## Uses of Class
org.apache.bcel.generic.InstructionHandle

Packages that use InstructionHandle
org.apache.bcel.generic: This package contains the "generic" part of the Byte Code Engineering Library, i.e., classes to dynamically modify class objects and byte code instructions.
org.apache.bcel.util: This package contains utility classes for the Byte Code Engineering Library, namely:
org.apache.bcel.verifier.structurals: Provides a PassVerifier class mostly used internally by JustIce, yielding a control flow graph for public use as a nice side effect.

Uses of InstructionHandle in org.apache.bcel.generic

Subclasses of InstructionHandle in org.apache.bcel.generic
`class` `BranchHandle` BranchHandle is returned by specialized InstructionList.append() whenever a BranchInstruction is appended.

Fields in org.apache.bcel.generic declared as InstructionHandle
`protected InstructionHandle` `BranchInstruction.target`
`protected InstructionHandle[]` `Select.targets`

Methods in org.apache.bcel.generic that return InstructionHandle
`InstructionHandle` `InstructionList.append(CompoundInstruction c)` Append a compound instruction.
`InstructionHandle` `InstructionList.append(Instruction i)` Append an instruction to the end of this list.
`InstructionHandle` `InstructionList.append(Instruction i, CompoundInstruction c)` Append a compound instruction, after instruction i.
`InstructionHandle` `InstructionList.append(InstructionHandle ih, CompoundInstruction c)` Append a compound instruction.
`InstructionHandle` `InstructionList.append(InstructionHandle ih, Instruction i)` Append an instruction after instruction (handle) ih contained in this list.
`InstructionHandle` `InstructionList.append(InstructionHandle ih, InstructionList il)` Append another list after instruction (handle) ih contained in this list.
`InstructionHandle` `InstructionList.append(Instruction i, Instruction j)` Append a single instruction j after another instruction i, which must be in this list of course!
`InstructionHandle` `InstructionList.append(Instruction i, InstructionList il)` Append another list after instruction i contained in this list.
`InstructionHandle` `InstructionList.append(InstructionList il)` Append another list to this one.
`static InstructionHandle` `InstructionList.findHandle(InstructionHandle[] ihs, int[] pos, int count, int target)` Find the target instruction (handle) that corresponds to the given target position (byte code offset).
`InstructionHandle` `InstructionList.findHandle(int pos)` Get instruction handle for instruction at byte code position pos.
`InstructionHandle` `LocalVariableGen.getEnd()`
`InstructionHandle` `InstructionList.getEnd()`
`InstructionHandle` `CodeExceptionGen.getEndPC()`
`InstructionHandle` `CodeExceptionGen.getHandlerPC()`
`InstructionHandle` `LineNumberGen.getInstruction()`
`InstructionHandle[]` `InstructionList.getInstructionHandles()`
`InstructionHandle` `InstructionHandle.getNext()`
`InstructionHandle` `InstructionHandle.getPrev()`
`InstructionHandle` `LocalVariableGen.getStart()`
`InstructionHandle` `InstructionList.getStart()`
`InstructionHandle` `CodeExceptionGen.getStartPC()`
`InstructionHandle` `ReturnaddressType.getTarget()`
`InstructionHandle` `BranchInstruction.getTarget()`
`InstructionHandle` `BranchHandle.getTarget()`
`InstructionHandle[]` `TargetLostException.getTargets()`
`InstructionHandle[]` `Select.getTargets()`
`InstructionHandle` `InstructionList.insert(CompoundInstruction c)` Insert a compound instruction.
`InstructionHandle` `InstructionList.insert(Instruction i)` Insert an instruction at start of this list.
`InstructionHandle` `InstructionList.insert(Instruction i, CompoundInstruction c)` Insert a compound instruction before instruction i.
`InstructionHandle` `InstructionList.insert(InstructionHandle ih, CompoundInstruction c)` Insert a compound instruction.
`InstructionHandle` `InstructionList.insert(InstructionHandle ih, Instruction i)` Insert an instruction before instruction (handle) ih contained in this list.
`InstructionHandle` `InstructionList.insert(InstructionHandle ih, InstructionList il)` Insert another list before Instruction handle ih contained in this list.
`InstructionHandle` `InstructionList.insert(Instruction i, Instruction j)` Insert a single instruction j before another instruction i, which must be in this list of course!
`InstructionHandle` `InstructionList.insert(Instruction i, InstructionList il)` Insert another list before Instruction i contained in this list.
`InstructionHandle` `InstructionList.insert(InstructionList il)` Insert another list.
`InstructionHandle` `JsrInstruction.physicalSuccessor()` Returns an InstructionHandle to the physical successor of this JsrInstruction.

