org.apache.bcel.generic

## Class MethodGen

- java.lang.Object
- - org.apache.bcel.classfile.AccessFlags
  - - org.apache.bcel.generic.FieldGenOrMethodGen
    - - org.apache.bcel.generic.MethodGen

- All Implemented Interfaces:
    Cloneable, NamedAndTyped

      public class MethodGen
      extends FieldGenOrMethodGen

  Template class for building up a method. This is done by defining exception handlers, adding thrown exceptions, local variables and attributes, whereas the `LocalVariableTable' and `LineNumberTable' attributes will be set automatically for the code. Use stripAttributes() if you don't like this. While generating code it may be necessary to insert NOP operations. You can use the `removeNOPs' method to get rid off them. The resulting method object can be obtained via the `getMethod()' method.
  See Also:
    `InstructionList`, `Method`

- - ### Field Summary

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

      `cp, name, type`

    - ### Fields inherited from class org.apache.bcel.classfile.AccessFlags

      `access_flags`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `MethodGen(int accessFlags, Type returnType, Type[] argTypes, String[] argNames, String methodName, String className, InstructionList il, ConstantPoolGen cp)` Declare method.
    `MethodGen(Method method, String className, ConstantPoolGen cp)` Instantiate from existing method.

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addAnnotationsAsAttribute(ConstantPoolGen cp)`
    `void` | `addCodeAttribute(Attribute a)` Add an attribute to the code.
    `void` | `addException(String className)` Add an exception possibly thrown by this method.
    `CodeExceptionGen` | `addExceptionHandler(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.
    `LineNumberGen` | `addLineNumber(InstructionHandle ih, int srcLine)` Give an instruction a line number corresponding to the source code line.
    `LocalVariableGen` | `addLocalVariable(String name, Type type, InstructionHandle start, InstructionHandle end)` Adds a local variable to this method and assigns an index automatically.
    `LocalVariableGen` | `addLocalVariable(String name, Type type, int slot, InstructionHandle start, InstructionHandle end)` Adds a local variable to this method.
    `LocalVariableGen` | `addLocalVariable(String name, Type type, int slot, InstructionHandle start, InstructionHandle end, int origIndex)` Adds a local variable to this method.
    `void` | `addObserver(MethodObserver o)` Add observer for this object.
    `void` | `addParameterAnnotation(int parameterIndex, AnnotationEntryGen annotation)`
    `void` | `addParameterAnnotationsAsAttribute(ConstantPoolGen cp)`
    `MethodGen` | `copy(String className, ConstantPoolGen cp)`
    `boolean` | `equals(Object obj)` Return value as defined by given BCELComparator strategy.
    `List<AnnotationEntryGen>` | `getAnnotationsOnParameter(int i)` Return a list of AnnotationGen objects representing parameter annotations
    `String` | `getArgumentName(int i)`
    `String[]` | `getArgumentNames()`
    `Type` | `getArgumentType(int i)`
    `Type[]` | `getArgumentTypes()`
    `String` | `getClassName()`
    `Attribute[]` | `getCodeAttributes()`
    `static BCELComparator` | `getComparator()`
    `CodeExceptionGen[]` | `getExceptionHandlers()`
    `String[]` | `getExceptions()`
    `InstructionList` | `getInstructionList()`
    `LineNumberGen[]` | `getLineNumbers()`
    `LineNumberTable` | `getLineNumberTable(ConstantPoolGen cp)`
    `LocalVariableGen[]` | `getLocalVariables()`
    `LocalVariableTable` | `getLocalVariableTable(ConstantPoolGen cp)`
    `LocalVariableTypeTable` | `getLocalVariableTypeTable()`
    `int` | `getMaxLocals()`
    `int` | `getMaxStack()`
    `static int` | `getMaxStack(ConstantPoolGen cp, InstructionList il, CodeExceptionGen[] et)` Computes stack usage of an instruction list by performing control flow analysis.
    `Method` | `getMethod()` Get method object.
    `Type` | `getReturnType()`
    `String` | `getSignature()`
    `int` | `hashCode()` Return value as defined by given BCELComparator strategy.
    `void` | `removeCodeAttribute(Attribute a)` Remove a code attribute.
    `void` | `removeCodeAttributes()` Remove all code attributes.
    `void` | `removeException(String c)` Remove an exception.
    `void` | `removeExceptionHandler(CodeExceptionGen c)` Remove an exception handler.
    `void` | `removeExceptionHandlers()` Remove all line numbers.
    `void` | `removeExceptions()` Remove all exceptions.
    `void` | `removeLineNumber(LineNumberGen l)` Remove a line number.
    `void` | `removeLineNumbers()` Remove all line numbers.
    `void` | `removeLocalVariable(LocalVariableGen l)` Remove a local variable, its slot will not be reused, if you do not use addLocalVariable with an explicit index argument.
    `void` | `removeLocalVariables()` Remove all local variables.
    `void` | `removeLocalVariableTypeTable()` Remove the LocalVariableTypeTable
    `void` | `removeNOPs()` Remove all NOPs from the instruction list (if possible) and update every object referring to them, i.e., branch instructions, local variables and exception handlers.
    `void` | `removeObserver(MethodObserver o)` Remove observer for this object.
    `void` | `removeRuntimeAttributes(Attribute[] attrs)` Would prefer to make this private, but need a way to test if client is using BCEL version 6.5.0 or later that contains fix for BCEL-329.
    `void` | `setArgumentName(int i, String name)`
    `void` | `setArgumentNames(String[] argNames)`
    `void` | `setArgumentType(int i, Type type)`
    `void` | `setArgumentTypes(Type[] argTypes)`
    `void` | `setClassName(String className)`
    `static void` | `setComparator(BCELComparator comparator)`
    `void` | `setInstructionList(InstructionList il)`
    `void` | `setMaxLocals()` Compute maximum number of local variables.
    `void` | `setMaxLocals(int m)` Set maximum number of local variables.
    `void` | `setMaxStack()` Computes max.
    `void` | `setMaxStack(int m)` Set maximum stack size for this method.
    `void` | `setReturnType(Type returnType)`
    `void` | `stripAttributes(boolean flag)` Do not/Do produce attributes code attributesLineNumberTable and LocalVariableTable, like javac -O
    `String` | `toString()` Return string representation close to declaration format, `public static void main(String[]) throws IOException', e.g.
    `void` | `update()` Call notify() method on all observers.

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

      `addAll, addAnnotationEntry, addAttribute, clone, getAnnotationEntries, getAttributes, getConstantPool, getName, getType, removeAnnotationEntries, removeAnnotationEntry, removeAttribute, removeAttributes, setConstantPool, setName, setType`

    - ### Methods inherited from class org.apache.bcel.classfile.AccessFlags

      `getAccessFlags, getModifiers, isAbstract, isAbstract, isAnnotation, isAnnotation, isEnum, isEnum, isFinal, isFinal, isInterface, isInterface, isNative, isNative, isPrivate, isPrivate, isProtected, isProtected, isPublic, isPublic, isStatic, isStatic, isStrictfp, isStrictfp, isSynchronized, isSynchronized, isSynthetic, isSynthetic, isTransient, isTransient, isVarArgs, isVarArgs, isVolatile, isVolatile, setAccessFlags, setModifiers`

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

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

- - ### Constructor Detail

    - #### MethodGen

          public MethodGen(int accessFlags,
                           Type returnType,
                           Type[] argTypes,
                           String[] argNames,
                           String methodName,
                           String className,
                           InstructionList il,
                           ConstantPoolGen cp)

      Declare method. If the method is non-static the constructor automatically declares a local variable `$this' in slot 0. The actual code is contained in the `il' parameter, which may further manipulated by the user. But they must take care not to remove any instruction (handles) that are still referenced from this object. For example one may not add a local variable and later remove the instructions it refers to without causing havoc. It is safe however if you remove that local variable, too.
      Parameters:
        `accessFlags` - access qualifiers
        `returnType` - method type
        `argTypes` - argument types
        `argNames` - argument names (if this is null, default names will be provided for them)
        `methodName` - name of method
        `className` - class name containing this method (may be null, if you don't care)
        `il` - instruction list associated with this method, may be null only for abstract or native methods
        `cp` - constant pool

    - #### MethodGen

          public MethodGen(Method method,
                           String className,
                           ConstantPoolGen cp)

      Instantiate from existing method.
      Parameters:
        `method` - method
        `className` - class name containing this method
        `cp` - constant pool

  - ### Method Detail

    - #### getComparator

          public static BCELComparator getComparator()

      Returns:
        Comparison strategy object

    - #### getMaxStack

          public static int getMaxStack(ConstantPoolGen cp,
                                        InstructionList il,
                                        CodeExceptionGen[] et)

      Computes stack usage of an instruction list by performing control flow analysis.
      Returns:
        maximum stack depth used by method

    - #### setComparator

          public static void setComparator(BCELComparator comparator)

      Parameters:
        `comparator` - Comparison strategy object

    - #### addAnnotationsAsAttribute

          public void addAnnotationsAsAttribute(ConstantPoolGen cp)

      Since:
        6.0

    - #### addCodeAttribute

          public void addCodeAttribute(Attribute a)

      Add an attribute to the code. Currently, the JVM knows about the LineNumberTable, LocalVariableTable and StackMap attributes, where the former two will be generated automatically and the latter is used for the MIDP only. Other attributes will be ignored by the JVM but do no harm.
      Parameters:
        `a` - attribute to be added

    - #### addException

          public void addException(String className)

      Add an exception possibly thrown by this method.
      Parameters:
        `className` - (fully qualified) name of exception

    - #### addExceptionHandler

          public CodeExceptionGen addExceptionHandler(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 region (inclusive)
        `endPc` - End of region (inclusive)
        `handlerPc` - Where handling is done
        `catchType` - class type of handled exception or null if any exception is handled
      Returns:
        new exception handler object

    - #### addLineNumber

          public LineNumberGen addLineNumber(InstructionHandle ih,
                                             int srcLine)

      Give an instruction a line number corresponding to the source code line.
      Parameters:
        `ih` - instruction to tag
      Returns:
        new line number object
      See Also:
        `LineNumber`

    - #### addLocalVariable

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

      Adds a local variable to this method and assigns an index automatically.
      Parameters:
        `name` - variable name
        `type` - variable type
        `start` - from where the variable is valid, if this is null, it is valid from the start
        `end` - until where the variable is valid, if this is null, it is valid to the end
      Returns:
        new local variable object
      See Also:
        `LocalVariable`

    - #### addLocalVariable

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

      Adds a local variable to this method.
      Parameters:
        `name` - variable name
        `type` - variable type
        `slot` - the index of the local variable, if type is long or double, the next available index is slot+2
        `start` - from where the variable is valid
        `end` - until where the variable is valid
      Returns:
        new local variable object
      See Also:
        `LocalVariable`

    - #### addLocalVariable

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

      Adds a local variable to this method.
      Parameters:
        `name` - variable name
        `type` - variable type
        `slot` - the index of the local variable, if type is long or double, the next available index is slot+2
        `start` - from where the variable is valid
        `end` - until where the variable is valid
        `origIndex` - the index of the local variable prior to any modifications
      Returns:
        new local variable object
      See Also:
        `LocalVariable`

    - #### addObserver

          public void addObserver(MethodObserver o)

      Add observer for this object.

    - #### addParameterAnnotation

          public void addParameterAnnotation(int parameterIndex,
                                             AnnotationEntryGen annotation)

    - #### addParameterAnnotationsAsAttribute

          public void addParameterAnnotationsAsAttribute(ConstantPoolGen cp)

      Since:
        6.0

    - #### copy

          public MethodGen copy(String className,
                                ConstantPoolGen cp)

      Returns:
        deep copy of this method

    - #### equals

          public boolean equals(Object obj)

      Return value as defined by given BCELComparator strategy. By default two MethodGen objects are said to be equal when their names and signatures are equal.
      Overrides:
        `equals` in class `Object`
      See Also:
        `Object.equals(Object)`

    - #### getAnnotationsOnParameter

          public List<AnnotationEntryGen> getAnnotationsOnParameter(int i)

      Return a list of AnnotationGen objects representing parameter annotations
      Since:
        6.0

    - #### getArgumentName

          public String getArgumentName(int i)

    - #### getArgumentNames

          public String[] getArgumentNames()

    - #### getArgumentType

          public Type getArgumentType(int i)

    - #### getArgumentTypes

          public Type[] getArgumentTypes()

    - #### getClassName

          public String getClassName()

      Returns:
        class that contains this method

    - #### getCodeAttributes

          public Attribute[] getCodeAttributes()

      Returns:
        all attributes of this method.

    - #### getExceptionHandlers

          public CodeExceptionGen[] getExceptionHandlers()

    - #### getExceptions

          public String[] getExceptions()

    - #### getInstructionList

          public InstructionList getInstructionList()

    - #### getLineNumbers

          public LineNumberGen[] getLineNumbers()

    - #### getLineNumberTable

          public LineNumberTable getLineNumberTable(ConstantPoolGen cp)

      Returns:
        `LineNumberTable' attribute of all the local variables of this method.

    - #### getLocalVariables

          public LocalVariableGen[] getLocalVariables()

    - #### getLocalVariableTable

          public LocalVariableTable getLocalVariableTable(ConstantPoolGen cp)

      Returns:
        `LocalVariableTable' attribute of all the local variables of this method.

    - #### getLocalVariableTypeTable

          public LocalVariableTypeTable getLocalVariableTypeTable()

      Returns:
        `LocalVariableTypeTable' attribute of this method.

    - #### getMaxLocals

          public int getMaxLocals()

    - #### getMaxStack

          public int getMaxStack()

    - #### getMethod

          public Method getMethod()

      Get method object. Never forget to call setMaxStack() or setMaxStack(max), respectively, before calling this method (the same applies for max locals).
      Returns:
        method object

    - #### getReturnType

          public Type getReturnType()

    - #### getSignature

          public String getSignature()

      Specified by:
        `getSignature` in class `FieldGenOrMethodGen`
      Returns:
        signature of method/field.

    - #### hashCode

          public int hashCode()

      Return value as defined by given BCELComparator strategy. By default return the hashcode of the method's name XOR signature.
      Overrides:
        `hashCode` in class `Object`
      See Also:
        `Object.hashCode()`

    - #### removeCodeAttribute

          public void removeCodeAttribute(Attribute a)

      Remove a code attribute.

    - #### removeCodeAttributes

          public void removeCodeAttributes()

      Remove all code attributes.

    - #### removeException

          public void removeException(String c)

      Remove an exception.

    - #### removeExceptionHandler

          public void removeExceptionHandler(CodeExceptionGen c)

      Remove an exception handler.

    - #### removeExceptionHandlers

          public void removeExceptionHandlers()

      Remove all line numbers.

    - #### removeExceptions

          public void removeExceptions()

      Remove all exceptions.

    - #### removeLineNumber

          public void removeLineNumber(LineNumberGen l)

      Remove a line number.

    - #### removeLineNumbers

          public void removeLineNumbers()

      Remove all line numbers.

    - #### removeLocalVariable

          public void removeLocalVariable(LocalVariableGen l)

      Remove a local variable, its slot will not be reused, if you do not use addLocalVariable with an explicit index argument.

    - #### removeLocalVariables

          public void removeLocalVariables()

      Remove all local variables.

    - #### removeLocalVariableTypeTable

          public void removeLocalVariableTypeTable()

      Remove the LocalVariableTypeTable

    - #### removeNOPs

          public void removeNOPs()

      Remove all NOPs from the instruction list (if possible) and update every object referring to them, i.e., branch instructions, local variables and exception handlers.

    - #### removeObserver

          public void removeObserver(MethodObserver o)

      Remove observer for this object.

    - #### removeRuntimeAttributes

          public void removeRuntimeAttributes(Attribute[] attrs)

      Would prefer to make this private, but need a way to test if client is using BCEL version 6.5.0 or later that contains fix for BCEL-329.
      Since:
        6.5.0

    - #### setArgumentName

          public void setArgumentName(int i,
                                      String name)

    - #### setArgumentNames

          public void setArgumentNames(String[] argNames)

    - #### setArgumentType

          public void setArgumentType(int i,
                                      Type type)

    - #### setArgumentTypes

          public void setArgumentTypes(Type[] argTypes)

    - #### setClassName

          public void setClassName(String className)

    - #### setInstructionList

          public void setInstructionList(InstructionList il)

    - #### setMaxLocals

          public void setMaxLocals()

      Compute maximum number of local variables.

    - #### setMaxLocals

          public void setMaxLocals(int m)

      Set maximum number of local variables.

    - #### setMaxStack

          public void setMaxStack()

      Computes max. stack size by performing control flow analysis.

    - #### setMaxStack

          public void setMaxStack(int m)

      Set maximum stack size for this method.

    - #### setReturnType

          public void setReturnType(Type returnType)

    - #### stripAttributes

          public void stripAttributes(boolean flag)

      Do not/Do produce attributes code attributesLineNumberTable and LocalVariableTable, like javac -O

    - #### toString

          public final String toString()

      Return string representation close to declaration format, `public static void main(String[]) throws IOException', e.g.
      Overrides:
        `toString` in class `Object`
      Returns:
        String representation of the method.

    - #### update

          public void update()

      Call notify() method on all observers. This method is not called automatically whenever the state has changed, but has to be called by the user after they have finished editing the object.

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