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

equal deleted inserted replaced

-:badfa812b82a
+:8e0ae3830fca
 /*
-* Copyright (c) 2013, 2017, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2013, 2019, Oracle and/or its affiliates. All rights reserved.
 */
 /*
 * 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.
 * 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
+* use the `removeNOPs' method to get rid off them.
-* can be obtained via the `getMethod()' method.
+* The resulting method object can be obtained via the `getMethod()' method.
 *
-* @version $Id: MethodGen.java 1749603 2016-06-21 20:50:19Z ggregory $
+* @version $Id$
-* @see InstructionList
+* @see     InstructionList
-* @see Method
+* @see     Method
-* @LastModified: Oct 2017
+* @LastModified: Jun 2019
 */
 public class MethodGen extends FieldGenOrMethodGen {
 private String class_name;
 private Type[] arg_types;
 private String[] arg_names;
 private int max_locals;
 private int max_stack;
 private InstructionList il;
 private boolean strip_attributes;
+private LocalVariableTypeTable local_variable_type_table = null;
 private final List<LocalVariableGen> variable_vec = new ArrayList<>();
-private final List<LocalVariableGen> type_vec = new ArrayList<>();
 private final List<LineNumberGen> line_number_vec = new ArrayList<>();
 private final List<CodeExceptionGen> exception_vec = new ArrayList<>();
 private final List<String> throws_vec = new ArrayList<>();
 private final List<Attribute> code_attrs_vec = new ArrayList<>();
 private boolean haveUnpackedParameterAnnotations = false;
 private static BCELComparator bcelComparator = new BCELComparator() {
 @Override
-public boolean equals(final Object o1, final Object o2) {
+public boolean equals( final Object o1, final Object o2 ) {
 final MethodGen THIS = (MethodGen) o1;
 final MethodGen THAT = (MethodGen) o2;
 return THIS.getName().equals(THAT.getName())
 && THIS.getSignature().equals(THAT.getSignature());
 }
 @Override
-public int hashCode(final Object o) {
+public int hashCode( final Object o ) {
 final MethodGen THIS = (MethodGen) o;
 return THIS.getSignature().hashCode() ^ THIS.getName().hashCode();
 }
 };
-/**
-* Declare method. If the method is non-static the constructor automatically
+/**
-* declares a local variable `$this' in slot 0. The actual code is contained
+* Declare method. If the method is non-static the constructor
-* in the `il' parameter, which may further manipulated by the user. But he
+* automatically declares a local variable `$this' in slot 0. The
-* must take care not to remove any instruction (handles) that are still
+* actual code is contained in the `il' parameter, which may further
-* referenced from this object.
+* 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
+* instructions it refers to without causing havoc. It is safe
-* you remove that local variable, too.
+* however if you remove that local variable, too.
 *
 * @param access_flags access qualifiers
-* @param return_type method type
+* @param return_type  method type
 * @param arg_types argument types
-* @param arg_names argument names (if this is null, default names will be
+* @param arg_names argument names (if this is null, default names will be provided
-* provided for them)
+* for them)
 * @param method_name name of method
-* @param class_name class name containing this method (may be null, if you
+* @param class_name class name containing this method (may be null, if you don't care)
-* don't care)
+* @param il instruction list associated with this method, may be null only for
-* @param il instruction list associated with this method, may be null only
+* abstract or native methods
-* for abstract or native methods
 * @param cp constant pool
 */
 public MethodGen(final int access_flags, final Type return_type, final Type[] arg_types, String[] arg_names,
 final String method_name, final String class_name, final InstructionList il, final ConstantPoolGen cp) {
 super(access_flags);
 setClassName(class_name);
 setInstructionList(il);
 setConstantPool(cp);
 final boolean abstract_ = isAbstract() || isNative();
 InstructionHandle start = null;
-InstructionHandle end = null;
+final InstructionHandle end = null;
 if (!abstract_) {
 start = il.getStart();
-end = il.getEnd();
+// end == null => live to end of method
 /* Add local variables, namely the implicit `this' and the arguments
 */
 if (!isStatic() && (class_name != null)) { // Instance method -> `this' is local var 0
-addLocalVariable("this", ObjectType.getInstance(class_name), start, end);
+addLocalVariable("this",  ObjectType.getInstance(class_name), start, end);
 }
 }
 if (arg_types != null) {
 final int size = arg_types.length;
 for (final Type arg_type : arg_types) {
 }
 }
 }
 }
 /**
 * Instantiate from existing method.
 *
 * @param m method
 * @param class_name class name containing this method
 * @param cp constant pool
 */
 public MethodGen(final Method m, final String class_name, final ConstantPoolGen cp) {
 this(m.getAccessFlags(), Type.getReturnType(m.getSignature()), Type.getArgumentTypes(m
-.getSignature()), null /* may be overridden anyway */, m.getName(), class_name,
+.getSignature()), null /* may be overridden anyway */
+, m.getName(), class_name,
 ((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;
 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);
+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
 if (ih != null) {
 addLineNumber(ih, l.getLineNumber());
 }
 }
 } else if (a instanceof LocalVariableTable) {
-final LocalVariable[] lv = ((LocalVariableTable) a).getLocalVariableTable();
+updateLocalVariableTable((LocalVariableTable) a);
-removeLocalVariables();
-repairHandles(lv, false);
 } else if (a instanceof LocalVariableTypeTable) {
-LocalVariable[] lv = ((LocalVariableTypeTable) a).getLocalVariableTypeTable();
+this.local_variable_type_table = (LocalVariableTypeTable) a.copy(cp.getConstantPool());
-removeLocalVariableTypes();
-repairHandles(lv, true);
 } else {
 addCodeAttribute(a);
 }
 }
 } else if (a instanceof ExceptionTable) {
 addAttribute(a);
 }
 }
 }