Methods in org.apache.bcel.generic with parameters of type InstructionHandle
`CodeExceptionGen` `MethodGen.addExceptionHandler(InstructionHandle start_pc, InstructionHandle end_pc, InstructionHandle handler_pc, ObjectType catch_type)` Add an exception handler, i.e., specify region where a handler is active and an instruction where the actual handling is done.
`LineNumberGen` `MethodGen.addLineNumber(InstructionHandle ih, int src_line)` Give an instruction a line number corresponding to the source code line.
`LocalVariableGen` `MethodGen.addLocalVariable(String name, Type type, InstructionHandle start, InstructionHandle end)` Adds a local variable to this method and assigns an index automatically.
`LocalVariableGen` `MethodGen.addLocalVariable(String name, Type type, int slot, InstructionHandle start, InstructionHandle end)` Adds a local variable to this method.
`BranchHandle` `InstructionList.append(InstructionHandle ih, BranchInstruction i)` Append an instruction after instruction (handle) ih contained in this list.
`InstructionHandle` `InstructionList.append(InstructionHandle ih, CompoundInstruction c)` Append a compound instruction.
`InstructionHandle` `InstructionList.append(InstructionHandle ih, Instruction i)` Append an instruction after instruction (handle) ih contained in this list.
`InstructionHandle` `InstructionList.append(InstructionHandle ih, InstructionList il)` Append another list after instruction (handle) ih contained in this list.
`boolean` `InstructionList.contains(InstructionHandle i)`
`boolean` `Select.containsTarget(InstructionHandle ih)`
`boolean` `LocalVariableGen.containsTarget(InstructionHandle ih)`
`boolean` `LineNumberGen.containsTarget(InstructionHandle ih)`
`boolean` `InstructionTargeter.containsTarget(InstructionHandle ih)`
`boolean` `CodeExceptionGen.containsTarget(InstructionHandle ih)`
`boolean` `BranchInstruction.containsTarget(InstructionHandle ih)`
`static BranchInstruction` `InstructionFactory.createBranchInstruction(short opcode, InstructionHandle target)` Create branch instruction by given opcode, except LOOKUPSWITCH and TABLESWITCH.
`void` `InstructionList.delete(InstructionHandle ih)` Remove instruction from this list.
`void` `InstructionList.delete(InstructionHandle from, InstructionHandle to)` Remove instructions from instruction `from' to instruction `to' contained in this list.
`static InstructionHandle` `InstructionList.findHandle(InstructionHandle[] ihs, int[] pos, int count, int target)` Find the target instruction (handle) that corresponds to the given target position (byte code offset).
`protected int` `BranchInstruction.getTargetOffset(InstructionHandle _target)`
`BranchHandle` `InstructionList.insert(InstructionHandle ih, BranchInstruction i)` Insert an instruction before instruction (handle) ih contained in this list.
`InstructionHandle` `InstructionList.insert(InstructionHandle ih, CompoundInstruction c)` Insert a compound instruction.
`InstructionHandle` `InstructionList.insert(InstructionHandle ih, Instruction i)` Insert an instruction before instruction (handle) ih contained in this list.
`InstructionHandle` `InstructionList.insert(InstructionHandle ih, InstructionList il)` Insert another list before Instruction handle ih contained in this list.
`void` `InstructionList.move(InstructionHandle ih, InstructionHandle target)` Move a single instruction (handle) to a new location.
`void` `InstructionList.move(InstructionHandle start, InstructionHandle end, InstructionHandle target)` Take all instructions (handles) from "start" to "end" and append them after the new location "target".
`void` `InstructionList.redirectBranches(InstructionHandle old_target, InstructionHandle new_target)` Redirect all references from old_target to new_target, i.e., update targets of branch instructions.
`void` `InstructionList.redirectExceptionHandlers(CodeExceptionGen[] exceptions, InstructionHandle old_target, InstructionHandle new_target)` Redirect all references of exception handlers from old_target to new_target.
`void` `InstructionList.redirectLocalVariables(LocalVariableGen[] lg, InstructionHandle old_target, InstructionHandle new_target)` Redirect all references of local variables from old_target to new_target.
`void` `LocalVariableGen.setEnd(InstructionHandle end)`
`void` `CodeExceptionGen.setEndPC(InstructionHandle end_pc)`
`void` `CodeExceptionGen.setHandlerPC(InstructionHandle handler_pc)`
`void` `LineNumberGen.setInstruction(InstructionHandle ih)`
`void` `LocalVariableGen.setStart(InstructionHandle start)`
`void` `CodeExceptionGen.setStartPC(InstructionHandle start_pc)`
`void` `BranchInstruction.setTarget(InstructionHandle target)` Set branch target
`void` `BranchHandle.setTarget(InstructionHandle ih)` Pass new target to instruction.
`void` `Select.setTarget(int i, InstructionHandle target)` Set branch target for `i'th case
`void` `Select.updateTarget(InstructionHandle old_ih, InstructionHandle new_ih)`
`void` `LocalVariableGen.updateTarget(InstructionHandle old_ih, InstructionHandle new_ih)`
`void` `LineNumberGen.updateTarget(InstructionHandle old_ih, InstructionHandle new_ih)`
`void` `InstructionTargeter.updateTarget(InstructionHandle old_ih, InstructionHandle new_ih)`
`void` `CodeExceptionGen.updateTarget(InstructionHandle old_ih, InstructionHandle new_ih)`
`void` `BranchInstruction.updateTarget(InstructionHandle old_ih, InstructionHandle new_ih)`
`void` `BranchHandle.updateTarget(InstructionHandle old_ih, InstructionHandle new_ih)` Update target of instruction.

Constructors in org.apache.bcel.generic with parameters of type InstructionHandle
`BranchInstruction(short opcode, InstructionHandle target)` Common super constructor
`CodeExceptionGen(InstructionHandle start_pc, InstructionHandle end_pc, InstructionHandle handler_pc, ObjectType catch_type)` Add an exception handler, i.e., specify region where a handler is active and an instruction where the actual handling is done.
`GOTO_W(InstructionHandle target)`
`GOTO(InstructionHandle target)`
`IF_ACMPEQ(InstructionHandle target)`
`IF_ACMPNE(InstructionHandle target)`
`IF_ICMPEQ(InstructionHandle target)`
`IF_ICMPGE(InstructionHandle target)`
`IF_ICMPGT(InstructionHandle target)`
`IF_ICMPLE(InstructionHandle target)`
`IF_ICMPLT(InstructionHandle target)`
`IF_ICMPNE(InstructionHandle target)`
`IFEQ(InstructionHandle target)`
`IFGE(InstructionHandle target)`
`IFGT(InstructionHandle target)`
`IfInstruction(short opcode, InstructionHandle target)`
`IFLE(InstructionHandle target)`
`IFLT(InstructionHandle target)`
`IFNE(InstructionHandle target)`
`IFNONNULL(InstructionHandle target)`
`IFNULL(InstructionHandle target)`
`JSR_W(InstructionHandle target)`
`JSR(InstructionHandle target)`
`LineNumberGen(InstructionHandle ih, int src_line)` Create a line number.
`LocalVariableGen(int index, String name, Type type, InstructionHandle start, InstructionHandle end)` Generate a local variable that with index `index'.
`LOOKUPSWITCH(int[] match, InstructionHandle[] targets, InstructionHandle defaultTarget)`
`LOOKUPSWITCH(int[] match, InstructionHandle[] targets, InstructionHandle defaultTarget)`
`ReturnaddressType(InstructionHandle returnTarget)` Creates a ReturnaddressType object with a target.
`SWITCH(int[] match, InstructionHandle[] targets, InstructionHandle target)`
`SWITCH(int[] match, InstructionHandle[] targets, InstructionHandle target)`
`SWITCH(int[] match, InstructionHandle[] targets, InstructionHandle target, int max_gap)` Template for switch() constructs.
`SWITCH(int[] match, InstructionHandle[] targets, InstructionHandle target, int max_gap)` Template for switch() constructs.
`TABLESWITCH(int[] match, InstructionHandle[] targets, InstructionHandle defaultTarget)`
`TABLESWITCH(int[] match, InstructionHandle[] targets, InstructionHandle defaultTarget)`

