org.apache.bcel.generic

## Class CodeExceptionGen

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

- All Implemented Interfaces:
    Cloneable, InstructionTargeter

      public final class CodeExceptionGen
      extends Object
      implements InstructionTargeter, Cloneable

  This class represents an exception handler, i.e., specifies the region where a handler is active and an instruction where the actual handling is done. pool as parameters. Opposed to the JVM specification the end of the handled region is set to be inclusive, i.e. all instructions between start and end are protected including the start and end instructions (handles) themselves. The end of the region is automatically mapped to be exclusive when calling getCodeException(), i.e., there is no difference semantically.
  See Also:
    `MethodGen`, `CodeException`, `InstructionHandle`

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `CodeExceptionGen(InstructionHandle startPc, InstructionHandle endPc, InstructionHandle handlerPc, ObjectType catchType)` Add an exception handler, i.e., specify region where a handler is active and an instruction where the actual handling is done.

  - ### 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.
    `ObjectType` | `getCatchType()` Gets the type of the Exception to catch, 'null' for ANY.
    `CodeException` | `getCodeException(ConstantPoolGen cp)` Get CodeException object. This relies on that the instruction list has already been dumped to byte code or that the `setPositions' methods has been called for the instruction list.
    `InstructionHandle` | `getEndPC()`
    `InstructionHandle` | `getHandlerPC()`
    `InstructionHandle` | `getStartPC()`
    `void` | `setCatchType(ObjectType catchType)` Sets the type of the Exception to catch.
    `void` | `setEndPC(InstructionHandle end_pc)`
    `void` | `setHandlerPC(InstructionHandle handler_pc)`
    `void` | `setStartPC(InstructionHandle start_pc)`
    `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

      `equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

- - ### Constructor Detail

    - #### CodeExceptionGen

          public CodeExceptionGen(InstructionHandle startPc,
                                  InstructionHandle endPc,
                                  InstructionHandle handlerPc,
                                  ObjectType catchType)

      Add an exception handler, i.e., specify region where a handler is active and an instruction where the actual handling is done.
      Parameters:
        `startPc` - Start of handled region (inclusive)
        `endPc` - End of handled region (inclusive)
        `handlerPc` - Where handling is done
        `catchType` - which exception is handled, null for ANY

  - ### Method Detail

    - #### clone

          public Object clone()

      Overrides:
        `clone` in class `Object`

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

    - #### getCatchType

          public ObjectType getCatchType()

      Gets the type of the Exception to catch, 'null' for ANY.

    - #### getCodeException

          public CodeException getCodeException(ConstantPoolGen cp)

      Get CodeException object.
      This relies on that the instruction list has already been dumped to byte code or that the `setPositions' methods has been called for the instruction list.
      Parameters:
        `cp` - constant pool

    - #### getEndPC

          public InstructionHandle getEndPC()

      Returns:
        end of handled region (inclusive)

    - #### getHandlerPC

          public InstructionHandle getHandlerPC()

      Returns:
        start of handler

    - #### getStartPC

          public InstructionHandle getStartPC()

      Returns:
        start of handled region (inclusive)

    - #### setCatchType

          public void setCatchType(ObjectType catchType)

      Sets the type of the Exception to catch. Set 'null' for ANY.

    - #### setEndPC

          public void setEndPC(InstructionHandle end_pc)

    - #### setHandlerPC

          public void setHandlerPC(InstructionHandle handler_pc)

    - #### setStartPC

          public void setStartPC(InstructionHandle start_pc)

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

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

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