/*
 * Copyright (c) 2013, 2017, 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.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * 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.classfile.AnnotationEntry;
import com.sun.org.apache.bcel.internal.classfile.Annotations;
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. The resulting method object
can be obtained via the `getMethod()' method.
See Also:
InstructionList
Method
Version:
$Id: MethodGen.java 1749603 2016-06-21 20:50:19Z ggregory $
@LastModified
: Oct 2017/**
 * Template class for building up a method. This is done by defining exception
 * handlers, adding thrown exceptions, local variables and attributes, whereas
 * the `LocalVariableTable' and `LineNumberTable' attributes will be set
 * automatically for the code. Use stripAttributes() if you don't like this.
 *
 * While generating code it may be necessary to insert NOP operations. You can
 * use the `removeNOPs' method to get rid off them. The resulting method object
 * can be obtained via the `getMethod()' method.
 *
 * @version $Id: MethodGen.java 1749603 2016-06-21 20:50:19Z ggregory $
 * @see InstructionList
 * @see Method
 * @LastModified: Oct 2017
 */
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 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 List<AnnotationEntryGen>[] param_annotations; // Array of lists containing AnnotationGen objects
    private boolean hasParameterAnnotations = false;
    private boolean haveUnpackedParameterAnnotations = false;

    private static BCELComparator bcelComparator = new BCELComparator() {

        @Override
        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) {
            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
in the `il' parameter, which may further manipulated by the user. But he
must take care not to remove any instruction (handles) that are still
referenced from this object.
For example one may not add a local variable and later remove the
instructions it refers to without causing havoc. It is safe however if
you remove that local variable, too.
Params:
access_flags – access qualifiers
return_type – method type
arg_types – argument types
arg_names – argument names (if this is null, default names will be
provided for them)
method_name – name of method
class_name – class name containing this method (may be null, if you
don't care)
il – instruction list associated with this method, may be null only
for abstract or native methods
cp – constant pool/**
     * Declare method. If the method is non-static the constructor automatically
     * declares a local variable `$this' in slot 0. The actual code is contained
     * in the `il' parameter, which may further manipulated by the user. But he
     * must take care not to remove any instruction (handles) that are still
     * referenced from this object.
     *
     * For example one may not add a local variable and later remove the
     * instructions it refers to without causing havoc. It is safe however if
     * you remove that local variable, too.
     *
     * @param access_flags access qualifiers
     * @param return_type method type
     * @param arg_types argument types
     * @param arg_names argument names (if this is null, default names will be
     * provided for them)
     * @param method_name name of method
     * @param class_name class name containing this method (may be null, if you
     * don't care)
     * @param il instruction list associated with this method, may be null only
     * 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);
        setType(return_type);
        setArgumentTypes(arg_types);
        setArgumentNames(arg_names);
        setName(method_name);
        setClassName(class_name);
        setInstructionList(il);
        setConstantPool(cp);
        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
             */
            if (!isStatic() && (class_name != null)) { // Instance method -> `this' is local var 0
                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) {
                if (Type.VOID == arg_type) {
                    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);
            }
            if (!abstract_) {
                for (int i = 0; i < size; i++) {
                    addLocalVariable(arg_names[i], arg_types[i], start, end);
                }
            }
        }
    }

    
Instantiate from existing method.
Params:
m – method
class_name – class name containing this method
cp – constant pool/**
     * 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,
                ((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 {
                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.
Params:
name – variable name
type – variable type
slot – the index of the local variable, if type is long or double,
the next available index is slot+2
start – from where the variable is valid
end – until where the variable is valid
See Also:
LocalVariable
Returns:
new local variable object/**
     * 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,
     * 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
     */
    public LocalVariableGen addLocalVariable(final String name, final Type type, final int slot,
            final InstructionHandle start, final InstructionHandle end) {

        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);
            int i;
            if ((i = variable_vec.indexOf(l)) >= 0) {
                variable_vec.set(i, l);
            } else {
                variable_vec.add(l);
            }
            return 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.
