## 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:
  Serializable, 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.

Version:
  $Id: MethodGen.java 386056 2006-03-15 11:31:56Z tcurdt $
See Also:
  `InstructionList`, `Method`, Serialized Form

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
`MethodGen(int access_flags, Type return_type, Type[] arg_types, String[] arg_names, String method_name, String class_name, InstructionList il, ConstantPoolGen cp)` Declare method.
`MethodGen(Method m, String class_name, ConstantPoolGen cp)` Instantiate from existing method.

Method Summary
`void` `addCodeAttribute(Attribute a)` Add an attribute to the code.
`void` `addException(String class_name)` Add an exception possibly thrown by this method.
`CodeExceptionGen` `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` `addLineNumber(InstructionHandle ih, int src_line)` 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.
`void` `addObserver(MethodObserver o)` Add observer for this object.
`MethodGen` `copy(String class_name, ConstantPoolGen cp)`
`boolean` `equals(Object obj)` Return value as defined by given BCELComparator strategy.
`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)`
`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` `removeNOPs()` Remove all NOPs from the instruction list (if possible) and update every object refering to them, i.e., branch instructions, local variables and exception handlers.
`void` `removeObserver(MethodObserver o)` Remove observer for this object.
`void` `setArgumentName(int i, String name)`
`void` `setArgumentNames(String[] arg_names)`
`void` `setArgumentType(int i, Type type)`
`void` `setArgumentTypes(Type[] arg_types)`
`void` `setClassName(String class_name)`
`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 return_type)`
`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
`addAttribute, clone, getAttributes, getConstantPool, getName, getType, 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, isVolatile, isVolatile, setAccessFlags, setModifiers`

Methods inherited from class java.lang.Object
`finalize, getClass, notify, notifyAll, wait, wait, wait`

Constructor Detail

### MethodGen

    public MethodGen(int access_flags,
                     Type return_type,
                     Type[] arg_types,
                     String[] arg_names,
                     String method_name,
                     String class_name,
                     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 he 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:
    `access_flags` - access qualifiers
    `return_type` - method type
    `arg_types` - argument types
    `arg_names` - argument names (if this is null, default names will be provided for them)
    `method_name` - name of method
    `class_name` - 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 m,
                     String class_name,
                     ConstantPoolGen cp)

  Instantiate from existing method.

  Parameters:
    `m` - method
    `class_name` - class name containing this method
    `cp` - constant pool

Method Detail

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

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

### getLocalVariables

    public LocalVariableGen[] getLocalVariables()

### getLocalVariableTable

    public LocalVariableTable getLocalVariableTable(ConstantPoolGen cp)

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

### addLineNumber

    public LineNumberGen addLineNumber(InstructionHandle ih,
                                       int src_line)

  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`

### removeLineNumber

    public void removeLineNumber(LineNumberGen l)

  Remove a line number.

### removeLineNumbers

    public void removeLineNumbers()

  Remove all line numbers.

### getLineNumbers

    public LineNumberGen[] getLineNumbers()

### getLineNumberTable

    public LineNumberTable getLineNumberTable(ConstantPoolGen cp)

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

### addExceptionHandler

    public CodeExceptionGen 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.

  Parameters:
    `start_pc` - Start of region (inclusive)
    `end_pc` - End of region (inclusive)
    `handler_pc` - Where handling is done
    `catch_type` - class type of handled exception or null if any exception is handled
  Returns:
    new exception handler object

### removeExceptionHandler

    public void removeExceptionHandler(CodeExceptionGen c)

  Remove an exception handler.

### removeExceptionHandlers

    public void removeExceptionHandlers()

  Remove all line numbers.

### getExceptionHandlers

    public CodeExceptionGen[] getExceptionHandlers()

### addException

    public void addException(String class_name)

  Add an exception possibly thrown by this method.

  Parameters:
    `class_name` - (fully qualified) name of exception

### removeException

    public void removeException(String c)

  Remove an exception.

### removeExceptions

    public void removeExceptions()

  Remove all exceptions.

### getExceptions

    public String[] getExceptions()

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

### removeCodeAttribute

    public void removeCodeAttribute(Attribute a)

  Remove a code attribute.

### removeCodeAttributes

    public void removeCodeAttributes()

  Remove all code attributes.

### getCodeAttributes

    public Attribute[] getCodeAttributes()

  Returns:
    all attributes of this method.

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

### removeNOPs

    public void removeNOPs()

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

### setMaxLocals

    public void setMaxLocals(int m)

  Set maximum number of local variables.

### getMaxLocals

    public int getMaxLocals()

### setMaxStack

    public void setMaxStack(int m)

  Set maximum stack size for this method.

### getMaxStack

    public int getMaxStack()

### getClassName

    public String getClassName()

  Returns:
    class that contains this method

### setClassName

    public void setClassName(String class_name)

### setReturnType

    public void setReturnType(Type return_type)

### getReturnType

    public Type getReturnType()

### setArgumentTypes

    public void setArgumentTypes(Type[] arg_types)

### getArgumentTypes

    public Type[] getArgumentTypes()

### setArgumentType

    public void setArgumentType(int i,
                                Type type)

### getArgumentType

    public Type getArgumentType(int i)

### setArgumentNames

    public void setArgumentNames(String[] arg_names)

### getArgumentNames

    public String[] getArgumentNames()

### setArgumentName

    public void setArgumentName(int i,
                                String name)

### getArgumentName

    public String getArgumentName(int i)

### getInstructionList

    public InstructionList getInstructionList()

### setInstructionList

    public void setInstructionList(InstructionList il)

### getSignature

    public String getSignature()

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

### setMaxStack

    public void setMaxStack()

  Computes max. stack size by performing control flow analysis.

### setMaxLocals

    public void setMaxLocals()

  Compute maximum number of local variables.

### stripAttributes

    public void stripAttributes(boolean flag)

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

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

### addObserver

    public void addObserver(MethodObserver o)

  Add observer for this object.

### removeObserver

    public void removeObserver(MethodObserver o)

  Remove observer for this object.

### 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 he has finished editing the object.

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

### copy

    public MethodGen copy(String class_name,
                          ConstantPoolGen cp)

  Returns:
    deep copy of this method

### getComparator

    public static BCELComparator getComparator()

  Returns:
    Comparison strategy object

### setComparator

    public static void setComparator(BCELComparator comparator)

  Parameters:
    `comparator` - Comparison strategy object

### 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(java.lang.Object)`

### 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()`

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