org.apache.bcel.generic

## Class LocalVariableGen

- java.lang.Object
- - org.apache.bcel.generic.LocalVariableGen

- All Implemented Interfaces:
    Cloneable, InstructionTargeter, NamedAndTyped

      public class LocalVariableGen
      extends Object
      implements InstructionTargeter, NamedAndTyped, Cloneable

  Represents a local variable within a method. It contains its scope, name and type. The generated LocalVariable object can be obtained with getLocalVariable which needs the instruction list and the constant pool as parameters.
  See Also:
    `LocalVariable`, `MethodGen`

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `LocalVariableGen(int index, String name, Type type, InstructionHandle start, InstructionHandle end)` Generate a local variable that with index `index'.
    `LocalVariableGen(int index, String name, Type type, InstructionHandle start, InstructionHandle end, int origIndex)` Generates a local variable that with index `index'.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `Object` | `clone()`
    `boolean` | `containsTarget(InstructionHandle ih)` Checks whether this targeter targets the specified instruction handle.
    `boolean` | `equals(Object o)` We consider to local variables to be equal, if the use the same index and are valid in the same range.
    `InstructionHandle` | `getEnd()`
    `int` | `getIndex()`
    `boolean` | `getLiveToEnd()`
    `LocalVariable` | `getLocalVariable(ConstantPoolGen cp)` Gets LocalVariable object.
    `String` | `getName()`
    `int` | `getOrigIndex()`
    `InstructionHandle` | `getStart()`
    `Type` | `getType()`
    `int` | `hashCode()`
    `void` | `setEnd(InstructionHandle end)`
    `void` | `setIndex(int index)`
    `void` | `setLiveToEnd(boolean live_to_end)`
    `void` | `setName(String name)`
    `void` | `setStart(InstructionHandle start)`
    `void` | `setType(Type type)`
    `String` | `toString()`
    `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 java.lang.Object

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

- - ### Constructor Detail

    - #### LocalVariableGen

          public LocalVariableGen(int index,
                                  String name,
                                  Type type,
                                  InstructionHandle start,
                                  InstructionHandle end)

      Generate a local variable that with index `index'. Note that double and long variables need two indexs. Index indices have to be provided by the user.
      Parameters:
        `index` - index of local variable
        `name` - its name
        `type` - its type
        `start` - from where the instruction is valid (null means from the start)
        `end` - until where the instruction is valid (null means to the end)

    - #### LocalVariableGen

          public LocalVariableGen(int index,
                                  String name,
                                  Type type,
                                  InstructionHandle start,
                                  InstructionHandle end,
                                  int origIndex)

      Generates a local variable that with index `index'. Note that double and long variables need two indexs. Index indices have to be provided by the user.
      Parameters:
        `index` - index of local variable
        `name` - its name
        `type` - its type
        `start` - from where the instruction is valid (null means from the start)
        `end` - until where the instruction is valid (null means to the end)
        `origIndex` - index of local variable prior to any changes to index

  - ### Method Detail

    - #### getLocalVariable

          public LocalVariable getLocalVariable(ConstantPoolGen cp)

      Gets LocalVariable object. This relies on that the instruction list has already been dumped to byte code or or that the `setPositions' methods has been called for the instruction list. Note that due to the conversion from byte code offset to InstructionHandle, it is impossible to tell the difference between a live range that ends BEFORE the last insturction of the method or a live range that ends AFTER the last instruction of the method. Hence the liveToEnd flag to differentiate between these two cases.
      Parameters:
        `cp` - constant pool

    - #### setIndex

          public void setIndex(int index)

    - #### getIndex

          public int getIndex()

    - #### getOrigIndex

          public int getOrigIndex()

    - #### setLiveToEnd

          public void setLiveToEnd(boolean live_to_end)

    - #### getLiveToEnd

          public boolean getLiveToEnd()

    - #### setName

          public void setName(String name)

      Specified by:
        `setName` in interface `NamedAndTyped`

    - #### getName

          public String getName()

      Specified by:
        `getName` in interface `NamedAndTyped`

    - #### setType

          public void setType(Type type)

      Specified by:
        `setType` in interface `NamedAndTyped`

    - #### getType

          public Type getType()

      Specified by:
        `getType` in interface `NamedAndTyped`

    - #### getStart

          public InstructionHandle getStart()

    - #### getEnd

          public InstructionHandle getEnd()

    - #### setStart

          public void setStart(InstructionHandle start)

    - #### setEnd

          public void setEnd(InstructionHandle end)

    - #### 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, either start or end
        `new_ih` - new target

    - #### 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 variable

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `Object`

    - #### equals

          public boolean equals(Object o)

      We consider to local variables to be equal, if the use the same index and are valid in the same range.
      Overrides:
        `equals` in class `Object`

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

    - #### clone

          public Object clone()

      Overrides:
        `clone` in class `Object`

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