Params:
name – variable name
type – variable type
start – from where the variable is valid, if this is null, it is
valid from the start
end – until where the variable is valid, if this is null, it is
valid to the end
See Also:
LocalVariable
Returns:
new local variable object/**
     * 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.
/**
     * 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.
/**
     * 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);
    }

    /*
     * 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) {
                lg[i].setStart(il.getStart());
            }

            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;
    }

    
Returns:
`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) {
        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());
    }

    
Returns:
`LocalVariableTypeTable' attribute of all the local variable
types of this method./**
     * @return `LocalVariableTypeTable' attribute of all the local variable
     * types of this method.
     */
    public LocalVariableTypeTable getLocalVariableTypeTable(ConstantPoolGen cp) {
        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.
Params:
name – variable name
type – variable type
slot – the index of the local variable, if type is long or double,
the next available index is slot+2
start – from where the variable is valid
end – until where the variable is valid
See Also:
LocalVariable
Returns:
new local variable object/**
     * 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.
/**
     * Remove all local variable types.
     */
    private void removeLocalVariableTypes() {
        type_vec.clear();
    }

    
Give an instruction a line number corresponding to the source code line.
Params:
ih – instruction to tag
See Also:
LineNumber
Returns:
new line number object/**
     * 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) {
        final LineNumberGen l = new LineNumberGen(ih, src_line);
        line_number_vec.add(l);
        return l;
    }

    
Remove a line number.
/**
     * Remove a line number.
     */
    public void removeLineNumber(final LineNumberGen l) {
        line_number_vec.remove(l);
    }

    
Remove all line numbers.
/**
     * 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;
    }

    
Returns:
`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) {
        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.
Params:
start_pc – Start of region (inclusive)
end_pc – End of region (inclusive)
handler_pc – Where handling is done
catch_type – class type of handled exception or null if any
exception is handled
Returns:
new exception handler object/**
     * 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,
            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.
/**
     * Remove an exception handler.
     */
    public void removeExceptionHandler(final CodeExceptionGen c) {
        exception_vec.remove(c);
    }

    
Remove all line numbers.
/**
     * 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;
    }

    
Returns:
code exceptions for `Code' attribute/**
     * @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);
            c_exc[i] = c.getCodeException(super.getConstantPool());
        }
        return c_exc;
    }

    
Add an exception possibly thrown by this method.
Params:
class_name – (fully qualified) name of exception/**
     * Add an exception possibly thrown by this method.
     *
     * @param class_name (fully qualified) name of exception
     */
    public void addException(final String class_name) {
        throws_vec.add(class_name);
    }

    
Remove an exception.
/**
     * Remove an exception.
     */
    public void removeException(final String c) {
        throws_vec.remove(c);
    }

    
Remove all exceptions.
/**
     * 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;
    }

    
Returns:
`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) {
        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
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.
Params:
a – attribute to be added/**
     * Add an attribute to the code. Currently, the JVM knows about the
     * LineNumberTable, LocalVariableTable and StackMap attributes, where the
     * former two will be generated automatically and the latter is used for the
     * MIDP only. Other attributes will be ignored by the JVM but do no harm.
     *
     * @param a attribute to be added
     */
    public void addCodeAttribute(final Attribute a) {
        code_attrs_vec.add(a);
    }

    
Remove a code attribute.
/**
     * Remove a code attribute.
     */
    public void removeCodeAttribute(final Attribute a) {
        code_attrs_vec.remove(a);
    }

    
Remove all code attributes.
/**
     * Remove all code attributes.
     */
    public void removeCodeAttributes() {
        code_attrs_vec.clear();
    }

    
Returns:
all attributes of this method./**
     * @return all attributes of this method.
     */
    public Attribute[] getCodeAttributes() {
        final Attribute[] attributes = new Attribute[code_attrs_vec.size()];
        code_attrs_vec.toArray(attributes);
        return attributes;
    }

    
Since:
6.0/**
     * @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/**
     * @since 6.0
     */
    public void addParameterAnnotationsAsAttribute(final ConstantPoolGen cp) {
        if (!hasParameterAnnotations) {
            return;
        }
        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
applies for max locals).
Returns:
method object/**
     * Get method object. Never forget to call setMaxStack() or
     * setMaxStack(max), respectively, before calling this method (the same
     * applies for max locals).
     *
     * @return method object
     */
    public Method getMethod() {
        final String signature = getSignature();
        final ConstantPoolGen _cp = super.getConstantPool();
        final int name_index = _cp.addUtf8(super.getName());
        final int signature_index = _cp.addUtf8(signature);
        /* Also updates positions of instructions, i.e., their indices
         */
        byte[] byte_code = null;
        if (il != null) {
            byte_code = il.getByteCode();
        }
        LineNumberTable lnt = null;
        LocalVariableTable lvt = null;
        LocalVariableTypeTable lvtt = null;

        /* Create LocalVariableTable, LocalvariableTypeTable, and LineNumberTable
         * attributes (for debuggers, e.g.)
         */
        if ((variable_vec.size() > 0) && !strip_attributes) {
            addCodeAttribute(lvt = getLocalVariableTable(_cp));
        }

        if ((type_vec.size() > 0) && !strip_attributes) {
            addCodeAttribute(lvtt = getLocalVariableTypeTable(_cp));
        }

        if ((line_number_vec.size() > 0) && !strip_attributes) {
            addCodeAttribute(lnt = getLineNumberTable(_cp));
        }
        final Attribute[] code_attrs = getCodeAttributes();
        /* Each attribute causes 6 additional header bytes
         */
        int attrs_len = 0;
        for (final Attribute code_attr : code_attrs) {
            attrs_len += code_attr.getLength() + 6;
        }
        final CodeException[] c_exc = getCodeExceptions();
        final int exc_len = c_exc.length * 8; // Every entry takes 8 bytes
        Code code = null;
        if ((il != null) && !isAbstract() && !isNative()) {
            // Remove any stale code attribute
            final Attribute[] attributes = getAttributes();
            for (final Attribute a : attributes) {
                if (a instanceof Code) {
                    removeAttribute(a);
                }
            }
            code = new Code(_cp.addUtf8("Code"), 8 + byte_code.length + // prologue byte code
                    2 + exc_len + // exceptions
                    2 + attrs_len, // attributes
                    max_stack, max_locals, byte_code, c_exc, code_attrs, _cp.getConstantPool());
            addAttribute(code);
        }
        addAnnotationsAsAttribute(_cp);
        addParameterAnnotationsAsAttribute(_cp);
        ExceptionTable et = null;
        if (throws_vec.size() > 0) {
            addAttribute(et = getExceptionTable(_cp));
            // Add `Exceptions' if there are "throws" clauses
        }
        final Method m = new Method(super.getAccessFlags(), name_index, signature_index, getAttributes(), _cp
                .getConstantPool());
        // Undo effects of adding attributes
        if (lvt != null) {
            removeCodeAttribute(lvt);
        }
        if (lvtt != null) {
            removeCodeAttribute(lvtt);
        }
        if (lnt != null) {
            removeCodeAttribute(lnt);
        }
        if (code != null) {
            removeAttribute(code);
        }
        if (et != null) {
            removeAttribute(et);
        }
        return m;
    }

    
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.
/**
     * 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.
     */
    public void removeNOPs() {
        if (il != null) {
            InstructionHandle next;
            /* Check branch instructions.
             */
            for (InstructionHandle ih = il.getStart(); ih != null; ih = next) {
                next = ih.getNext();
                if ((next != null) && (ih.getInstruction() instanceof NOP)) {
                    try {
                        il.delete(ih);
                    } catch (final TargetLostException e) {
                        for (final InstructionHandle target : e.getTargets()) {
                            for (final InstructionTargeter targeter : target.getTargeters()) {
                                targeter.updateTarget(target, next);
                            }
                        }
                    }
                }
            }
        }
    }

    
Set maximum number of local variables.
/**
     * Set maximum number of local variables.
     */
    public void setMaxLocals(final int m) {
        max_locals = m;
    }

    public int getMaxLocals() {
        return max_locals;
    }

    
Set maximum stack size for this method.
/**
     * Set maximum stack size for this method.
     */
    public void setMaxStack(final int m) { // TODO could be package-protected?
        max_stack = m;
    }

    public int getMaxStack() {
        return max_stack;
    }

    
Returns:
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?
        this.class_name = class_name;
    }

    public void setReturnType(final Type return_type) {
        setType(return_type);
    }

    public Type getReturnType() {
        return getType();
    }

    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) {
        arg_types[i] = type;
    }

    public Type getArgumentType(final int i) {
        return arg_types[i];
    }

    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) {
        arg_names[i] = name;
    }

    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?
        this.il = il;
    }

    @Override
    public String getSignature() {
        return Type.getMethodSignature(super.getType(), arg_types);
    }

    