-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());
-InstructionHandle end = il.findHandle(l.getStartPC() + l.getLength());
-// Repair malformed handles
-if (null == start) {
-start = il.getStart();
-}
-if (null == end) {
-end = il.getEnd();
-}
-if (isLVT) {
-addLocalVariableType(l.getName(), Type.getType(l.getSignature()),
-l.getIndex(), start, end);
-} else {
-addLocalVariable(l.getName(), Type.getType(l.getSignature()),
-l.getIndex(), start, end);
-}
-}
-}
 /**
 * Adds a local variable to this method.
 *
 * @param name variable name
 * @param type variable type
-* @param slot the index of the local variable, if type is long or double,
+* @param slot the index of the local variable, if type is long or double, the next available
-* the next available index is slot+2
+* index is slot+2
 * @param start from where the variable is valid
 * @param end until where the variable is valid
+* @param orig_index the index of the local variable prior to any modifications
 * @return new local variable object
 * @see LocalVariable
 */
-public LocalVariableGen addLocalVariable(final String name, final Type type, final int slot,
+public LocalVariableGen addLocalVariable( final String name, final Type type, final int slot,
-final InstructionHandle start, final InstructionHandle end) {
+final InstructionHandle start, final InstructionHandle end, final int orig_index ) {
 final byte t = type.getType();
 if (t != Const.T_ADDRESS) {
 final int add = type.getSize();
 if (slot + add > max_locals) {
 max_locals = slot + add;
 }
-final LocalVariableGen l = new LocalVariableGen(slot, name, type, start, end);
+final LocalVariableGen l = new LocalVariableGen(slot, name, type, start, end, orig_index);
 int i;
 if ((i = variable_vec.indexOf(l)) >= 0) {
 variable_vec.set(i, l);
 } else {
 variable_vec.add(l);
 }
 throw new IllegalArgumentException("Can not use " + type
 + " as type for local variable");
 }
-/**
-* Adds a local variable to this method and assigns an index automatically.
+/**
+* Adds a local variable to this method.
 *
 * @param name variable name
 * @param type variable type
-* @param start from where the variable is valid, if this is null, it is
+* @param slot the index of the local variable, if type is long or double, the next available
-* valid from the start
+* index is slot+2
-* @param end until where the variable is valid, if this is null, it is
+* @param start from where the variable is valid
-* valid to the end
+* @param end until where the variable is valid
 * @return new local variable object
 * @see LocalVariable
 */
-public LocalVariableGen addLocalVariable(final String name, final Type type,
+public LocalVariableGen addLocalVariable( final String name, final Type type, final int slot,
-final InstructionHandle start, final InstructionHandle end) {
+final InstructionHandle start, final InstructionHandle end ) {
+return addLocalVariable(name, type, slot, start, end, slot);
+}
+/**
+* Adds a local variable to this method and assigns an index automatically.
+*
+* @param name variable name
+* @param type variable type
+* @param start from where the variable is valid, if this is null,
+* it is valid from the start
+* @param end until where the variable is valid, if this is null,
+* it is valid to the end
+* @return new local variable object
+* @see LocalVariable
+*/
+public LocalVariableGen addLocalVariable( final String name, final Type type, final InstructionHandle start,
+final InstructionHandle end ) {
 return addLocalVariable(name, type, max_locals, start, end);
 }
 /**
 * Remove a local variable, its slot will not be reused, if you do not use
 * addLocalVariable with an explicit index argument.
 */
 public void removeLocalVariable(final LocalVariableGen l) {
 variable_vec.remove(l);
 }
 /**
 * Remove all local variables.
 */
 public void removeLocalVariables() {
 variable_vec.clear();
 }
 /*
 * 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 variables sorted by index
 */
 public LocalVariableGen[] getLocalVariables() {
-return getLocalVariableOrTypes(false);
+final int size = variable_vec.size();
-}
+final LocalVariableGen[] lg = new LocalVariableGen[size];
+variable_vec.toArray(lg);
-/*
-* 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
-*/
-private LocalVariableGen[] getLocalVariableTypes() {
-return getLocalVariableOrTypes(true);
-}
-/*
-* 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.
-*
-* @return array of declared local variables or types sorted by index
-*/
-private LocalVariableGen[] getLocalVariableOrTypes(boolean isLVT) {
-int size = (isLVT) ? type_vec.size() : variable_vec.size();
-LocalVariableGen[] lg = new LocalVariableGen[size];
-if (isLVT) {
-type_vec.toArray(lg);
-} else {
-variable_vec.toArray(lg);
-}
 for (int i = 0; i < size; i++) {
-if (lg[i].getStart() == null) {
+if ((lg[i].getStart() == null) && (il != null)) {
 lg[i].setStart(il.getStart());
 }
+if ((lg[i].getEnd() == null) && (il != null)) {
-if (lg[i].getEnd() == null) {
 lg[i].setEnd(il.getEnd());
 }
 }
 if (size > 1) {
 Arrays.sort(lg, new Comparator<LocalVariableGen>() {
 @Override
 public int compare(final LocalVariableGen o1, final LocalVariableGen o2) {
 return o1.getIndex() - o2.getIndex();
 }
 });
 }
 return lg;
 }
-/**
-* @return `LocalVariableTable' attribute of all the local variables of this
+/**
-* method.
+* @return `LocalVariableTable' attribute of all the local variables of this method.
 */
-public LocalVariableTable getLocalVariableTable(final ConstantPoolGen cp) {
+public LocalVariableTable getLocalVariableTable( final ConstantPoolGen cp ) {
 final LocalVariableGen[] lg = getLocalVariables();
 final int size = lg.length;
 final LocalVariable[] lv = new LocalVariable[size];
 for (int i = 0; i < size; i++) {
 lv[i] = lg[i].getLocalVariable(cp);
 return new LocalVariableTable(cp.addUtf8("LocalVariableTable"), 2 + lv.length * 10, lv, cp
 .getConstantPool());
 }
 /**
-* @return `LocalVariableTypeTable' attribute of all the local variable
+* @return `LocalVariableTypeTable' attribute of this method.
-* types of this method.
+*/
-*/
+public LocalVariableTypeTable getLocalVariableTypeTable() {
-public LocalVariableTypeTable getLocalVariableTypeTable(ConstantPoolGen cp) {
+return local_variable_type_table;
-LocalVariableGen[] lg = getLocalVariableTypes();
-int size = lg.length;
-LocalVariable[] lv = new LocalVariable[size];
-for (int i = 0; i < size; i++) {
-lv[i] = lg[i].getLocalVariable(cp);
-}
-return new LocalVariableTypeTable(cp.addUtf8("LocalVariableTypeTable"),
-2 + lv.length * 10, lv, cp.getConstantPool());
-}
-/**
-* Adds a local variable type to this method.
-*
-* @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
-* @param start from where the variable is valid
-* @param end until where the variable is valid
-* @return new local variable object
-* @see LocalVariable
-*/
-private LocalVariableGen addLocalVariableType(String name, Type type, int slot,
-InstructionHandle start,
-InstructionHandle end) {
-byte t = type.getType();
-if (t != Const.T_ADDRESS) {
-int add = type.getSize();
-if (slot + add > max_locals) {
-max_locals = slot + add;
-}
-LocalVariableGen l = new LocalVariableGen(slot, name, type, start, end);
-int i;
-if ((i = type_vec.indexOf(l)) >= 0) // Overwrite if necessary
-{
-type_vec.set(i, l);
-} else {
-type_vec.add(l);
-}
-return l;
-} else {
-throw new IllegalArgumentException("Can not use " + type
-+ " as type for local variable");
-}
-}
-/**
-* Remove all local variable types.
-*/
-private void removeLocalVariableTypes() {
-type_vec.clear();
 }
 /**
 * Give an instruction a line number corresponding to the source code line.
 *
 * @param ih instruction to tag
 * @return new line number object
 * @see LineNumber
 */
-public LineNumberGen addLineNumber(final InstructionHandle ih, final int src_line) {
+public LineNumberGen addLineNumber( final InstructionHandle ih, final int src_line ) {
 final LineNumberGen l = new LineNumberGen(ih, src_line);
 line_number_vec.add(l);
 return l;
 }
 /**
 * Remove a line number.
 */
-public void removeLineNumber(final LineNumberGen l) {
+public void removeLineNumber( final LineNumberGen l ) {
 line_number_vec.remove(l);
 }
 /**
 * Remove all line numbers.
 */
 public void removeLineNumbers() {
 line_number_vec.clear();
 }
 /*
 * @return array of line numbers
 */
 public LineNumberGen[] getLineNumbers() {
 final LineNumberGen[] lg = new LineNumberGen[line_number_vec.size()];
 line_number_vec.toArray(lg);
 return lg;
 }
-/**
-* @return `LineNumberTable' attribute of all the local variables of this
+/**
-* method.
+* @return `LineNumberTable' attribute of all the local variables of this method.
 */
-public LineNumberTable getLineNumberTable(final ConstantPoolGen cp) {
+public LineNumberTable getLineNumberTable( final ConstantPoolGen cp ) {
 final int size = line_number_vec.size();
 final LineNumber[] ln = new LineNumber[size];
 for (int i = 0; i < size; i++) {
 ln[i] = line_number_vec.get(i).getLineNumber();
 }
 return new LineNumberTable(cp.addUtf8("LineNumberTable"), 2 + ln.length * 4, ln, cp
 .getConstantPool());
 }
-/**
-* Add an exception handler, i.e., specify region where a handler is active
+/**
-* and an instruction where the actual handling is done.
+* 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)
 * @param end_pc End of region (inclusive)
 * @param handler_pc Where handling is done
 * @param catch_type class type of handled exception or null if any
 * exception is handled
 * @return new exception handler object
 */
-public CodeExceptionGen addExceptionHandler(final InstructionHandle start_pc,
+public CodeExceptionGen addExceptionHandler( final InstructionHandle start_pc,
-final InstructionHandle end_pc, final InstructionHandle handler_pc, final ObjectType catch_type) {
+final InstructionHandle end_pc, final InstructionHandle handler_pc, final ObjectType catch_type ) {
 if ((start_pc == null) || (end_pc == null) || (handler_pc == null)) {
 throw new ClassGenException("Exception handler target is null instruction");
 }
 final CodeExceptionGen c = new CodeExceptionGen(start_pc, end_pc, handler_pc, catch_type);
 exception_vec.add(c);
 return c;
 }
 /**
 * Remove an exception handler.
 */
-public void removeExceptionHandler(final CodeExceptionGen c) {
+public void removeExceptionHandler( final CodeExceptionGen c ) {
 exception_vec.remove(c);
 }
 /**
 * Remove all line numbers.
 */
 public void removeExceptionHandlers() {
 exception_vec.clear();
 }
 /*
 * @return array of declared exception handlers
 */
 public CodeExceptionGen[] getExceptionHandlers() {
 final CodeExceptionGen[] cg = new CodeExceptionGen[exception_vec.size()];
 exception_vec.toArray(cg);
 return cg;
 }
 /**
 * @return code exceptions for `Code' attribute
 */
 private CodeException[] getCodeExceptions() {
 final int size = exception_vec.size();
 final CodeException[] c_exc = new CodeException[size];
 for (int i = 0; i < size; i++) {
-final CodeExceptionGen c = exception_vec.get(i);
+final CodeExceptionGen c =  exception_vec.get(i);
 c_exc[i] = c.getCodeException(super.getConstantPool());
 }
 return c_exc;
 }
 /**
 * Add an exception possibly thrown by this method.
 *
 * @param class_name (fully qualified) name of exception
 */
-public void addException(final String class_name) {
+public void addException( final String class_name ) {
 throws_vec.add(class_name);
 }
 /**
 * Remove an exception.
 */
-public void removeException(final String c) {
+public void removeException( final String c ) {
 throws_vec.remove(c);
 }
 /**
 * Remove all exceptions.
 */
 public void removeExceptions() {
 throws_vec.clear();
 }
 /*
 * @return array of thrown exceptions
 */
 public String[] getExceptions() {
 final String[] e = new String[throws_vec.size()];
 throws_vec.toArray(e);
 return e;
 }
-/**
-* @return `Exceptions' attribute of all the exceptions thrown by this
+/**
-* method.
+* @return `Exceptions' attribute of all the exceptions thrown by this method.
 */
-private ExceptionTable getExceptionTable(final ConstantPoolGen cp) {
+private ExceptionTable getExceptionTable( final ConstantPoolGen cp ) {
 final int size = throws_vec.size();
 final int[] ex = new int[size];
 for (int i = 0; i < size; i++) {
 ex[i] = cp.addClass(throws_vec.get(i));
 }
 return new ExceptionTable(cp.addUtf8("Exceptions"), 2 + 2 * size, ex, cp.getConstantPool());
 }
 /**
 * Add an attribute to the code. Currently, the JVM knows about the
-* LineNumberTable, LocalVariableTable and StackMap attributes, where the
+* LineNumberTable, LocalVariableTable and StackMap attributes,
-* former two will be generated automatically and the latter is used for the
+* where the former two will be generated automatically and the
-* MIDP only. Other attributes will be ignored by the JVM but do no harm.
+* 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
 */
-public void addCodeAttribute(final Attribute a) {
+public void addCodeAttribute( final Attribute a ) {
 code_attrs_vec.add(a);
 }
+/**
+* Remove the LocalVariableTypeTable
+*/
+public void removeLocalVariableTypeTable( ) {
+local_variable_type_table = null;
+}
 /**
 * Remove a code attribute.
 */
-public void removeCodeAttribute(final Attribute a) {
+public void removeCodeAttribute( final Attribute a ) {
 code_attrs_vec.remove(a);
 }
 /**
 * Remove all code attributes.
 */
 public void removeCodeAttributes() {
+local_variable_type_table = null;
 code_attrs_vec.clear();
 }
 /**
 * @return all attributes of this method.
 */
 public Attribute[] getCodeAttributes() {
 /**
 * @since 6.0
 */
 public void addAnnotationsAsAttribute(final ConstantPoolGen cp) {
 final Attribute[] attrs = AnnotationEntryGen.getAnnotationAttributes(cp, super.getAnnotationEntries());
 for (final Attribute attr : attrs) {
 addAttribute(attr);
 }
 }
 /**
 * @since 6.0
 */
 public void addParameterAnnotationsAsAttribute(final ConstantPoolGen cp) {
 if (!hasParameterAnnotations) {
 return;
 }
-final Attribute[] attrs = AnnotationEntryGen.getParameterAnnotationAttributes(cp, param_annotations);
+final Attribute[] attrs = AnnotationEntryGen.getParameterAnnotationAttributes(cp,param_annotations);
 if (attrs != null) {
 for (final Attribute attr : attrs) {
 addAttribute(attr);
 }
 }
 }
-/**
-* Get method object. Never forget to call setMaxStack() or
+/**
-* setMaxStack(max), respectively, before calling this method (the same
+* Get method object. Never forget to call setMaxStack() or setMaxStack(max), respectively,
-* applies for max locals).
+* before calling this method (the same applies for max locals).
 *
 * @return method object
 */
 public Method getMethod() {
 final String signature = getSignature();
 if (il != null) {
 byte_code = il.getByteCode();
 }
 LineNumberTable lnt = null;
 LocalVariableTable lvt = null;
-LocalVariableTypeTable lvtt = null;
+/* Create LocalVariableTable and LineNumberTable attributes (for debuggers, e.g.)
-/* Create LocalVariableTable, LocalvariableTypeTable, and LineNumberTable
-* attributes (for debuggers, e.g.)
 */
 if ((variable_vec.size() > 0) && !strip_attributes) {
+updateLocalVariableTable(getLocalVariableTable(_cp));
 addCodeAttribute(lvt = getLocalVariableTable(_cp));
 }
+if (local_variable_type_table != null) {
-if ((type_vec.size() > 0) && !strip_attributes) {
+// LocalVariable length in LocalVariableTypeTable is not updated automatically. It's a difference with LocalVariableTable.
-addCodeAttribute(lvtt = getLocalVariableTypeTable(_cp));
+if (lvt != null) {
-}
+adjustLocalVariableTypeTable(lvt);
+}
+addCodeAttribute(local_variable_type_table);
+}
 if ((line_number_vec.size() > 0) && !strip_attributes) {
 addCodeAttribute(lnt = getLineNumberTable(_cp));
 }
 final Attribute[] code_attrs = getCodeAttributes();
 /* Each attribute causes 6 additional header bytes
 .getConstantPool());
 // Undo effects of adding attributes
 if (lvt != null) {
 removeCodeAttribute(lvt);
 }
-if (lvtt != null) {
+if (local_variable_type_table != null) {
-removeCodeAttribute(lvtt);
+removeCodeAttribute(local_variable_type_table);
 }
 if (lnt != null) {
 removeCodeAttribute(lnt);
 }
 if (code != null) {
 if (et != null) {
 removeAttribute(et);
 }
 return m;
 }
+private void updateLocalVariableTable(final LocalVariableTable a) {
+final LocalVariable[] lv = a.getLocalVariableTable();
+removeLocalVariables();
+for (final LocalVariable l : lv) {
+InstructionHandle start = il.findHandle(l.getStartPC());
+final InstructionHandle end = il.findHandle(l.getStartPC() + l.getLength());
+// Repair malformed handles
+if (null == start) {
+start = il.getStart();
+}
+// end == null => live to end of method
+// Since we are recreating the LocalVaraible, we must
+// propagate the orig_index to new copy.
+addLocalVariable(l.getName(), Type.getType(l.getSignature()), l
+.getIndex(), start, end, l.getOrigIndex());
+}
+}
+private void adjustLocalVariableTypeTable(final LocalVariableTable lvt) {
+final LocalVariable[] lv = lvt.getLocalVariableTable();
+final LocalVariable[] lvg = local_variable_type_table.getLocalVariableTypeTable();
+for (final LocalVariable element : lvg) {
+for (final LocalVariable l : lv) {
+if (element.getName().equals(l.getName()) && element.getIndex() == l.getOrigIndex()) {
+element.setLength(l.getLength());
+element.setStartPC(l.getStartPC());
+element.setIndex(l.getIndex());
+break;
+}
+}
+}
+}
 /**
 * 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.
 }
 }
 }
 }
 /**
 * Set maximum number of local variables.
 */
-public void setMaxLocals(final int m) {
+public void setMaxLocals( final int m ) {
 max_locals = m;
 }
 public int getMaxLocals() {
 return max_locals;
 }
 /**
 * Set maximum stack size for this method.
 */
-public void setMaxStack(final int m) { // TODO could be package-protected?
+public void setMaxStack( final int m ) { // TODO could be package-protected?
 max_stack = m;
 }
 public int getMaxStack() {
 return max_stack;
 }
-/**
-* @return class that contains this method
+/** @return class that contains this method
 */
 public String getClassName() {
 return class_name;
 }
-public void setClassName(final String class_name) { // TODO could be package-protected?
+public void setClassName( final String class_name ) { // TODO could be package-protected?
 this.class_name = class_name;
 }
-public void setReturnType(final Type return_type) {
+public void setReturnType( final Type return_type ) {
 setType(return_type);
 }
 public Type getReturnType() {
 return getType();
 }
-public void setArgumentTypes(final Type[] arg_types) {
+public void setArgumentTypes( final Type[] arg_types ) {
 this.arg_types = arg_types;
 }
 public Type[] getArgumentTypes() {
 return arg_types.clone();
 }
-public void setArgumentType(final int i, final Type type) {
+public void setArgumentType( final int i, final Type type ) {
 arg_types[i] = type;
 }
-public Type getArgumentType(final int i) {
+public Type getArgumentType( final int i ) {
 return arg_types[i];
 }
-public void setArgumentNames(final String[] arg_names) {
+public void setArgumentNames( final String[] arg_names ) {
 this.arg_names = arg_names;
 }
 public String[] getArgumentNames() {
 return arg_names.clone();
 }
-public void setArgumentName(final int i, final String name) {
+public void setArgumentName( final int i, final String name ) {
 arg_names[i] = name;
 }
-public String getArgumentName(final int i) {
+public String getArgumentName( final int i ) {
 return arg_names[i];
 }
 public InstructionList getInstructionList() {
 return il;
 }
-public void setInstructionList(final InstructionList il) { // TODO could be package-protected?
+public void setInstructionList( final InstructionList il ) { // TODO could be package-protected?
 this.il = il;
 }
 @Override
 public String getSignature() {
 return Type.getMethodSignature(super.getType(), arg_types);
 }
 /**
 * Computes max. stack size by performing control flow analysis.
 */
 public void setMaxStack() { // TODO could be package-protected? (some tests would need repackaging)
 max_stack = getMaxStack(super.getConstantPool(), il, getExceptionHandlers());
 } else {
 max_stack = 0;
 }
 }
 /**
 * Compute maximum number of local variables.
 */
 public void setMaxLocals() { // TODO could be package-protected? (some tests would need repackaging)
 } else {
 max_locals = 0;
 }
 }
-/**
-* Do not/Do produce attributes code attributesLineNumberTable and
+/** Do not/Do produce attributes code attributesLineNumberTable and
 * LocalVariableTable, like javac -O
 */
-public void stripAttributes(final boolean flag) {
+public void stripAttributes( final boolean flag ) {
 strip_attributes = flag;
 }
 static final class BranchTarget {
 final InstructionHandle target;
 final int stackDepth;
 BranchTarget(final InstructionHandle target, final int stackDepth) {
 this.target = target;
 this.stackDepth = stackDepth;
 }
 static final class BranchStack {
 private final Stack<BranchTarget> branchTargets = new Stack<>();
 private final Map<InstructionHandle, BranchTarget> visitedTargets = new HashMap<>();
-public void push(final InstructionHandle target, final int stackDepth) {
+public void push( final InstructionHandle target, final int stackDepth ) {
 if (visited(target)) {
 return;
 }
 branchTargets.push(visit(target, stackDepth));
 }
 public BranchTarget pop() {
 if (!branchTargets.empty()) {
 final BranchTarget bt = branchTargets.pop();
 return bt;
 }
 return null;
 }
-private BranchTarget visit(final InstructionHandle target, final int stackDepth) {
+private BranchTarget visit( final InstructionHandle target, final int stackDepth ) {
 final BranchTarget bt = new BranchTarget(target, stackDepth);
 visitedTargets.put(target, bt);
 return bt;
 }
-private boolean visited(final InstructionHandle target) {
+private boolean visited( final InstructionHandle target ) {
 return visitedTargets.get(target) != null;
 }
 }
-/**
-* Computes stack usage of an instruction list by performing control flow
+/**
-* analysis.
+* Computes stack usage of an instruction list by performing control flow analysis.
 *
 * @return maximum stack depth used by method
 */
-public static int getMaxStack(final ConstantPoolGen cp, final InstructionList il,
+public static int getMaxStack( final ConstantPoolGen cp, final InstructionList il, final CodeExceptionGen[] et ) {
-final CodeExceptionGen[] et) {
 final BranchStack branchTargets = new BranchStack();
 /* Initially, populate the branch stack with the exception
 * handlers, because these aren't (necessarily) branched to
 * explicitly. in each case, the stack will have depth 1,
 * containing the exception object.
 return maxStackDepth;
 }
 private List<MethodObserver> observers;
-/**
-* Add observer for this object.
+/** Add observer for this object.
 */
-public void addObserver(final MethodObserver o) {
+public void addObserver( final MethodObserver o ) {
 if (observers == null) {
 observers = new ArrayList<>();
 }
 observers.add(o);
 }
-/**
-* Remove observer for this object.
+/** Remove observer for this object.
 */
-public void removeObserver(final MethodObserver o) {
+public void removeObserver( final MethodObserver o ) {
 if (observers != null) {
 observers.remove(o);
 }
 }
-/**
-* Call notify() method on all observers. This method is not called
+/** Call notify() method on all observers. This method is not called
-* automatically whenever the state has changed, but has to be called by the
+* automatically whenever the state has changed, but has to be
-* user after he has finished editing the object.
+* called by the user after he has finished editing the object.
 */
 public void update() {
 if (observers != null) {
 for (final MethodObserver observer : observers) {
 observer.notify(this);
 }
 }
 }
-/**
-* Return string representation close to declaration format, e.g. public
+/**
-* static void main(String[]) throws IOException'
+* Return string representation close to declaration format,
+* `public static void main(String[]) throws IOException', e.g.
 *
 * @return String representation of the method.
 */
 @Override
 public final String toString() {
 }
 }
 return buf.toString();
 }
-/**
-* @return deep copy of this method
+/** @return deep copy of this method
 */
-public MethodGen copy(final String class_name, final ConstantPoolGen cp) {
+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);
 //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) {
 * 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() {
+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) {
+if (attribute instanceof ParameterAnnotations)
+{
 // Initialize param_annotations
-if (!hasParameterAnnotations) {
+if (!hasParameterAnnotations)
+{
 @SuppressWarnings({"rawtypes", "unchecked"})
 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<>();
 if (rpa instanceof RuntimeVisibleParameterAnnotations) {
 paramAnnVisAttr = rpa;
 } else {
 paramAnnInvisAttr = rpa;
 }
-for (int j = 0; j < arg_types.length; j++) {
+final ParameterAnnotationEntry[] parameterAnnotationEntries = rpa.getParameterAnnotationEntries();
+for (int j = 0; j < parameterAnnotationEntries.length; j++)
+{
 // This returns Annotation[] ...
-final ParameterAnnotationEntry immutableArray = rpa
+final ParameterAnnotationEntry immutableArray = rpa.getParameterAnnotationEntries()[j];
-.getParameterAnnotationEntries()[j];
 // ... which needs transforming into an AnnotationGen[] ...
-final List<AnnotationEntryGen> mutable
+final List<AnnotationEntryGen> mutable = makeMutableVersion(immutableArray.getAnnotationEntries());
-= makeMutableVersion(immutableArray.getAnnotationEntries());
 // ... then add these to any we already know about
 param_annotations[j].addAll(mutable);
 }
 }
 }
 removeAttribute(paramAnnInvisAttr);
 }
 haveUnpackedParameterAnnotations = true;
 }
-private List<AnnotationEntryGen> makeMutableVersion(final AnnotationEntry[] mutableArray) {
+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) {
+final AnnotationEntryGen annotation)
+{
 ensureExistingParameterAnnotationsUnpacked();
-if (!hasParameterAnnotations) {
+if (!hasParameterAnnotations)
+{
 @SuppressWarnings({"rawtypes", "unchecked"})
 final List<AnnotationEntryGen>[] parmList = new List[arg_types.length];
 param_annotations = parmList;
 hasParameterAnnotations = true;
 }
 final List<AnnotationEntryGen> existingAnnotations = param_annotations[parameterIndex];
-if (existingAnnotations != null) {
+if (existingAnnotations != null)
+{
 existingAnnotations.add(annotation);
-} else {
+}
+else
+{
 final List<AnnotationEntryGen> l = new ArrayList<>();
 l.add(annotation);
 param_annotations[parameterIndex] = l;
 }
 }
 */
 public static BCELComparator getComparator() {
 return bcelComparator;
 }
 /**
 * @param comparator Comparison strategy object
 */
-public static void setComparator(final BCELComparator comparator) {
+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
+* Return value as defined by given BCELComparator strategy.
-* are equal.
+* 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) {
+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.
+* 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() {

changeset 55496	8e0ae3830fca
parent 48409	5ab69533994b