jdk-sandbox: comparison jaxp/src/java.xml/share/classes/com/sun/org/apache/bcel/internal/generic/MethodGen.java

equal deleted inserted replaced

-:5546b5710844
+:5611d2529b49
 /*
-* reserved comment block
+* Copyright (c) 2013, 2017, Oracle and/or its affiliates. All rights reserved.
-* DO NOT REMOVE OR ALTER!
 */
 /*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 package com.sun.org.apache.bcel.internal.generic;
+import com.sun.org.apache.bcel.internal.Const;
-import com.sun.org.apache.bcel.internal.Constants;
+import com.sun.org.apache.bcel.internal.classfile.AnnotationEntry;
-import com.sun.org.apache.bcel.internal.classfile.*;
+import com.sun.org.apache.bcel.internal.classfile.Annotations;
-import java.util.*;
+import com.sun.org.apache.bcel.internal.classfile.Attribute;
+import com.sun.org.apache.bcel.internal.classfile.Code;
+import com.sun.org.apache.bcel.internal.classfile.CodeException;
+import com.sun.org.apache.bcel.internal.classfile.ExceptionTable;
+import com.sun.org.apache.bcel.internal.classfile.LineNumber;
+import com.sun.org.apache.bcel.internal.classfile.LineNumberTable;
+import com.sun.org.apache.bcel.internal.classfile.LocalVariable;
+import com.sun.org.apache.bcel.internal.classfile.LocalVariableTable;
+import com.sun.org.apache.bcel.internal.classfile.LocalVariableTypeTable;
+import com.sun.org.apache.bcel.internal.classfile.Method;
+import com.sun.org.apache.bcel.internal.classfile.ParameterAnnotationEntry;
+import com.sun.org.apache.bcel.internal.classfile.ParameterAnnotations;
+import com.sun.org.apache.bcel.internal.classfile.RuntimeVisibleParameterAnnotations;
+import com.sun.org.apache.bcel.internal.classfile.Utility;
+import com.sun.org.apache.bcel.internal.util.BCELComparator;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Stack;
 /**
 * 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.
+* use the `removeNOPs' method to get rid off them. The resulting method object
-* The resulting method object can be obtained via the `getMethod()' method.
+* can be obtained via the `getMethod()' method.
 *
-* @author  <A HREF="mailto:markus.dahm@berlin.de">M. Dahm</A>
+* @version $Id: MethodGen.java 1749603 2016-06-21 20:50:19Z ggregory $
-* @author  <A HREF="http://www.vmeng.com/beard">Patrick C. Beard</A> [setMaxStack()]
+* @see InstructionList
-* @see     InstructionList
+* @see Method
-* @see     Method
 */
 public class MethodGen extends FieldGenOrMethodGen {
-private String          class_name;
-private Type[]          arg_types;
+private String class_name;
-private String[]        arg_names;
+private Type[] arg_types;
-private int             max_locals;
+private String[] arg_names;
-private int             max_stack;
+private int max_locals;
-private InstructionList il;
+private int max_stack;
-private boolean         strip_attributes;
+private InstructionList il;
+private boolean strip_attributes;
-private ArrayList       variable_vec    = new ArrayList();
+private final List<LocalVariableGen> variable_vec = new ArrayList<>();
-private ArrayList       type_vec        = new ArrayList();
+private final List<LocalVariableGen> type_vec = new ArrayList<>();
-private ArrayList       line_number_vec = new ArrayList();
+private final List<LineNumberGen> line_number_vec = new ArrayList<>();
-private ArrayList       exception_vec   = new ArrayList();
+private final List<CodeExceptionGen> exception_vec = new ArrayList<>();
-private ArrayList       throws_vec      = new ArrayList();
+private final List<String> throws_vec = new ArrayList<>();
-private ArrayList       code_attrs_vec  = new ArrayList();
+private final List<Attribute> code_attrs_vec = new ArrayList<>();
-/**
+private List<AnnotationEntryGen>[] param_annotations; // Array of lists containing AnnotationGen objects
-* Declare method. If the method is non-static the constructor
+private boolean hasParameterAnnotations = false;
-* automatically declares a local variable `$this' in slot 0. The
+private boolean haveUnpackedParameterAnnotations = false;
-* actual code is contained in the `il' parameter, which may further
-* manipulated by the user. But he must take care not to remove any
+private static BCELComparator bcelComparator = new BCELComparator() {
-* instruction (handles) that are still referenced from this object.
-*
+@Override
-* For example one may not add a local variable and later remove the
+public boolean equals(final Object o1, final Object o2) {
-* instructions it refers to without causing havoc. It is safe
+final MethodGen THIS = (MethodGen) o1;
-* however if you remove that local variable, too.
+final MethodGen THAT = (MethodGen) o2;
-*
+return THIS.getName().equals(THAT.getName())
-* @param access_flags access qualifiers
+&& THIS.getSignature().equals(THAT.getSignature());
-* @param return_type  method type
+}
-* @param arg_types argument types
-* @param arg_names argument names (if this is null, default names will be provided
+@Override
-* for them)
+public int hashCode(final Object o) {
-* @param method_name name of method
+final MethodGen THIS = (MethodGen) o;
-* @param class_name class name containing this method (may be null, if you don't care)
+return THIS.getSignature().hashCode() ^ THIS.getName().hashCode();
-* @param il instruction list associated with this method, may be null only for
+}
-* abstract or native methods
+};
-* @param cp constant pool
-*/
+/**
-public MethodGen(int access_flags, Type return_type, Type[] arg_types,
+* Declare method. If the method is non-static the constructor automatically
-String[] arg_names, String method_name, String class_name,
+* declares a local variable `$this' in slot 0. The actual code is contained
-InstructionList il, ConstantPoolGen cp) {
+* in the `il' parameter, which may further manipulated by the user. But he
-setAccessFlags(access_flags);
+* must take care not to remove any instruction (handles) that are still
-setType(return_type);
+* referenced from this object.
-setArgumentTypes(arg_types);
+*
-setArgumentNames(arg_names);
+* For example one may not add a local variable and later remove the
-setName(method_name);
+* instructions it refers to without causing havoc. It is safe however if
-setClassName(class_name);
+* you remove that local variable, too.
-setInstructionList(il);
+*
-setConstantPool(cp);
+* @param access_flags access qualifiers
+* @param return_type method type
-boolean abstract_ = isAbstract() || isNative();
+* @param arg_types argument types
-InstructionHandle start = null;
+* @param arg_names argument names (if this is null, default names will be
-InstructionHandle end   = null;
+* provided for them)
+* @param method_name name of method
-if(!abstract_) {
+* @param class_name class name containing this method (may be null, if you
-start = il.getStart();
+* don't care)
-end   = il.getEnd();
+* @param il instruction list associated with this method, may be null only
+* for abstract or native methods
-/* Add local variables, namely the implicit `this' and the arguments
+* @param cp constant pool
 */
-if(!isStatic() && (class_name != null)) { // Instance method -> `this' is local var 0
+public MethodGen(final int access_flags, final Type return_type, final Type[] arg_types, String[] arg_names,
-addLocalVariable("this", new ObjectType(class_name), start, end);
+final String method_name, final String class_name, final InstructionList il, final ConstantPoolGen cp) {
-}
+super(access_flags);
-}
+setType(return_type);
+setArgumentTypes(arg_types);
-if(arg_types != null) {
-int size = arg_types.length;
-for(int i=0; i < size; i++) {
-if(Type.VOID == arg_types[i]) {
-throw new ClassGenException("'void' is an illegal argument type for a method");
-}
-}
-if(arg_names != null) { // Names for variables provided?
-if(size != arg_names.length)
-throw new ClassGenException("Mismatch in argument array lengths: " +
-size + " vs. " + arg_names.length);
-} else { // Give them dummy names
-arg_names = new String[size];
-for(int i=0; i < size; i++)
-arg_names[i] = "arg" + i;
 setArgumentNames(arg_names);
-}
+setName(method_name);
+setClassName(class_name);
-if(!abstract_) {
+setInstructionList(il);
-for(int i=0; i < size; i++) {
+setConstantPool(cp);
-addLocalVariable(arg_names[i], arg_types[i], start, end);
+final boolean abstract_ = isAbstract() || isNative();
-}
+InstructionHandle start = null;
-}
+InstructionHandle end = null;
-}
+if (!abstract_) {
-}
+start = il.getStart();
+end = il.getEnd();
-/**
+/* Add local variables, namely the implicit `this' and the arguments
-* Instantiate from existing method.
+*/
-*
+if (!isStatic() && (class_name != null)) { // Instance method -> `this' is local var 0
-* @param m method
+addLocalVariable("this", ObjectType.getInstance(class_name), start, end);
-* @param class_name class name containing this method
+}
-* @param cp constant pool
+}
-*/
+if (arg_types != null) {
-public MethodGen(Method m, String class_name, ConstantPoolGen cp) {
+final int size = arg_types.length;
-this(m.getAccessFlags(), Type.getReturnType(m.getSignature()),
+for (final Type arg_type : arg_types) {
-Type.getArgumentTypes(m.getSignature()), null /* may be overridden anyway */,
+if (Type.VOID == arg_type) {
-m.getName(), class_name,
+throw new ClassGenException("'void' is an illegal argument type for a method");
-((m.getAccessFlags() & (Constants.ACC_ABSTRACT | Constants.ACC_NATIVE)) == 0)?
+}
-new InstructionList(m.getCode().getCode()) : null,
+}
-cp);
+if (arg_names != null) { // Names for variables provided?
+if (size != arg_names.length) {
-Attribute[] attributes = m.getAttributes();
+throw new ClassGenException("Mismatch in argument array lengths: " + size
-for(int i=0; i < attributes.length; i++) {
++ " vs. " + arg_names.length);
-Attribute a = attributes[i];
+}
+} else { // Give them dummy names
-if(a instanceof Code) {
+arg_names = new String[size];
-Code c = (Code)a;
+for (int i = 0; i < size; i++) {
-setMaxStack(c.getMaxStack());
+arg_names[i] = "arg" + i;
-setMaxLocals(c.getMaxLocals());
+}
+setArgumentNames(arg_names);
-CodeException[] ces = c.getExceptionTable();
+}
+if (!abstract_) {
-if(ces != null) {
+for (int i = 0; i < size; i++) {
-for(int j=0; j < ces.length; j++) {
+addLocalVariable(arg_names[i], arg_types[i], start, end);
-CodeException ce     = ces[j];
+}
-int           type   = ce.getCatchType();
+}
-ObjectType    c_type = null;
+}
+}
-if(type > 0) {
-String cen = m.getConstantPool().getConstantString(type, Constants.CONSTANT_Class);
+/**
-c_type = new ObjectType(cen);
+* Instantiate from existing method.
-}
+*
+* @param m method
-int end_pc = ce.getEndPC();
+* @param class_name class name containing this method
-int length = m.getCode().getCode().length;
+* @param cp constant pool
+*/
-InstructionHandle end;
+public MethodGen(final Method m, final String class_name, final ConstantPoolGen cp) {
+this(m.getAccessFlags(), Type.getReturnType(m.getSignature()), Type.getArgumentTypes(m
-if(length == end_pc) { // May happen, because end_pc is exclusive
+.getSignature()), null /* may be overridden anyway */, m.getName(), class_name,
-end = il.getEnd();
+((m.getAccessFlags() & (Const.ACC_ABSTRACT | Const.ACC_NATIVE)) == 0)
+? new InstructionList(m.getCode().getCode())
+: null, cp);
+final Attribute[] attributes = m.getAttributes();
+for (final Attribute attribute : attributes) {
+Attribute a = attribute;
+if (a instanceof Code) {
+final Code c = (Code) a;
+setMaxStack(c.getMaxStack());
+setMaxLocals(c.getMaxLocals());
+final CodeException[] ces = c.getExceptionTable();
+if (ces != null) {
+for (final CodeException ce : ces) {
+final int type = ce.getCatchType();
+ObjectType c_type = null;
+if (type > 0) {
+final String cen = m.getConstantPool().getConstantString(type,
+Const.CONSTANT_Class);
+c_type = ObjectType.getInstance(cen);
+}
+final int end_pc = ce.getEndPC();
+final int length = m.getCode().getCode().length;
+InstructionHandle end;
+if (length == end_pc) { // May happen, because end_pc is exclusive
+end = il.getEnd();
+} else {
+end = il.findHandle(end_pc);
+end = end.getPrev(); // Make it inclusive
+}
+addExceptionHandler(il.findHandle(ce.getStartPC()), end, il.findHandle(ce
+.getHandlerPC()), c_type);
+}
+}
+final Attribute[] c_attributes = c.getAttributes();
+for (final Attribute c_attribute : c_attributes) {
+a = c_attribute;
+if (a instanceof LineNumberTable) {
+final LineNumber[] ln = ((LineNumberTable) a).getLineNumberTable();
+for (final LineNumber l : ln) {
+final InstructionHandle ih = il.findHandle(l.getStartPC());
+if (ih != null) {
+addLineNumber(ih, l.getLineNumber());
+}
+}
+} else if (a instanceof LocalVariableTable) {
+final LocalVariable[] lv = ((LocalVariableTable) a).getLocalVariableTable();
+removeLocalVariables();
+repairHandles(lv, false);
+} else if (a instanceof LocalVariableTypeTable) {
+LocalVariable[] lv = ((LocalVariableTypeTable) a).getLocalVariableTypeTable();
+removeLocalVariableTypes();
+repairHandles(lv, true);
+} else {
+addCodeAttribute(a);
+}
+}
+} else if (a instanceof ExceptionTable) {
+final String[] names = ((ExceptionTable) a).getExceptionNames();
+for (final String name2 : names) {
+addException(name2);
+}
+} else if (a instanceof Annotations) {
+final Annotations runtimeAnnotations = (Annotations) a;
+final AnnotationEntry[] aes = runtimeAnnotations.getAnnotationEntries();
+for (final AnnotationEntry element : aes) {
+addAnnotationEntry(new AnnotationEntryGen(element, cp, false));
+}
 } else {
-end = il.findHandle(end_pc);
+addAttribute(a);
-end = end.getPrev(); // Make it inclusive
+}
 }
+}
-addExceptionHandler(il.findHandle(ce.getStartPC()), end,
-il.findHandle(ce.getHandlerPC()), c_type);
+private void repairHandles(final LocalVariable[] lv, boolean isLVT) {
-}
+for (int k = 0; k < lv.length; k++) {
-}
+LocalVariable l = lv[k];
+InstructionHandle start = il.findHandle(l.getStartPC());
-Attribute[] c_attributes = c.getAttributes();
+InstructionHandle end = il.findHandle(l.getStartPC() + l.getLength());
-for(int j=0; j < c_attributes.length; j++) {
+// Repair malformed handles
-a = c_attributes[j];
+if (null == start) {
-if(a instanceof LineNumberTable) {
-LineNumber[] ln = ((LineNumberTable)a).getLineNumberTable();
-for(int k=0; k < ln.length; k++) {
-LineNumber l = ln[k];
-addLineNumber(il.findHandle(l.getStartPC()), l.getLineNumber());
-}
-} else if(a instanceof LocalVariableTable) {
-LocalVariable[] lv = ((LocalVariableTable)a).getLocalVariableTable();
-removeLocalVariables();
-for(int k=0; k < lv.length; k++) {
-LocalVariable     l     = lv[k];
-InstructionHandle start = il.findHandle(l.getStartPC());
-InstructionHandle end   = il.findHandle(l.getStartPC() + l.getLength());
-// Repair malformed handles
-if(null == start) {
 start = il.getStart();
 }
+if (null == end) {
-if(null == end) {
 end = il.getEnd();
 }
+if (isLVT) {
-addLocalVariable(l.getName(), Type.getType(l.getSignature()),
+addLocalVariableType(l.getName(), Type.getType(l.getSignature()),
 l.getIndex(), start, end);
-}
+} else {
-} else if (a instanceof LocalVariableTypeTable) {
+addLocalVariable(l.getName(), Type.getType(l.getSignature()),
-LocalVariable[] lv = ((LocalVariableTypeTable) a).getLocalVariableTypeTable();
+l.getIndex(), start, end);
-removeLocalVariableTypes();
+}
-for (int k = 0; k < lv.length; k++) {
+}
-LocalVariable l = lv[k];
+}
-InstructionHandle start = il.findHandle(l.getStartPC());
-InstructionHandle end = il.findHandle(l.getStartPC() + l.getLength());
+/**
-// Repair malformed handles
+* Adds a local variable to this method.
-if (null == start) {
+*
-start = il.getStart();
+* @param name variable name
-}
+* @param type variable type
-if (null == end) {
+* @param slot the index of the local variable, if type is long or double,
-end = il.getEnd();
+* the next available index is slot+2
-}
+* @param start from where the variable is valid
-addLocalVariableType(l.getName(), Type.getType(l.getSignature()), l
+* @param end until where the variable is valid
-.getIndex(), start, end);
+* @return new local variable object
-}
+* @see LocalVariable
-} else
+*/
-addCodeAttribute(a);
+public LocalVariableGen addLocalVariable(final String name, final Type type, final int slot,
-}
+final InstructionHandle start, final InstructionHandle end) {
-} else if(a instanceof ExceptionTable) {
-String[] names = ((ExceptionTable)a).getExceptionNames();
+final byte t = type.getType();
-for(int j=0; j < names.length; j++)
+if (t != Const.T_ADDRESS) {
-addException(names[j]);
+final int add = type.getSize();
-} else
+if (slot + add > max_locals) {
-addAttribute(a);
+max_locals = slot + add;
 }
-}
+final LocalVariableGen l = new LocalVariableGen(slot, name, type, start, end);
+int i;
-/**
+if ((i = variable_vec.indexOf(l)) >= 0) {
-* Adds a local variable to this method.
+variable_vec.set(i, l);
-*
+} else {
-* @param name variable name
+variable_vec.add(l);
-* @param type variable type
+}
-* @param slot the index of the local variable, if type is long or double, the next available
+return l;
-* index is slot+2
+}
-* @param start from where the variable is valid
+throw new IllegalArgumentException("Can not use " + type
-* @param end until where the variable is valid
++ " as type for local variable");
-* @return new local variable object
+}
-* @see LocalVariable
-*/
+/**
-public LocalVariableGen addLocalVariable(String name, Type type, int slot,
+* Adds a local variable to this method and assigns an index automatically.
-InstructionHandle start,
+*
-InstructionHandle end) {
+* @param name variable name
-byte t = type.getType();
+* @param type variable type
+* @param start from where the variable is valid, if this is null, it is
-if(t != Constants.T_ADDRESS) {
+* valid from the start
-int  add = type.getSize();
+* @param end until where the variable is valid, if this is null, it is
+* valid to the end
-if(slot + add > max_locals)
+* @return new local variable object
-max_locals = slot + add;
+* @see LocalVariable
+*/
-LocalVariableGen l = new LocalVariableGen(slot, name, type, start, end);
+public LocalVariableGen addLocalVariable(final String name, final Type type,
-int i;
+final InstructionHandle start, final InstructionHandle end) {
+return addLocalVariable(name, type, max_locals, start, end);
-if((i = variable_vec.indexOf(l)) >= 0) // Overwrite if necessary
+}
-variable_vec.set(i, l);
-else
+/**
-variable_vec.add(l);
+* Remove a local variable, its slot will not be reused, if you do not use
+* addLocalVariable with an explicit index argument.
-return l;
+*/
-} else {
+public void removeLocalVariable(final LocalVariableGen l) {
-throw new IllegalArgumentException("Can not use " + type +
+variable_vec.remove(l);
-" as type for local variable");
+}
-}
+/**
-}
+* Remove all local variables.
+*/
-/**
+public void removeLocalVariables() {
-* Adds a local variable to this method and assigns an index automatically.
+variable_vec.clear();
-*
+}
-* @param name variable name
-* @param type variable type
+/*
-* @param start from where the variable is valid, if this is null,
+* If the range of the variable has not been set yet, it will be set to be valid from
-* it is valid from the start
+* the start to the end of the instruction list.
-* @param end until where the variable is valid, if this is null,
+*
-* it is valid to the end
+* @return array of declared local variables sorted by index
-* @return new local variable object
+*/
-* @see LocalVariable
+public LocalVariableGen[] getLocalVariables() {
-*/
+return getLocalVariableOrTypes(false);
-public LocalVariableGen addLocalVariable(String name, Type type,
+}
-InstructionHandle start,
-InstructionHandle end) {
+/*
-return addLocalVariable(name, type, max_locals, start, end);
+* If the range of the variable has not been set yet, it will be set to be
-}
+* valid from the start to the end of the instruction list.
+*
-/**
+* @return array of declared local variable types sorted by index
-* Remove a local variable, its slot will not be reused, if you do not use addLocalVariable
+*/
-* with an explicit index argument.
+private LocalVariableGen[] getLocalVariableTypes() {
-*/
+return getLocalVariableOrTypes(true);
-public void removeLocalVariable(LocalVariableGen l) {
+}
-variable_vec.remove(l);
-}
+/*
+* If the range of the variable or type has not been set yet, it will be set
-/**
+* to be valid from the start to the end of the instruction list.
-* Remove all local variables.
+*
-*/
+* @return array of declared local variables or types sorted by index
-public void removeLocalVariables() {
+*/
-variable_vec.clear();
+private LocalVariableGen[] getLocalVariableOrTypes(boolean isLVT) {
-}
+int size = (isLVT) ? type_vec.size() : variable_vec.size();
+LocalVariableGen[] lg = new LocalVariableGen[size];
-/**
+if (isLVT) {
-* Sort local variables by index
+type_vec.toArray(lg);
-*/
+} else {
-private static final void sort(LocalVariableGen[] vars, int l, int r) {
+variable_vec.toArray(lg);
-int i = l, j = r;
+}
-int m = vars[(l + r) / 2].getIndex();
-LocalVariableGen h;
+for (int i = 0; i < size; i++) {
+if (lg[i].getStart() == null) {
-do {
+lg[i].setStart(il.getStart());
-while(vars[i].getIndex() < m) i++;
+}
-while(m < vars[j].getIndex()) j--;
+if (lg[i].getEnd() == null) {
-if(i <= j) {
+lg[i].setEnd(il.getEnd());
-h=vars[i]; vars[i]=vars[j]; vars[j]=h; // Swap elements
+}
-i++; j--;
+}
-}
-} while(i <= j);
+if (size > 1) {
+Arrays.sort(lg, new Comparator<LocalVariableGen>() {
-if(l < j) sort(vars, l, j);
+@Override
-if(i < r) sort(vars, i, r);
+public int compare(final LocalVariableGen o1, final LocalVariableGen o2) {
-}
+return o1.getIndex() - o2.getIndex();
+}
-/*
+});
-* If the range of the variable has not been set yet, it will be set to be valid from
+}
-* the start to the end of the instruction list.
-*
+return lg;
-* @return array of declared local variables sorted by index
+}
-*/
-public LocalVariableGen[] getLocalVariables() {
+/**
-int                size = variable_vec.size();
+* @return `LocalVariableTable' attribute of all the local variables of this
-LocalVariableGen[] lg   = new LocalVariableGen[size];
+* method.
-variable_vec.toArray(lg);
+*/
+public LocalVariableTable getLocalVariableTable(final ConstantPoolGen cp) {
-for(int i=0; i < size; i++) {
+final LocalVariableGen[] lg = getLocalVariables();
-if(lg[i].getStart() == null)
+final int size = lg.length;
-lg[i].setStart(il.getStart());
+final LocalVariable[] lv = new LocalVariable[size];
+for (int i = 0; i < size; i++) {
-if(lg[i].getEnd() == null)
+lv[i] = lg[i].getLocalVariable(cp);
-lg[i].setEnd(il.getEnd());
+}
-}
+return new LocalVariableTable(cp.addUtf8("LocalVariableTable"), 2 + lv.length * 10, lv, cp
+.getConstantPool());
-if(size > 1)
+}
-sort(lg, 0, size - 1);
+/**
-return lg;
+* @return `LocalVariableTypeTable' attribute of all the local variable
-}
+* types of this method.
+*/
-/*
+public LocalVariableTypeTable getLocalVariableTypeTable(ConstantPoolGen cp) {
-* If the range of the variable has not been set yet, it will be set to be
+LocalVariableGen[] lg = getLocalVariableTypes();
-* val id from the start to the end of the instruction list.
+int size = lg.length;
-*
+LocalVariable[] lv = new LocalVariable[size];
-* @return array of declared local variable types sorted by index
-*/
+for (int i = 0; i < size; i++) {
-private LocalVariableGen[] getLocalVariableTypes() {
+lv[i] = lg[i].getLocalVariable(cp);
-int                size = type_vec.size();
+}
-LocalVariableGen[] lg   = new LocalVariableGen[size];
-type_vec.toArray(lg);
+return new LocalVariableTypeTable(cp.addUtf8("LocalVariableTypeTable"),
+2 + lv.length * 10, lv, cp.getConstantPool());
-for(int i=0; i < size; i++) {
+}
-if(lg[i].getStart() == null)
-lg[i].setStart(il.getStart());
+/**
+* Adds a local variable type to this method.
-if(lg[i].getEnd() == null)
+*
-lg[i].setEnd(il.getEnd());
+* @param name variable name
-}
+* @param type variable type
+* @param slot the index of the local variable, if type is long or double,
-if(size > 1)
+* the next available index is slot+2
-sort(lg, 0, size - 1);
+* @param start from where the variable is valid
+* @param end until where the variable is valid
-return lg;
+* @return new local variable object
-}
+* @see LocalVariable
+*/
-/**
+private LocalVariableGen addLocalVariableType(String name, Type type, int slot,
-* @return `LocalVariableTable' attribute of all the local variables of this method.
+InstructionHandle start,
-*/
+InstructionHandle end) {
-public LocalVariableTable getLocalVariableTable(ConstantPoolGen cp) {
+byte t = type.getType();
-LocalVariableGen[] lg   = getLocalVariables();
-int                size = lg.length;
+if (t != Const.T_ADDRESS) {
-LocalVariable[]    lv   = new LocalVariable[size];
+int add = type.getSize();
-for(int i=0; i < size; i++)
+if (slot + add > max_locals) {
-lv[i] = lg[i].getLocalVariable(cp);
+max_locals = slot + add;
+}
-return new LocalVariableTable(cp.addUtf8("LocalVariableTable"),
-2 + lv.length * 10, lv, cp.getConstantPool());
+LocalVariableGen l = new LocalVariableGen(slot, name, type, start, end);
-}
+int i;
-/**
+if ((i = type_vec.indexOf(l)) >= 0) // Overwrite if necessary
-* @return `LocalVariableTypeTable' attribute of all the local variable
+{
-* types of this method.
+type_vec.set(i, l);
-*/
+} else {
-public LocalVariableTypeTable getLocalVariableTypeTable(ConstantPoolGen cp) {
+type_vec.add(l);
-LocalVariableGen[] lg   = getLocalVariableTypes();
+}
-int                size = lg.length;
-LocalVariable[]    lv   = new LocalVariable[size];
+return l;
+} else {
-for(int i=0; i < size; i++)
+throw new IllegalArgumentException("Can not use " + type
-lv[i] = lg[i].getLocalVariable(cp);
++ " as type for local variable");
+}
-return new LocalVariableTypeTable(cp.addUtf8("LocalVariableTypeTable"),
+}
-2 + lv.length * 10, lv, cp.getConstantPool());
-}
+/**
+* Remove all local variable types.
-/**
+*/
-* Adds a local variable type to this method.
+private void removeLocalVariableTypes() {
-*
+type_vec.clear();
-* @param name variable name
+}
-* @param type variable type
-* @param slot the index of the local variable, if type is long or double, the next available
+/**
-* index is slot+2
+* Give an instruction a line number corresponding to the source code line.
-* @param start from where the variable is valid
+*
-* @param end until where the variable is valid
+* @param ih instruction to tag
-* @return new local variable object
+* @return new line number object
-* @see LocalVariable
+* @see LineNumber
 */
-private LocalVariableGen addLocalVariableType(String name, Type type, int slot,
+public LineNumberGen addLineNumber(final InstructionHandle ih, final int src_line) {
-InstructionHandle start,
+final LineNumberGen l = new LineNumberGen(ih, src_line);
-InstructionHandle end) {
+line_number_vec.add(l);
-byte t = type.getType();
+return l;
+}
-if(t != Constants.T_ADDRESS) {
-int  add = type.getSize();
+/**
+* Remove a line number.
-if(slot + add > max_locals)
+*/
-max_locals = slot + add;
+public void removeLineNumber(final LineNumberGen l) {
+line_number_vec.remove(l);
-LocalVariableGen l = new LocalVariableGen(slot, name, type, start, end);
+}
-int i;
+/**
-if((i = type_vec.indexOf(l)) >= 0) // Overwrite if necessary
+* Remove all line numbers.
-type_vec.set(i, l);
+*/
-else
+public void removeLineNumbers() {
-type_vec.add(l);
+line_number_vec.clear();
+}
-return l;
-} else {
+/*
-throw new IllegalArgumentException("Can not use " + type +
+* @return array of line numbers
-" as type for local variable");
+*/
+public LineNumberGen[] getLineNumbers() {
-}
+final LineNumberGen[] lg = new LineNumberGen[line_number_vec.size()];
-}
+line_number_vec.toArray(lg);
+return lg;
-/**
+}
-* Remove all local variable types.
-*/
+/**
-private void removeLocalVariableTypes() {
+* @return `LineNumberTable' attribute of all the local variables of this
-type_vec.clear();
+* method.
-}
+*/
+public LineNumberTable getLineNumberTable(final ConstantPoolGen cp) {
-/**
+final int size = line_number_vec.size();
-* Give an instruction a line number corresponding to the source code line.
+final LineNumber[] ln = new LineNumber[size];
-*
+for (int i = 0; i < size; i++) {
-* @param ih instruction to tag
+ln[i] = line_number_vec.get(i).getLineNumber();
-* @return new line number object
+}
-* @see LineNumber
+return new LineNumberTable(cp.addUtf8("LineNumberTable"), 2 + ln.length * 4, ln, cp
-*/
+.getConstantPool());
-public LineNumberGen addLineNumber(InstructionHandle ih, int src_line) {
+}
-LineNumberGen l = new LineNumberGen(ih, src_line);
-line_number_vec.add(l);
+/**
-return l;
+* Add an exception handler, i.e., specify region where a handler is active
-}
+* and an instruction where the actual handling is done.
+*
-/**
+* @param start_pc Start of region (inclusive)
-* Remove a line number.
+* @param end_pc End of region (inclusive)
-*/
+* @param handler_pc Where handling is done
-public void removeLineNumber(LineNumberGen l) {
+* @param catch_type class type of handled exception or null if any
-line_number_vec.remove(l);
+* exception is handled
-}
+* @return new exception handler object
+*/
-/**
+public CodeExceptionGen addExceptionHandler(final InstructionHandle start_pc,
-* Remove all line numbers.
+final InstructionHandle end_pc, final InstructionHandle handler_pc, final ObjectType catch_type) {
-*/
+if ((start_pc == null) || (end_pc == null) || (handler_pc == null)) {
-public void removeLineNumbers() {
+throw new ClassGenException("Exception handler target is null instruction");
-line_number_vec.clear();
+}
-}
+final CodeExceptionGen c = new CodeExceptionGen(start_pc, end_pc, handler_pc, catch_type);
+exception_vec.add(c);
-/*
+return c;
-* @return array of line numbers
+}
-*/
-public LineNumberGen[] getLineNumbers() {
+/**
-LineNumberGen[] lg = new LineNumberGen[line_number_vec.size()];
+* Remove an exception handler.
-line_number_vec.toArray(lg);
+*/
-return lg;
+public void removeExceptionHandler(final CodeExceptionGen c) {
-}
+exception_vec.remove(c);
+}
-/**
-* @return `LineNumberTable' attribute of all the local variables of this method.
+/**
-*/
+* Remove all line numbers.
-public LineNumberTable getLineNumberTable(ConstantPoolGen cp) {
+*/
-int          size = line_number_vec.size();
+public void removeExceptionHandlers() {
-LineNumber[] ln   = new LineNumber[size];
+exception_vec.clear();
+}
-try {
-for(int i=0; i < size; i++)
+/*
-ln[i] = ((LineNumberGen)line_number_vec.get(i)).getLineNumber();
+* @return array of declared exception handlers
-} catch(ArrayIndexOutOfBoundsException e) {} // Never occurs
+*/
+public CodeExceptionGen[] getExceptionHandlers() {
-return new LineNumberTable(cp.addUtf8("LineNumberTable"),
+final CodeExceptionGen[] cg = new CodeExceptionGen[exception_vec.size()];
-2 + ln.length * 4, ln, cp.getConstantPool());
+exception_vec.toArray(cg);
-}
+return cg;
+}
-/**
-* Add an exception handler, i.e., specify region where a handler is active and an
+/**
-* instruction where the actual handling is done.
+* @return code exceptions for `Code' attribute
-*
+*/
-* @param start_pc Start of region (inclusive)
+private CodeException[] getCodeExceptions() {
-* @param end_pc End of region (inclusive)
+final int size = exception_vec.size();
-* @param handler_pc Where handling is done
+final CodeException[] c_exc = new CodeException[size];
-* @param catch_type class type of handled exception or null if any
+for (int i = 0; i < size; i++) {
-* exception is handled
+final CodeExceptionGen c = exception_vec.get(i);
-* @return new exception handler object
+c_exc[i] = c.getCodeException(super.getConstantPool());
-*/
+}
-public CodeExceptionGen addExceptionHandler(InstructionHandle start_pc,
+return c_exc;
-InstructionHandle end_pc,
+}
-InstructionHandle handler_pc,
-ObjectType catch_type) {
+/**
-if((start_pc == null) || (end_pc == null) || (handler_pc == null))
+* Add an exception possibly thrown by this method.
-throw new ClassGenException("Exception handler target is null instruction");
+*
+* @param class_name (fully qualified) name of exception
-CodeExceptionGen c = new CodeExceptionGen(start_pc, end_pc,
+*/
-handler_pc, catch_type);
+public void addException(final String class_name) {
-exception_vec.add(c);
+throws_vec.add(class_name);
-return c;
+}
-}
+/**
-/**
+* Remove an exception.
-* Remove an exception handler.
+*/
-*/
+public void removeException(final String c) {
-public void removeExceptionHandler(CodeExceptionGen c) {
+throws_vec.remove(c);
-exception_vec.remove(c);
+}
-}
+/**
-/**
+* Remove all exceptions.
-* Remove all line numbers.
+*/
-*/
+public void removeExceptions() {
-public void removeExceptionHandlers() {
+throws_vec.clear();
-exception_vec.clear();
+}
-}
+/*
-/*
+* @return array of thrown exceptions
-* @return array of declared exception handlers
+*/
-*/
+public String[] getExceptions() {
-public CodeExceptionGen[] getExceptionHandlers() {
+final String[] e = new String[throws_vec.size()];
-CodeExceptionGen[] cg   = new CodeExceptionGen[exception_vec.size()];
+throws_vec.toArray(e);
-exception_vec.toArray(cg);
+return e;
-return cg;
+}
-}
+/**
-/**
+* @return `Exceptions' attribute of all the exceptions thrown by this
-* @return code exceptions for `Code' attribute
+* method.
 */
-private CodeException[] getCodeExceptions() {
+private ExceptionTable getExceptionTable(final ConstantPoolGen cp) {
-int             size  = exception_vec.size();
+final int size = throws_vec.size();
-CodeException[] c_exc = new CodeException[size];
+final int[] ex = new int[size];
+for (int i = 0; i < size; i++) {
-try {
+ex[i] = cp.addClass(throws_vec.get(i));
-for(int i=0; i < size; i++) {
+}
-CodeExceptionGen c = (CodeExceptionGen)exception_vec.get(i);
+return new ExceptionTable(cp.addUtf8("Exceptions"), 2 + 2 * size, ex, cp.getConstantPool());
-c_exc[i] = c.getCodeException(cp);
+}
-}
-} catch(ArrayIndexOutOfBoundsException e) {}
+/**
+* Add an attribute to the code. Currently, the JVM knows about the
-return c_exc;
+* 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.
-/**
+*
-* Add an exception possibly thrown by this method.
+* @param a attribute to be added
-*
+*/
-* @param class_name (fully qualified) name of exception
+public void addCodeAttribute(final Attribute a) {
-*/
+code_attrs_vec.add(a);
-public void addException(String class_name) {
+}
-throws_vec.add(class_name);
-}
+/**
+* Remove a code attribute.
-/**
+*/
-* Remove an exception.
+public void removeCodeAttribute(final Attribute a) {
-*/
+code_attrs_vec.remove(a);
-public void removeException(String c) {
+}
-throws_vec.remove(c);
-}
+/**
+* Remove all code attributes.
-/**
+*/
-* Remove all exceptions.
+public void removeCodeAttributes() {
-*/
+code_attrs_vec.clear();
-public void removeExceptions() {
+}
-throws_vec.clear();
-}
+/**
+* @return all attributes of this method.
-/*
+*/
-* @return array of thrown exceptions
+public Attribute[] getCodeAttributes() {
-*/
+final Attribute[] attributes = new Attribute[code_attrs_vec.size()];
-public String[] getExceptions() {
+code_attrs_vec.toArray(attributes);
-String[] e = new String[throws_vec.size()];
+return attributes;
-throws_vec.toArray(e);
+}
-return e;
-}
+/**
+* @since 6.0
-/**
+*/
-* @return `Exceptions' attribute of all the exceptions thrown by this method.
+public void addAnnotationsAsAttribute(final ConstantPoolGen cp) {
-*/
+final Attribute[] attrs = AnnotationEntryGen.getAnnotationAttributes(cp, super.getAnnotationEntries());
-private ExceptionTable getExceptionTable(ConstantPoolGen cp) {
+for (final Attribute attr : attrs) {
-int   size = throws_vec.size();
+addAttribute(attr);
-int[] ex   = new int[size];
+}
+}
-try {
-for(int i=0; i < size; i++)
+/**
-ex[i] = cp.addClass((String)throws_vec.get(i));
+* @since 6.0
-} catch(ArrayIndexOutOfBoundsException e) {}
+*/
+public void addParameterAnnotationsAsAttribute(final ConstantPoolGen cp) {
-return new ExceptionTable(cp.addUtf8("Exceptions"),
+if (!hasParameterAnnotations) {
-2 + 2 * size, ex, cp.getConstantPool());
+return;
 }
+final Attribute[] attrs = AnnotationEntryGen.getParameterAnnotationAttributes(cp, param_annotations);
-/**
+if (attrs != null) {
-* Add an attribute to the code. Currently, the JVM knows about the
+for (final Attribute attr : attrs) {
-* LineNumberTable, LocalVariableTable and StackMap attributes,
+addAttribute(attr);
-* 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.
+}
-*
-* @param a attribute to be added
+/**
-*/
+* Get method object. Never forget to call setMaxStack() or
-public void addCodeAttribute(Attribute a) { code_attrs_vec.add(a); }
+* setMaxStack(max), respectively, before calling this method (the same
+* applies for max locals).
-/**
+*
-* Remove a code attribute.
+* @return method object
 */
-public void removeCodeAttribute(Attribute a) { code_attrs_vec.remove(a); }
+public Method getMethod() {
+final String signature = getSignature();
-/**
+final ConstantPoolGen _cp = super.getConstantPool();
-* Remove all code attributes.
+final int name_index = _cp.addUtf8(super.getName());
-*/
+final int signature_index = _cp.addUtf8(signature);
-public void removeCodeAttributes() {
+/* Also updates positions of instructions, i.e., their indices
-code_attrs_vec.clear();
+*/
-}
+byte[] byte_code = null;
+if (il != null) {
-/**
+byte_code = il.getByteCode();
-* @return all attributes of this method.
+}
-*/
+LineNumberTable lnt = null;
-public Attribute[] getCodeAttributes() {
+LocalVariableTable lvt = null;
-Attribute[] attributes = new Attribute[code_attrs_vec.size()];
+LocalVariableTypeTable lvtt = null;
-code_attrs_vec.toArray(attributes);
-return attributes;
+/* Create LocalVariableTable, LocalvariableTypeTable, and LineNumberTable
-}
+* attributes (for debuggers, e.g.)
+*/
-/**
+if ((variable_vec.size() > 0) && !strip_attributes) {
-* Get method object. Never forget to call setMaxStack() or setMaxStack(max), respectively,
+addCodeAttribute(lvt = getLocalVariableTable(_cp));
-* before calling this method (the same applies for max locals).
+}
-*
-* @return method object
+if ((type_vec.size() > 0) && !strip_attributes) {
-*/
+addCodeAttribute(lvtt = getLocalVariableTypeTable(_cp));
-public Method getMethod() {
+}
-String signature       = getSignature();
-int    name_index      = cp.addUtf8(name);
+if ((line_number_vec.size() > 0) && !strip_attributes) {
-int    signature_index = cp.addUtf8(signature);
+addCodeAttribute(lnt = getLineNumberTable(_cp));
+}
-/* Also updates positions of instructions, i.e., their indices
+final Attribute[] code_attrs = getCodeAttributes();
-*/
+/* Each attribute causes 6 additional header bytes
-byte[] byte_code = null;
+*/
+int attrs_len = 0;
-if(il != null)
+for (final Attribute code_attr : code_attrs) {
-byte_code = il.getByteCode();
+attrs_len += code_attr.getLength() + 6;
+}
-LineNumberTable    lnt = null;
+final CodeException[] c_exc = getCodeExceptions();
-LocalVariableTable lvt = null;
+final int exc_len = c_exc.length * 8; // Every entry takes 8 bytes
-LocalVariableTypeTable lvtt = null;
+Code code = null;
+if ((il != null) && !isAbstract() && !isNative()) {
-/* Create LocalVariableTable, LocalvariableTypeTable, and LineNumberTable
+// Remove any stale code attribute
-* attributes (for debuggers, e.g.)
+final Attribute[] attributes = getAttributes();
-*/
+for (final Attribute a : attributes) {
-if((variable_vec.size() > 0) && !strip_attributes)
+if (a instanceof Code) {
-addCodeAttribute(lvt = getLocalVariableTable(cp));
+removeAttribute(a);
+}
-if((type_vec.size() > 0) && !strip_attributes)
+}
-addCodeAttribute(lvtt = getLocalVariableTypeTable(cp));
+code = new Code(_cp.addUtf8("Code"), 8 + byte_code.length + // prologue byte code
+2 + exc_len + // exceptions
-if((line_number_vec.size() > 0) && !strip_attributes)
+2 + attrs_len, // attributes
-addCodeAttribute(lnt = getLineNumberTable(cp));
+max_stack, max_locals, byte_code, c_exc, code_attrs, _cp.getConstantPool());
+addAttribute(code);
-Attribute[] code_attrs = getCodeAttributes();
+}
+addAnnotationsAsAttribute(_cp);
-/* Each attribute causes 6 additional header bytes
+addParameterAnnotationsAsAttribute(_cp);
-*/
+ExceptionTable et = null;
-int                attrs_len  = 0;
+if (throws_vec.size() > 0) {
-for(int i=0; i < code_attrs.length; i++)
+addAttribute(et = getExceptionTable(_cp));
-attrs_len += (code_attrs[i].getLength() + 6);
+// Add `Exceptions' if there are "throws" clauses
+}
-CodeException[] c_exc   = getCodeExceptions();
+final Method m = new Method(super.getAccessFlags(), name_index, signature_index, getAttributes(), _cp
-int             exc_len = c_exc.length * 8; // Every entry takes 8 bytes
+.getConstantPool());
+// Undo effects of adding attributes
-Code code = null;
+if (lvt != null) {
+removeCodeAttribute(lvt);
-if((il != null) && !isAbstract()) {
+}
-// Remove any stale code attribute
+if (lvtt != null) {
-Attribute[] attributes = getAttributes();
+removeCodeAttribute(lvtt);
-for(int i=0; i < attributes.length; i++) {
+}
-Attribute a = attributes[i];
+if (lnt != null) {
+removeCodeAttribute(lnt);
-if(a instanceof Code)
+}
-removeAttribute(a);
+if (code != null) {
-}
+removeAttribute(code);
+}
-code = new Code(cp.addUtf8("Code"),
+if (et != null) {
-8 + byte_code.length + // prologue byte code
+removeAttribute(et);
-2 + exc_len +          // exceptions
+}
-2 + attrs_len,         // attributes
+return m;
-max_stack, max_locals,
+}
-byte_code, c_exc,
-code_attrs,
+/**
-cp.getConstantPool());
+* Remove all NOPs from the instruction list (if possible) and update every
+* object referring to them, i.e., branch instructions, local variables and
-addAttribute(code);
+* exception handlers.
-}
+*/
+public void removeNOPs() {
-ExceptionTable et = null;
+if (il != null) {
+InstructionHandle next;
-if(throws_vec.size() > 0)
+/* Check branch instructions.
-addAttribute(et = getExceptionTable(cp)); // Add `Exceptions' if there are "throws" clauses
+*/
+for (InstructionHandle ih = il.getStart(); ih != null; ih = next) {
-Method m = new Method(access_flags, name_index, signature_index,
+next = ih.getNext();
-getAttributes(), cp.getConstantPool());
+if ((next != null) && (ih.getInstruction() instanceof NOP)) {
+try {
-// Undo effects of adding attributes
+il.delete(ih);
-if(lvt != null)  removeCodeAttribute(lvt);
+} catch (final TargetLostException e) {
-if(lvtt != null) removeCodeAttribute(lvtt);
+for (final InstructionHandle target : e.getTargets()) {
-if(lnt != null)  removeCodeAttribute(lnt);
+for (final InstructionTargeter targeter : target.getTargeters()) {
-if(code != null) removeAttribute(code);
+targeter.updateTarget(target, next);
-if(et != null)   removeAttribute(et);
+}
+}
-return m;
+}
 }
+}
-/**
+}
-* 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.
+/**
-*/
+* Set maximum number of local variables.
-public void removeNOPs() {
+*/
-if(il != null) {
+public void setMaxLocals(final int m) {
-InstructionHandle next;
+max_locals = m;
-/* Check branch instructions.
+}
-*/
-for(InstructionHandle ih = il.getStart(); ih != null; ih = next) {
+public int getMaxLocals() {
-next = ih.next;
+return max_locals;
+}
-if((next != null) && (ih.getInstruction() instanceof NOP)) {
-try {
+/**
-il.delete(ih);
+* Set maximum stack size for this method.
-} catch(TargetLostException e) {
+*/
-InstructionHandle[] targets = e.getTargets();
+public void setMaxStack(final int m) { // TODO could be package-protected?
+max_stack = m;
-for(int i=0; i < targets.length; i++) {
+}
-InstructionTargeter[] targeters = targets[i].getTargeters();
+public int getMaxStack() {
-for(int j=0; j < targeters.length; j++)
+return max_stack;
-targeters[j].updateTarget(targets[i], next);
+}
-}
-}
+/**
-}
+* @return class that contains this method
-}
+*/
-}
+public String getClassName() {
-}
+return class_name;
+}
-/**
-* Set maximum number of local variables.
+public void setClassName(final String class_name) { // TODO could be package-protected?
-*/
+this.class_name = class_name;
-public void   setMaxLocals(int m)  { max_locals = m; }
+}
-public int    getMaxLocals()       { return max_locals; }
+public void setReturnType(final Type return_type) {
-/**
+setType(return_type);
-* Set maximum stack size for this method.
+}
-*/
-public void   setMaxStack(int m)  { max_stack = m; }
+public Type getReturnType() {
-public int    getMaxStack()       { return max_stack; }
+return getType();
+}
-/** @return class that contains this method
-*/
+public void setArgumentTypes(final Type[] arg_types) {
-public String getClassName()                     { return class_name; }
+this.arg_types = arg_types;
-public void   setClassName(String class_name)    { this.class_name = class_name; }
+}
-public void   setReturnType(Type return_type)    { setType(return_type); }
+public Type[] getArgumentTypes() {
-public Type   getReturnType()                    { return getType(); }
+return arg_types.clone();
+}
-public void   setArgumentTypes(Type[] arg_types)  { this.arg_types = arg_types; }
-public Type[] getArgumentTypes()                  { return (Type[])arg_types.clone(); }
+public void setArgumentType(final int i, final Type type) {
-public void   setArgumentType(int i, Type type)       { arg_types[i] = type; }
+arg_types[i] = type;
-public Type   getArgumentType(int i)                  { return arg_types[i]; }
+}
-public void     setArgumentNames(String[] arg_names) { this.arg_names = arg_names; }
+public Type getArgumentType(final int i) {
-public String[] getArgumentNames()                   { return (String[])arg_names.clone(); }
+return arg_types[i];
-public void     setArgumentName(int i, String name)     { arg_names[i] = name; }
+}
-public String   getArgumentName(int i)                  { return arg_names[i]; }
+public void setArgumentNames(final String[] arg_names) {
-public InstructionList getInstructionList()                    { return il; }
+this.arg_names = arg_names;
-public void            setInstructionList(InstructionList il)  { this.il = il; }
+}
-public String getSignature() {
+public String[] getArgumentNames() {
-return Type.getMethodSignature(type, arg_types);
+return arg_names.clone();
 }
-/**
+public void setArgumentName(final int i, final String name) {
-* Computes max. stack size by performing control flow analysis.
+arg_names[i] = name;
-*/
+}
-public void setMaxStack() {
-if(il != null)
+public String getArgumentName(final int i) {
-max_stack = getMaxStack(cp, il, getExceptionHandlers());
+return arg_names[i];
-else
+}
-max_stack = 0;
-}
+public InstructionList getInstructionList() {
+return il;
-/**
+}
-* Compute maximum number of local variables.
-*/
+public void setInstructionList(final InstructionList il) { // TODO could be package-protected?
-public void setMaxLocals() {
+this.il = il;
-if(il != null) {
+}
-int max = isStatic()? 0 : 1;
+@Override
-if(arg_types != null)
+public String getSignature() {
-for(int i=0; i < arg_types.length; i++)
+return Type.getMethodSignature(super.getType(), arg_types);
-max += arg_types[i].getSize();
+}
-for(InstructionHandle ih = il.getStart(); ih != null; ih = ih.getNext()) {
+/**
-Instruction ins = ih.getInstruction();
+* Computes max. stack size by performing control flow analysis.
+*/
-if((ins instanceof LocalVariableInstruction) ||
+public void setMaxStack() { // TODO could be package-protected? (some tests would need repackaging)
-(ins instanceof RET) || (ins instanceof IINC))
+if (il != null) {
-{
+max_stack = getMaxStack(super.getConstantPool(), il, getExceptionHandlers());
-int index = ((IndexedInstruction)ins).getIndex() +
+} else {
-((TypedInstruction)ins).getType(cp).getSize();
+max_stack = 0;
+}
-if(index > max)
+}
-max = index;
-}
+/**
-}
+* Compute maximum number of local variables.
+*/
-max_locals = max;
+public void setMaxLocals() { // TODO could be package-protected? (some tests would need repackaging)
-} else
+if (il != null) {
-max_locals = 0;
+int max = isStatic() ? 0 : 1;
-}
+if (arg_types != null) {
+for (final Type arg_type : arg_types) {
-/** Do not/Do produce attributes code attributesLineNumberTable and
+max += arg_type.getSize();
-* LocalVariableTable, like javac -O
+}
-*/
+}
-public void stripAttributes(boolean flag) { strip_attributes = flag; }
+for (InstructionHandle ih = il.getStart(); ih != null; ih = ih.getNext()) {
+final Instruction ins = ih.getInstruction();
-static final class BranchTarget {
+if ((ins instanceof LocalVariableInstruction) || (ins instanceof RET)
-InstructionHandle target;
+|| (ins instanceof IINC)) {
-int               stackDepth;
+final int index = ((IndexedInstruction) ins).getIndex()
++ ((TypedInstruction) ins).getType(super.getConstantPool()).getSize();
-BranchTarget(InstructionHandle target, int stackDepth) {
+if (index > max) {
-this.target = target;
+max = index;
-this.stackDepth = stackDepth;
+}
 }
 }
+max_locals = max;
-static final class BranchStack {
+} else {
-Stack     branchTargets  = new Stack();
+max_locals = 0;
-Hashtable visitedTargets = new Hashtable();
+}
+}
-public void push(InstructionHandle target, int stackDepth) {
-if(visited(target))
+/**
-return;
+* Do not/Do produce attributes code attributesLineNumberTable and
+* LocalVariableTable, like javac -O
-branchTargets.push(visit(target, stackDepth));
+*/
-}
+public void stripAttributes(final boolean flag) {
+strip_attributes = flag;
-public BranchTarget pop() {
+}
-if(!branchTargets.empty()) {
-BranchTarget bt = (BranchTarget) branchTargets.pop();
+static final class BranchTarget {
-return bt;
-}
+final InstructionHandle target;
+final int stackDepth;
-return null;
-}
+BranchTarget(final InstructionHandle target, final int stackDepth) {
+this.target = target;
-private final BranchTarget visit(InstructionHandle target, int stackDepth) {
+this.stackDepth = stackDepth;
-BranchTarget bt = new BranchTarget(target, stackDepth);
+}
-visitedTargets.put(target, bt);
+}
-return bt;
+static final class BranchStack {
-}
+private final Stack<BranchTarget> branchTargets = new Stack<>();
-private final boolean visited(InstructionHandle target) {
+private final Map<InstructionHandle, BranchTarget> visitedTargets = new HashMap<>();
-return (visitedTargets.get(target) != null);
-}
+public void push(final InstructionHandle target, final int stackDepth) {
-}
+if (visited(target)) {
+return;
-/**
+}
-* Computes stack usage of an instruction list by performing control flow analysis.
+branchTargets.push(visit(target, stackDepth));
-*
+}
-* @return maximum stack depth used by method
-*/
+public BranchTarget pop() {
-public static int getMaxStack(ConstantPoolGen cp, InstructionList il, CodeExceptionGen[] et) {
+if (!branchTargets.empty()) {
-BranchStack branchTargets = new BranchStack();
+final BranchTarget bt = branchTargets.pop();
+return bt;
-/* Initially, populate the branch stack with the exception
+}
-* handlers, because these aren't (necessarily) branched to
+return null;
-* explicitly. in each case, the stack will have depth 1,
+}
-* containing the exception object.
-*/
+private BranchTarget visit(final InstructionHandle target, final int stackDepth) {
-for (int i = 0; i < et.length; i++) {
+final BranchTarget bt = new BranchTarget(target, stackDepth);
-InstructionHandle handler_pc = et[i].getHandlerPC();
+visitedTargets.put(target, bt);
-if (handler_pc != null)
+return bt;
-branchTargets.push(handler_pc, 1);
+}
-}
+private boolean visited(final InstructionHandle target) {
-int               stackDepth = 0, maxStackDepth = 0;
+return visitedTargets.get(target) != null;
-InstructionHandle ih         = il.getStart();
+}
+}
-while(ih != null) {
-Instruction instruction = ih.getInstruction();
+/**
-short opcode = instruction.getOpcode();
+* Computes stack usage of an instruction list by performing control flow
-int delta = instruction.produceStack(cp) - instruction.consumeStack(cp);
+* analysis.
+*
-stackDepth += delta;
+* @return maximum stack depth used by method
-if(stackDepth > maxStackDepth)
+*/
-maxStackDepth = stackDepth;
+public static int getMaxStack(final ConstantPoolGen cp, final InstructionList il,
+final CodeExceptionGen[] et) {
-// choose the next instruction based on whether current is a branch.
+final BranchStack branchTargets = new BranchStack();
-if(instruction instanceof BranchInstruction) {
+/* Initially, populate the branch stack with the exception
-BranchInstruction branch = (BranchInstruction) instruction;
+* handlers, because these aren't (necessarily) branched to
-if(instruction instanceof Select) {
+* explicitly. in each case, the stack will have depth 1,
-// explore all of the select's targets. the default target is handled below.
+* containing the exception object.
-Select select = (Select) branch;
+*/
-InstructionHandle[] targets = select.getTargets();
+for (final CodeExceptionGen element : et) {
-for (int i = 0; i < targets.length; i++)
+final InstructionHandle handler_pc = element.getHandlerPC();
-branchTargets.push(targets[i], stackDepth);
+if (handler_pc != null) {
-// nothing to fall through to.
+branchTargets.push(handler_pc, 1);
-ih = null;
+}
-} else if(!(branch instanceof IfInstruction)) {
+}
-// if an instruction that comes back to following PC,
+int stackDepth = 0;
-// push next instruction, with stack depth reduced by 1.
+int maxStackDepth = 0;
-if(opcode == Constants.JSR || opcode == Constants.JSR_W)
+InstructionHandle ih = il.getStart();
-branchTargets.push(ih.getNext(), stackDepth - 1);
+while (ih != null) {
-ih = null;
+final Instruction instruction = ih.getInstruction();
-}
+final short opcode = instruction.getOpcode();
-// for all branches, the target of the branch is pushed on the branch stack.
+final int delta = instruction.produceStack(cp) - instruction.consumeStack(cp);
-// conditional branches have a fall through case, selects don't, and
+stackDepth += delta;
-// jsr/jsr_w return to the next instruction.
+if (stackDepth > maxStackDepth) {
-branchTargets.push(branch.getTarget(), stackDepth);
+maxStackDepth = stackDepth;
-} else {
+}
-// check for instructions that terminate the method.
+// choose the next instruction based on whether current is a branch.
-if(opcode == Constants.ATHROW || opcode == Constants.RET ||
+if (instruction instanceof BranchInstruction) {
-(opcode >= Constants.IRETURN && opcode <= Constants.RETURN))
+final BranchInstruction branch = (BranchInstruction) instruction;
-ih = null;
+if (instruction instanceof Select) {
-}
+// explore all of the select's targets. the default target is handled below.
-// normal case, go to the next instruction.
+final Select select = (Select) branch;
-if(ih != null)
+final InstructionHandle[] targets = select.getTargets();
-ih = ih.getNext();
+for (final InstructionHandle target : targets) {
-// if we have no more instructions, see if there are any deferred branches to explore.
+branchTargets.push(target, stackDepth);
-if(ih == null) {
+}
-BranchTarget bt = branchTargets.pop();
+// nothing to fall through to.
-if (bt != null) {
+ih = null;
-ih = bt.target;
+} else if (!(branch instanceof IfInstruction)) {
-stackDepth = bt.stackDepth;
+// if an instruction that comes back to following PC,
-}
+// push next instruction, with stack depth reduced by 1.
-}
+if (opcode == Const.JSR || opcode == Const.JSR_W) {
-}
+branchTargets.push(ih.getNext(), stackDepth - 1);
+}
-return maxStackDepth;
+ih = null;
 }
+// for all branches, the target of the branch is pushed on the branch stack.
-private ArrayList observers;
+// conditional branches have a fall through case, selects don't, and
+// jsr/jsr_w return to the next instruction.
-/** Add observer for this object.
+branchTargets.push(branch.getTarget(), stackDepth);
-*/
+} else {
-public void addObserver(MethodObserver o) {
+// check for instructions that terminate the method.
-if(observers == null)
+if (opcode == Const.ATHROW || opcode == Const.RET
-observers = new ArrayList();
+|| (opcode >= Const.IRETURN && opcode <= Const.RETURN)) {
+ih = null;
-observers.add(o);
+}
 }
+// normal case, go to the next instruction.
-/** Remove observer for this object.
+if (ih != null) {
-*/
+ih = ih.getNext();
-public void removeObserver(MethodObserver o) {
+}
-if(observers != null)
+// if we have no more instructions, see if there are any deferred branches to explore.
-observers.remove(o);
+if (ih == null) {
-}
+final BranchTarget bt = branchTargets.pop();
+if (bt != null) {
-/** Call notify() method on all observers. This method is not called
+ih = bt.target;
-* automatically whenever the state has changed, but has to be
+stackDepth = bt.stackDepth;
-* called by the user after he has finished editing the object.
+}
-*/
+}
-public void update() {
+}
-if(observers != null)
+return maxStackDepth;
-for(Iterator e = observers.iterator(); e.hasNext(); )
+}
-((MethodObserver)e.next()).notify(this);
-}
+private List<MethodObserver> observers;
 /**
-* Return string representation close to declaration format,
+* Add observer for this object.
-* `public static void _main(String[]) throws IOException', e.g.
+*/
-*
+public void addObserver(final MethodObserver o) {
-* @return String representation of the method.
+if (observers == null) {
-*/
+observers = new ArrayList<>();
-public final String toString() {
+}
-String access    = Utility.accessToString(access_flags);
+observers.add(o);
-String signature = Type.getMethodSignature(type, arg_types);
+}
-signature = Utility.methodSignatureToString(signature, name, access,
+/**
-true, getLocalVariableTable(cp));
+* Remove observer for this object.
+*/
-StringBuffer buf = new StringBuffer(signature);
+public void removeObserver(final MethodObserver o) {
+if (observers != null) {
-if(throws_vec.size() > 0) {
+observers.remove(o);
-for(Iterator e = throws_vec.iterator(); e.hasNext(); )
+}
-buf.append("\n\t\tthrows " + e.next());
+}
-}
+/**
-return buf.toString();
+* 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.
-/** @return deep copy of this method
+*/
-*/
+public void update() {
-public MethodGen copy(String class_name, ConstantPoolGen cp) {
+if (observers != null) {
-Method    m  = ((MethodGen)clone()).getMethod();
+for (final MethodObserver observer : observers) {
-MethodGen mg = new MethodGen(m, class_name, this.cp);
+observer.notify(this);
+}
-if(this.cp != cp) {
+}
-mg.setConstantPool(cp);
+}
-mg.getInstructionList().replaceConstantPool(this.cp, cp);
-}
+/**
+* Return string representation close to declaration format, e.g. public
-return mg;
+* static void main(String[]) throws IOException'
-}
+*
+* @return String representation of the method.
+*/
+@Override
+public final String toString() {
+final String access = Utility.accessToString(super.getAccessFlags());
+String signature = Type.getMethodSignature(super.getType(), arg_types);
+signature = Utility.methodSignatureToString(signature, super.getName(), access, true,
+getLocalVariableTable(super.getConstantPool()));
+final StringBuilder buf = new StringBuilder(signature);
+for (final Attribute a : getAttributes()) {
+if (!((a instanceof Code) || (a instanceof ExceptionTable))) {
+buf.append(" [").append(a).append("]");
+}
+}
+if (throws_vec.size() > 0) {
+for (final String throwsDescriptor : throws_vec) {
+buf.append("\n\t\tthrows ").append(throwsDescriptor);
+}
+}
+return buf.toString();
+}
+/**
+* @return deep copy of this method
+*/
+public MethodGen copy(final String class_name, final ConstantPoolGen cp) {
+final Method m = ((MethodGen) clone()).getMethod();
+final MethodGen mg = new MethodGen(m, class_name, super.getConstantPool());
+if (super.getConstantPool() != cp) {
+mg.setConstantPool(cp);
+mg.getInstructionList().replaceConstantPool(super.getConstantPool(), cp);
+}
+return mg;
+}
+//J5TODO: Should param_annotations be an array of arrays? Rather than an array of lists, this
+// is more likely to suggest to the caller it is readonly (which a List does not).
+/**
+* Return a list of AnnotationGen objects representing parameter annotations
+*
+* @since 6.0
+*/
+public List<AnnotationEntryGen> getAnnotationsOnParameter(final int i) {
+ensureExistingParameterAnnotationsUnpacked();
+if (!hasParameterAnnotations || i > arg_types.length) {
+return null;
+}
+return param_annotations[i];
+}
+/**
+* Goes through the attributes on the method and identifies any that are
+* RuntimeParameterAnnotations, extracting their contents and storing them
+* as parameter annotations. There are two kinds of parameter annotation -
+* visible and invisible. Once they have been unpacked, these attributes are
+* deleted. (The annotations will be rebuilt as attributes when someone
+* builds a Method object out of this MethodGen object).
+*/
+private void ensureExistingParameterAnnotationsUnpacked() {
+if (haveUnpackedParameterAnnotations) {
+return;
+}
+// Find attributes that contain parameter annotation data
+final Attribute[] attrs = getAttributes();
+ParameterAnnotations paramAnnVisAttr = null;
+ParameterAnnotations paramAnnInvisAttr = null;
+for (final Attribute attribute : attrs) {
+if (attribute instanceof ParameterAnnotations) {
+// Initialize param_annotations
+if (!hasParameterAnnotations) {
+@SuppressWarnings("unchecked") // OK
+final List<AnnotationEntryGen>[] parmList = new List[arg_types.length];
+param_annotations = parmList;
+for (int j = 0; j < arg_types.length; j++) {
+param_annotations[j] = new ArrayList<>();
+}
+}
+hasParameterAnnotations = true;
+final ParameterAnnotations rpa = (ParameterAnnotations) attribute;
+if (rpa instanceof RuntimeVisibleParameterAnnotations) {
+paramAnnVisAttr = rpa;
+} else {
+paramAnnInvisAttr = rpa;
+}
+for (int j = 0; j < arg_types.length; j++) {
+// This returns Annotation[] ...
+final ParameterAnnotationEntry immutableArray = rpa
+.getParameterAnnotationEntries()[j];
+// ... which needs transforming into an AnnotationGen[] ...
+final List<AnnotationEntryGen> mutable
+= makeMutableVersion(immutableArray.getAnnotationEntries());
+// ... then add these to any we already know about
+param_annotations[j].addAll(mutable);
+}
+}
+}
+if (paramAnnVisAttr != null) {
+removeAttribute(paramAnnVisAttr);
+}
+if (paramAnnInvisAttr != null) {
+removeAttribute(paramAnnInvisAttr);
+}
+haveUnpackedParameterAnnotations = true;
+}
+private List<AnnotationEntryGen> makeMutableVersion(final AnnotationEntry[] mutableArray) {
+final List<AnnotationEntryGen> result = new ArrayList<>();
+for (final AnnotationEntry element : mutableArray) {
+result.add(new AnnotationEntryGen(element, getConstantPool(),
+false));
+}
+return result;
+}
+public void addParameterAnnotation(final int parameterIndex,
+final AnnotationEntryGen annotation) {
+ensureExistingParameterAnnotationsUnpacked();
+if (!hasParameterAnnotations) {
+@SuppressWarnings("unchecked") // OK
+final List<AnnotationEntryGen>[] parmList = new List[arg_types.length];
+param_annotations = parmList;
+hasParameterAnnotations = true;
+}
+final List<AnnotationEntryGen> existingAnnotations = param_annotations[parameterIndex];
+if (existingAnnotations != null) {
+existingAnnotations.add(annotation);
+} else {
+final List<AnnotationEntryGen> l = new ArrayList<>();
+l.add(annotation);
+param_annotations[parameterIndex] = l;
+}
+}
+/**
+* @return Comparison strategy object
+*/
+public static BCELComparator getComparator() {
+return bcelComparator;
+}
+/**
+* @param comparator Comparison strategy object
+*/
+public static void setComparator(final BCELComparator comparator) {
+bcelComparator = comparator;
+}
+/**
+* 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.
+*
+* @see java.lang.Object#equals(java.lang.Object)
+*/
+@Override
+public boolean equals(final Object obj) {
+return bcelComparator.equals(this, obj);
+}
+/**
+* Return value as defined by given BCELComparator strategy. By default
+* return the hashcode of the method's name XOR signature.
+*
+* @see java.lang.Object#hashCode()
+*/
+@Override
+public int hashCode() {
+return bcelComparator.hashCode(this);
+}
 }

changeset 46174	5611d2529b49
parent 44797	8b3b3b911b8a