Uses of InstructionHandle in org.apache.bcel.util

Methods in org.apache.bcel.util with parameters of type InstructionHandle
`boolean` `InstructionFinder.CodeConstraint.checkCode(InstructionHandle[] match)`
`Iterator` `InstructionFinder.search(String pattern, InstructionHandle from)` Start search beginning from `from'.
`Iterator` `InstructionFinder.search(String pattern, InstructionHandle from, InstructionFinder.CodeConstraint constraint)` Search for the given pattern in the instruction list.

Uses of InstructionHandle in org.apache.bcel.verifier.structurals

Methods in org.apache.bcel.verifier.structurals that return InstructionHandle
`InstructionHandle[]` `Subroutine.getEnteringJsrInstructions()` Returns all the JsrInstructions that have the first instruction of this subroutine as their target.
`InstructionHandle` `ExceptionHandler.getHandlerStart()` Returns the InstructionHandle where the handler starts off.
`InstructionHandle` `InstructionContext.getInstruction()` Returns the InstructionHandle this InstructionContext is wrapped around.
`InstructionHandle[]` `Subroutine.getInstructions()` Returns all instructions that together form this subroutine.
`InstructionHandle` `Subroutine.getLeavingRET()` Returns the one and only RET that leaves the subroutine.

Methods in org.apache.bcel.verifier.structurals with parameters of type InstructionHandle
`boolean` `Subroutine.contains(InstructionHandle inst)` Returns if the given InstructionHandle refers to an instruction that is part of this subroutine.
`InstructionContext` `ControlFlowGraph.contextOf(InstructionHandle inst)` Returns the InstructionContext of a given instruction.
`InstructionContext[]` `ControlFlowGraph.contextsOf(InstructionHandle[] insts)` Returns the InstructionContext[] of a given InstructionHandle[], in a naturally ordered manner.
`ExceptionHandler[]` `ExceptionHandlers.getExceptionHandlers(InstructionHandle ih)` Returns all the ExceptionHandler instances representing exception handlers that protect the instruction ih.
`Subroutine` `Subroutines.getSubroutine(InstructionHandle leader)` Returns the Subroutine object associated with the given leader (that is, the first instruction of the subroutine).
`boolean` `ControlFlowGraph.isDead(InstructionHandle i)` Returns true, if and only if the said instruction is not reachable; that means, if it is not part of this ControlFlowGraph.
`Subroutine` `Subroutines.subroutineOf(InstructionHandle any)` Returns the subroutine object associated with the given instruction.

Copyright © 2002-2006 Apache Software Foundation. All Rights Reserved.