Computes max. stack size by performing control flow analysis.
/**
     * Computes max. stack size by performing control flow analysis.
     */
    public void setMaxStack() { // TODO could be package-protected? (some tests would need repackaging)
        if (il != null) {
            max_stack = getMaxStack(super.getConstantPool(), il, getExceptionHandlers());
        } else {
            max_stack = 0;
        }
    }

    
Compute maximum number of local variables.
/**
     * Compute maximum number of local variables.
     */
    public void setMaxLocals() { // TODO could be package-protected? (some tests would need repackaging)
        if (il != null) {
            int max = isStatic() ? 0 : 1;
            if (arg_types != null) {
                for (final Type arg_type : arg_types) {
                    max += arg_type.getSize();
                }
            }
            for (InstructionHandle ih = il.getStart(); ih != null; ih = ih.getNext()) {
                final Instruction ins = ih.getInstruction();
                if ((ins instanceof LocalVariableInstruction) || (ins instanceof RET)
                        || (ins instanceof IINC)) {
                    final int index = ((IndexedInstruction) ins).getIndex()
                            + ((TypedInstruction) ins).getType(super.getConstantPool()).getSize();
                    if (index > max) {
                        max = index;
                    }
                }
            }
            max_locals = max;
        } else {
            max_locals = 0;
        }
    }

    
