* Copyright (c) 2013, 2017, Oracle and/or its affiliates. All rights reserved.

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;

 * 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

    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.

     *

     * @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.

     *

     * @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.

     *

     * @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.

     *

     * @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);

    }

    /*

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

    }

    /**

     * @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());

    }

    /**

     * @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.

     *

     * @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) {

        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) {