org.apache.bcel.generic

## Class BranchInstruction

- java.lang.Object
- - org.apache.bcel.generic.Instruction
  - - org.apache.bcel.generic.BranchInstruction

- All Implemented Interfaces:
    Cloneable, InstructionTargeter
  Direct Known Subclasses:
    GotoInstruction, IfInstruction, JsrInstruction, Select

      public abstract class BranchInstruction
      extends Instruction
      implements InstructionTargeter

  Abstract super class for branching instructions like GOTO, IFEQ, etc.. Branch instructions may have a variable length, namely GOTO, JSR, LOOKUPSWITCH and TABLESWITCH.
  See Also:
    `InstructionList`

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected int` | `index` Deprecated. (since 6.0) will be made private; do not access directly, use getter/setter
    `protected int` | `position` Deprecated. (since 6.0) will be made private; do not access directly, use getter/setter
    `protected InstructionHandle` | `target` Deprecated. (since 6.0) will be made private; do not access directly, use getter/setter

    - ### Fields inherited from class org.apache.bcel.generic.Instruction

      `length, opcode`

  - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `protected` | `BranchInstruction(short opcode, InstructionHandle target)` Common super constructor

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `containsTarget(InstructionHandle ih)` Checks whether this targeter targets the specified instruction handle.
    `void` | `dump(DataOutputStream out)` Dump instruction as byte code to stream out.
    `int` | `getIndex()`
    `protected int` | `getPosition()`
    `InstructionHandle` | `getTarget()`
    `protected int` | `getTargetOffset()`
    `protected int` | `getTargetOffset(InstructionHandle target)`
    `protected void` | `initFromFile(ByteSequence bytes, boolean wide)` Read needed data (e.g.
    `protected void` | `setIndex(int index)`
    `protected void` | `setPosition(int position)`
    `void` | `setTarget(InstructionHandle target)` Set branch target
    `String` | `toString(boolean verbose)` Long output format: <position in byte code> <name of opcode> "["<opcode number>"]" "("<length of instruction>")" "<"<target instruction>">" "@"<branch target offset>
    `protected int` | `updatePosition(int offset, int max_offset)` Called by InstructionList.setPositions when setting the position for every instruction.
    `void` | `updateTarget(InstructionHandle old_ih, InstructionHandle new_ih)` Replaces the target of this targeter from this old handle to the new handle.

    - ### Methods inherited from class org.apache.bcel.generic.Instruction

      `accept, consumeStack, copy, equals, getComparator, getLength, getName, getOpcode, hashCode, isValidByte, isValidShort, produceStack, readInstruction, setComparator, toString, toString`

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

- - ### Field Detail

    - #### index

          @Deprecated
          protected int index

      Deprecated. (since 6.0) will be made private; do not access directly, use getter/setter

    - #### target

          @Deprecated
          protected InstructionHandle target

      Deprecated. (since 6.0) will be made private; do not access directly, use getter/setter

    - #### position

          @Deprecated
          protected int position

      Deprecated. (since 6.0) will be made private; do not access directly, use getter/setter

  - ### Constructor Detail

    - #### BranchInstruction

          protected BranchInstruction(short opcode,
                                      InstructionHandle target)

      Common super constructor
      Parameters:
        `opcode` - Instruction opcode
        `target` - instruction to branch to

  - ### Method Detail

    - #### containsTarget

          public boolean containsTarget(InstructionHandle ih)

      Description copied from interface: `InstructionTargeter`
      Checks whether this targeter targets the specified instruction handle.
      Specified by:
        `containsTarget` in interface `InstructionTargeter`
      Returns:
        true, if ih is target of this instruction

    - #### dump

          public void dump(DataOutputStream out)
                    throws IOException

      Dump instruction as byte code to stream out.
      Overrides:
        `dump` in class `Instruction`
      Parameters:
        `out` - Output stream
      Throws:
        `IOException`

    - #### getIndex

          public final int getIndex()

      Returns:
        target offset in byte code

    - #### getPosition

          protected int getPosition()

      Returns:
        the position
      Since:
        6.0

    - #### getTarget

          public InstructionHandle getTarget()

      Returns:
        target of branch instruction

    - #### getTargetOffset

          protected int getTargetOffset()

      Returns:
        the offset to this instruction's target

    - #### getTargetOffset

          protected int getTargetOffset(InstructionHandle target)

      Parameters:
        `target` - branch target
      Returns:
        the offset to `target' relative to this instruction

    - #### initFromFile

          protected void initFromFile(ByteSequence bytes,
                                      boolean wide)
                               throws IOException

      Read needed data (e.g. index) from file. Conversion to a InstructionHandle is done in InstructionList(byte[]).
      Overrides:
        `initFromFile` in class `Instruction`
      Parameters:
        `bytes` - input stream
        `wide` - wide prefix?
      Throws:
        `IOException` - may be thrown if the implementation needs to read data from the file
      See Also:
        `InstructionList`

    - #### setIndex

          protected void setIndex(int index)

      Parameters:
        `index` - the index to set
      Since:
        6.0

    - #### setPosition

          protected void setPosition(int position)

      Parameters:
        `position` - the position to set
      Since:
        6.0

    - #### setTarget

          public void setTarget(InstructionHandle target)

      Set branch target
      Parameters:
        `target` - branch target

    - #### toString

          public String toString(boolean verbose)

      Long output format: <position in byte code> <name of opcode> "["<opcode number>"]" "("<length of instruction>")" "<"<target instruction>">" "@"<branch target offset>
      Overrides:
        `toString` in class `Instruction`
      Parameters:
        `verbose` - long/short format switch
      Returns:
        mnemonic for instruction

    - #### updatePosition

          protected int updatePosition(int offset,
                                       int max_offset)

      Called by InstructionList.setPositions when setting the position for every instruction. In the presence of variable length instructions `setPositions' performs multiple passes over the instruction list to calculate the correct (byte) positions and offsets by calling this function.
      Parameters:
        `offset` - additional offset caused by preceding (variable length) instructions
        `max_offset` - the maximum offset that may be caused by these instructions
      Returns:
        additional offset caused by possible change of this instruction's length

    - #### updateTarget

          public void updateTarget(InstructionHandle old_ih,
                                   InstructionHandle new_ih)

      Description copied from interface: `InstructionTargeter`
      Replaces the target of this targeter from this old handle to the new handle.
      Specified by:
        `updateTarget` in interface `InstructionTargeter`
      Parameters:
        `old_ih` - old target
        `new_ih` - new target

Copyright © 2004–2022 The Apache Software Foundation. All rights reserved.