Do not/Do produce attributes code attributesLineNumberTable and
LocalVariableTable, like javac -O
/**
     * Do not/Do produce attributes code attributesLineNumberTable and
     * LocalVariableTable, like javac -O
     */
    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) {
            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) {
            final BranchTarget bt = new BranchTarget(target, stackDepth);
            visitedTargets.put(target, bt);
            return bt;
        }

        private boolean visited(final InstructionHandle target) {
            return visitedTargets.get(target) != null;
        }
    }

    
Computes stack usage of an instruction list by performing control flow
analysis.
Returns:
maximum stack depth used by method/**
     * 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,
            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.
         */
        for (final CodeExceptionGen element : et) {
            final InstructionHandle handler_pc = element.getHandlerPC();
            if (handler_pc != null) {
                branchTargets.push(handler_pc, 1);
            }
        }
        int stackDepth = 0;
        int maxStackDepth = 0;
        InstructionHandle ih = il.getStart();
        while (ih != null) {
            final Instruction instruction = ih.getInstruction();
            final short opcode = instruction.getOpcode();
            final int delta = instruction.produceStack(cp) - instruction.consumeStack(cp);
            stackDepth += delta;
            if (stackDepth > maxStackDepth) {
                maxStackDepth = stackDepth;
            }
            // choose the next instruction based on whether current is a branch.
            if (instruction instanceof BranchInstruction) {
                final BranchInstruction branch = (BranchInstruction) instruction;
                if (instruction instanceof Select) {
                    // explore all of the select's targets. the default target is handled below.
                    final Select select = (Select) branch;
                    final InstructionHandle[] targets = select.getTargets();
                    for (final InstructionHandle target : targets) {
                        branchTargets.push(target, stackDepth);
                    }
                    // nothing to fall through to.
                    ih = null;
                } else if (!(branch instanceof IfInstruction)) {
                    // 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);
                    }
                    ih = null;
                }
                // for all branches, the target of the branch is pushed on the branch stack.
                // conditional branches have a fall through case, selects don't, and
                // jsr/jsr_w return to the next instruction.
                branchTargets.push(branch.getTarget(), stackDepth);
            } else {
                // check for instructions that terminate the method.
                if (opcode == Const.ATHROW || opcode == Const.RET
                        || (opcode >= Const.IRETURN && opcode <= Const.RETURN)) {
                    ih = null;
                }
            }
            // normal case, go to the next instruction.
            if (ih != null) {
                ih = ih.getNext();
            }
            // if we have no more instructions, see if there are any deferred branches to explore.
            if (ih == null) {
                final BranchTarget bt = branchTargets.pop();
                if (bt != null) {
                    ih = bt.target;
                    stackDepth = bt.stackDepth;
                }
            }
        }
        return maxStackDepth;
    }

    private List<MethodObserver> observers;

    
Add observer for this object.
/**
     * Add observer for this object.
     */
    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) {
        if (observers != null) {
            observers.remove(o);
        }
    }

    
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.
/**
     * 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.
     */
    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'
Returns:
String representation of the method./**
     * Return string representation close to declaration format, e.g. public
     * 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();
    }

    
Returns:
deep copy of this method/**
     * @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/**
     * 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).
/**
     * 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({"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<>();
                    }
                }
                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({"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) {
            existingAnnotations.add(annotation);
        } else {
            final List<AnnotationEntryGen> l = new ArrayList<>();
            l.add(annotation);
            param_annotations[parameterIndex] = l;
        }
    }

    
Returns:
Comparison strategy object/**
     * @return Comparison strategy object
     */
    public static BCELComparator getComparator() {
        return bcelComparator;
    }

    
Params:
comparator – Comparison strategy object/**
     * @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 Also:
equals.equals(Object)/**
     * 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 Also:
hashCode.hashCode()/**
     * 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);
    }
}