content: /*
   *  This file is part of AndroidIDE.
   *
   *  AndroidIDE is free software: you can redistribute it and/or modify
   *  it under the terms of the GNU General Public License as published by
   *  the Free Software Foundation, either version 3 of the License, or
   *  (at your option) any later version.
   *
   *  AndroidIDE is distributed in the hope that it will be useful,
   *  but WITHOUT ANY WARRANTY; without even the implied warranty of
   *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   *  GNU General Public License for more details.
   *
   *  You should have received a copy of the GNU General Public License
   *   along with AndroidIDE.  If not, see <https://www.gnu.org/licenses/>.
   */
  
  /*
   * reserved comment block
   * DO NOT REMOVE OR ALTER!
   */
  package jaxp.sun.org.apache.bcel.internal.generic;
  
  /* ====================================================================
   * The Apache Software License, Version 1.1
   *
   * Copyright (c) 2001 The Apache Software Foundation.  All rights
   * reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   *
   * 1. Redistributions of source code must retain the above copyright
   *    notice, this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright
   *    notice, this list of conditions and the following disclaimer in
   *    the documentation and/or other materials provided with the
   *    distribution.
   *
   * 3. The end-user documentation included with the redistribution,
   *    if any, must include the following acknowledgment:
   *       "This product includes software developed by the
   *        Apache Software Foundation (http://www.apache.org/)."
   *    Alternately, this acknowledgment may appear in the software itself,
   *    if and wherever such third-party acknowledgments normally appear.
   *
   * 4. The names "Apache" and "Apache Software Foundation" and
   *    "Apache BCEL" must not be used to endorse or promote products
   *    derived from this software without prior written permission. For
   *    written permission, please contact apache@apache.org.
   *
   * 5. Products derived from this software may not be called "Apache",
   *    "Apache BCEL", nor may "Apache" appear in their name, without
   *    prior written permission of the Apache Software Foundation.
   *
   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
   * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
   * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
   * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
   * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   * SUCH DAMAGE.
   * ====================================================================
   *
   * This software consists of voluntary contributions made by many
   * individuals on behalf of the Apache Software Foundation.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   */
  
  import jaxp.sun.org.apache.bcel.internal.Constants;
  import jaxp.sun.org.apache.bcel.internal.classfile.*;
  
  import jaxp.sun.org.apache.bcel.internal.classfile.Attribute;
  import jaxp.sun.org.apache.bcel.internal.classfile.Code;
  import jaxp.sun.org.apache.bcel.internal.classfile.CodeException;
  import jaxp.sun.org.apache.bcel.internal.classfile.ExceptionTable;
  import jaxp.sun.org.apache.bcel.internal.classfile.LineNumber;
  import jaxp.sun.org.apache.bcel.internal.classfile.LineNumberTable;
  import jaxp.sun.org.apache.bcel.internal.classfile.LocalVariable;
  import jaxp.sun.org.apache.bcel.internal.classfile.LocalVariableTable;
  import jaxp.sun.org.apache.bcel.internal.classfile.LocalVariableTypeTable;
  import jaxp.sun.org.apache.bcel.internal.classfile.Method;
  import jaxp.sun.org.apache.bcel.internal.classfile.Utility;
  
  import java.util.*;
  
  /**
   * 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.
   *
   * @author  <A HREF="mailto:markus.dahm@berlin.de">M. Dahm</A>
   * @author  <A HREF="http://www.vmeng.com/beard">Patrick C. Beard</A> [setMaxStack()]
   * @see     InstructionList
   * @see     Method
   */
  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 ArrayList       variable_vec    = new ArrayList();
    private ArrayList       line_number_vec = new ArrayList();
    private ArrayList       exception_vec   = new ArrayList();
    private ArrayList       throws_vec      = new ArrayList();
    private ArrayList       code_attrs_vec  = new ArrayList();
  
    /**
     * 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(int access_flags, Type return_type, Type[] arg_types,
                     String[] arg_names, String method_name, String class_name,
                     InstructionList il, ConstantPoolGen cp) {
      setAccessFlags(access_flags);
      setType(return_type);
      setArgumentTypes(arg_types);
      setArgumentNames(arg_names);
      setName(method_name);
      setClassName(class_name);
      setInstructionList(il);
      setConstantPool(cp);
  
      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", new ObjectType(class_name), start, end);
        }
      }
  
      if(arg_types != null) {
        int size = arg_types.length;
  
        for(int i=0; i < size; i++) {
          if(Type.VOID == arg_types[i]) {
            throw new ClassGenException("'void' is an illegal argument type for a method");
          }
        }
  
        if(arg_names != null) { // Names for variables provided?
          if(size != arg_names.length)
            throw new ClassGenException("Mismatch in argument array lengths: " +
                                        size + " vs. " + arg_names.length);
        } else { // Give them dummy names
          arg_names = new String[size];
  
          for(int i=0; i < size; i++)
            arg_names[i] = "arg" + i;
  
          setArgumentNames(arg_names);
        }
  
        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(Method m, String class_name, ConstantPoolGen cp) {
      this(m.getAccessFlags(), Type.getReturnType(m.getSignature()),
           Type.getArgumentTypes(m.getSignature()), null /* may be overridden anyway */,
           m.getName(), class_name,
           ((m.getAccessFlags() & (Constants.ACC_ABSTRACT | Constants.ACC_NATIVE)) == 0)?
           new InstructionList(m.getCode().getCode()) : null,
           cp);
  
      Attribute[] attributes = m.getAttributes();
      for(int i=0; i < attributes.length; i++) {
        Attribute a = attributes[i];
  
        if(a instanceof Code) {
          Code c = (Code)a;
          setMaxStack(c.getMaxStack());
          setMaxLocals(c.getMaxLocals());
  
          CodeException[] ces = c.getExceptionTable();
  
          if(ces != null) {
            for(int j=0; j < ces.length; j++) {
              CodeException ce     = ces[j];
              int           type   = ce.getCatchType();
              ObjectType    c_type = null;
  
              if(type > 0) {
                String cen = m.getConstantPool().getConstantString(type, Constants.CONSTANT_Class);
                c_type = new ObjectType(cen);
              }
  
              int end_pc = ce.getEndPC();
              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);
            }
          }
  
          Attribute[] c_attributes = c.getAttributes();
          for(int j=0; j < c_attributes.length; j++) {
            a = c_attributes[j];
  
            if(a instanceof LineNumberTable) {
              LineNumber[] ln = ((LineNumberTable)a).getLineNumberTable();
  
              for(int k=0; k < ln.length; k++) {
                LineNumber l = ln[k];
                addLineNumber(il.findHandle(l.getStartPC()), l.getLineNumber());
              }
            } else if(a instanceof LocalVariableTable) {
              LocalVariable[] lv = ((LocalVariableTable)a).getLocalVariableTable();
  
              removeLocalVariables();
  
              for(int k=0; k < lv.length; k++) {
                LocalVariable     l     = lv[k];
                InstructionHandle start = il.findHandle(l.getStartPC());
                InstructionHandle end   = il.findHandle(l.getStartPC() + l.getLength());
  
                // Repair malformed handles
                if(null == start) {
                  start = il.getStart();
                }
  
                if(null == end) {
                  end = il.getEnd();
                }
  
                addLocalVariable(l.getName(), Type.getType(l.getSignature()),
                                 l.getIndex(), start, end);
              }
            } else if (a instanceof LocalVariableTypeTable) {
               LocalVariable[] lv = ((LocalVariableTypeTable) a).getLocalVariableTypeTable();
               removeLocalVariables();
               for (int k = 0; k < lv.length; k++) {
                   LocalVariable l = lv[k];
                   InstructionHandle start = il.findHandle(l.getStartPC());
                   InstructionHandle end = il.findHandle(l.getStartPC() + l.getLength());
                   // Repair malformed handles
                   if (null == start) {
                       start = il.getStart();
                   }
                   if (null == end) {
                       end = il.getEnd();
                   }
                   addLocalVariable(l.getName(), Type.getType(l.getSignature()), l
                           .getIndex(), start, end);
                }
            } else
              addCodeAttribute(a);
          }
        } else if(a instanceof ExceptionTable) {
          String[] names = ((ExceptionTable)a).getExceptionNames();
          for(int j=0; j < names.length; j++)
            addException(names[j]);
        } else
          addAttribute(a);
      }
    }
  
    /**
     * 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(String name, Type type, int slot,
                                             InstructionHandle start,
                                             InstructionHandle end) {
      byte t = type.getType();
  
      if(t != Constants.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 = variable_vec.indexOf(l)) >= 0) // Overwrite if necessary
          variable_vec.set(i, l);
        else
          variable_vec.add(l);
  
        return l;
      } else {
        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(String name, Type type,
                                             InstructionHandle start,
                                             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(LocalVariableGen l) {
      variable_vec.remove(l);
    }
  
    /**
     * Remove all local variables.
     */
    public void removeLocalVariables() {
      variable_vec.clear();
    }
  
    /**
     * Sort local variables by index
     */
    private static final void sort(LocalVariableGen[] vars, int l, int r) {
      int i = l, j = r;
      int m = vars[(l + r) / 2].getIndex();
      LocalVariableGen h;
  
      do {
        while(vars[i].getIndex() < m) i++;
        while(m < vars[j].getIndex()) j--;
  
        if(i <= j) {
          h=vars[i]; vars[i]=vars[j]; vars[j]=h; // Swap elements
          i++; j--;
        }
      } while(i <= j);
  
      if(l < j) sort(vars, l, j);
      if(i < r) sort(vars, i, r);
    }
  
    /*
     * 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() {
      int                size = variable_vec.size();
      LocalVariableGen[] lg   = new LocalVariableGen[size];
      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)
        sort(lg, 0, size - 1);
  
      return lg;
    }
  
    /**
     * @return `LocalVariableTable' attribute of all the local variables of this method.
     */
    public LocalVariableTable getLocalVariableTable(ConstantPoolGen cp) {
      LocalVariableGen[] lg   = getLocalVariables();
      int                size = lg.length;
      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());
    }
  
    /**
     * 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(InstructionHandle ih, int src_line) {
      LineNumberGen l = new LineNumberGen(ih, src_line);
      line_number_vec.add(l);
      return l;
    }
  
    /**
     * Remove a line number.
     */
    public void removeLineNumber(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() {
      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.
     */
    public LineNumberTable getLineNumberTable(ConstantPoolGen cp) {
      int          size = line_number_vec.size();
      LineNumber[] ln   = new LineNumber[size];
  
      try {
        for(int i=0; i < size; i++)
          ln[i] = ((LineNumberGen)line_number_vec.get(i)).getLineNumber();
      } catch(ArrayIndexOutOfBoundsException e) {} // Never occurs
  
      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.
     *
     * @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(InstructionHandle start_pc,
                                                InstructionHandle end_pc,
                                                InstructionHandle handler_pc,
                                                ObjectType catch_type) {
      if((start_pc == null) || (end_pc == null) || (handler_pc == null))
        throw new ClassGenException("Exception handler target is null instruction");
  
      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(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() {
      CodeExceptionGen[] cg   = new CodeExceptionGen[exception_vec.size()];
      exception_vec.toArray(cg);
      return cg;
    }
  
    /**
     * @return code exceptions for `Code' attribute
     */
    private CodeException[] getCodeExceptions() {
      int             size  = exception_vec.size();
      CodeException[] c_exc = new CodeException[size];
  
      try {
        for(int i=0; i < size; i++) {
          CodeExceptionGen c = (CodeExceptionGen)exception_vec.get(i);
          c_exc[i] = c.getCodeException(cp);
        }
      } catch(ArrayIndexOutOfBoundsException e) {}
  
      return c_exc;
    }
  
    /**
     * Add an exception possibly thrown by this method.
     *
     * @param class_name (fully qualified) name of exception
     */
    public void addException(String class_name) {
      throws_vec.add(class_name);
    }
  
    /**
     * Remove an exception.
     */
    public void removeException(String c) {
      throws_vec.remove(c);
    }
  
    /**
     * Remove all exceptions.
     */
    public void removeExceptions() {
      throws_vec.clear();
    }
  
    /*
     * @return array of thrown exceptions
     */
    public String[] getExceptions() {
      String[] e = new String[throws_vec.size()];
      throws_vec.toArray(e);
      return e;
    }
  
    /**
     * @return `Exceptions' attribute of all the exceptions thrown by this method.
     */
    private ExceptionTable getExceptionTable(ConstantPoolGen cp) {
      int   size = throws_vec.size();
      int[] ex   = new int[size];
  
      try {
        for(int i=0; i < size; i++)
          ex[i] = cp.addClass((String)throws_vec.get(i));
      } catch(ArrayIndexOutOfBoundsException e) {}
  
      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.
     *
     * @param a attribute to be added
     */
    public void addCodeAttribute(Attribute a) { code_attrs_vec.add(a); }
  
    /**
     * Remove a code attribute.
     */
    public void removeCodeAttribute(Attribute a) { code_attrs_vec.remove(a); }
  
    /**
     * Remove all code attributes.
     */
    public void removeCodeAttributes() {
      code_attrs_vec.clear();
    }
  
    /**
     * @return all attributes of this method.
     */
    public Attribute[] getCodeAttributes() {
      Attribute[] attributes = new Attribute[code_attrs_vec.size()];
      code_attrs_vec.toArray(attributes);
      return attributes;
    }
  
    /**
     * 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() {
      String signature       = getSignature();
      int    name_index      = cp.addUtf8(name);
      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;
  
      /* Create LocalVariableTable and LineNumberTable attributes (for debuggers, e.g.)
       */
      if((variable_vec.size() > 0) && !strip_attributes)
        addCodeAttribute(lvt = getLocalVariableTable(cp));
  
      if((line_number_vec.size() > 0) && !strip_attributes)
        addCodeAttribute(lnt = getLineNumberTable(cp));
  
      Attribute[] code_attrs = getCodeAttributes();
  
      /* Each attribute causes 6 additional header bytes
       */
      int                attrs_len  = 0;
      for(int i=0; i < code_attrs.length; i++)
        attrs_len += (code_attrs[i].getLength() + 6);
  
      CodeException[] c_exc   = getCodeExceptions();
      int             exc_len = c_exc.length * 8; // Every entry takes 8 bytes
  
      Code code = null;
  
      if((il != null) && !isAbstract()) {
        // Remove any stale code attribute
        Attribute[] attributes = getAttributes();
        for(int i=0; i < attributes.length; i++) {
          Attribute a = attributes[i];
  
          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);
      }
  
      ExceptionTable et = null;
  
      if(throws_vec.size() > 0)
        addAttribute(et = getExceptionTable(cp)); // Add `Exceptions' if there are "throws" clauses
  
      Method m = new Method(access_flags, name_index, signature_index,
                            getAttributes(), cp.getConstantPool());
  
      // Undo effects of adding attributes
      if(lvt != null)  removeCodeAttribute(lvt);
      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 refering 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.next;
  
          if((next != null) && (ih.getInstruction() instanceof NOP)) {
            try {
              il.delete(ih);
            } catch(TargetLostException e) {
              InstructionHandle[] targets = e.getTargets();
  
              for(int i=0; i < targets.length; i++) {
                InstructionTargeter[] targeters = targets[i].getTargeters();
  
                for(int j=0; j < targeters.length; j++)
                  targeters[j].updateTarget(targets[i], next);
              }
            }
          }
        }
      }
    }
  
    /**
     * Set maximum number of local variables.
     */
    public void   setMaxLocals(int m)  { max_locals = m; }
    public int    getMaxLocals()       { return max_locals; }
  
    /**
     * Set maximum stack size for this method.
     */
    public void   setMaxStack(int m)  { max_stack = m; }
    public int    getMaxStack()       { return max_stack; }
  
    /** @return class that contains this method
     */
    public String getClassName()                     { return class_name; }
    public void   setClassName(String class_name)    { this.class_name = class_name; }
  
    public void   setReturnType(Type return_type)    { setType(return_type); }
    public Type   getReturnType()                    { return getType(); }
  
    public void   setArgumentTypes(Type[] arg_types)  { this.arg_types = arg_types; }
    public Type[] getArgumentTypes()                  { return (Type[])arg_types.clone(); }
    public void   setArgumentType(int i, Type type)       { arg_types[i] = type; }
    public Type   getArgumentType(int i)                  { return arg_types[i]; }
  
    public void     setArgumentNames(String[] arg_names) { this.arg_names = arg_names; }
    public String[] getArgumentNames()                   { return (String[])arg_names.clone(); }
    public void     setArgumentName(int i, String name)     { arg_names[i] = name; }
    public String   getArgumentName(int i)                  { return arg_names[i]; }
  
    public InstructionList getInstructionList()                    { return il; }
    public void            setInstructionList(InstructionList il)  { this.il = il; }
  
    public String getSignature() {
      return Type.getMethodSignature(type, arg_types);
    }
  
    /**
     * Computes max. stack size by performing control flow analysis.
     */
    public void setMaxStack() {
      if(il != null)
        max_stack = getMaxStack(cp, il, getExceptionHandlers());
      else
        max_stack = 0;
    }
  
    /**
     * Compute maximum number of local variables.
     */
    public void setMaxLocals() {
      if(il != null) {
        int max = isStatic()? 0 : 1;
  
        if(arg_types != null)
          for(int i=0; i < arg_types.length; i++)
            max += arg_types[i].getSize();
  
        for(InstructionHandle ih = il.getStart(); ih != null; ih = ih.getNext()) {
          Instruction ins = ih.getInstruction();
  
          if((ins instanceof LocalVariableInstruction) ||
             (ins instanceof RET) || (ins instanceof IINC))
          {
            int index = ((IndexedInstruction)ins).getIndex() +
              ((TypedInstruction)ins).getType(cp).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
     */
    public void stripAttributes(boolean flag) { strip_attributes = flag; }
  
    static final class BranchTarget {
      InstructionHandle target;
      int               stackDepth;
  
      BranchTarget(InstructionHandle target, int stackDepth) {
        this.target = target;
        this.stackDepth = stackDepth;
      }
    }
  
    static final class BranchStack {
      Stack     branchTargets  = new Stack();
      Hashtable visitedTargets = new Hashtable();
  
      public void push(InstructionHandle target, int stackDepth) {
        if(visited(target))
          return;
  
        branchTargets.push(visit(target, stackDepth));
      }
  
      public BranchTarget pop() {
        if(!branchTargets.empty()) {
          BranchTarget bt = (BranchTarget) branchTargets.pop();
          return bt;
        }
  
        return null;
      }
  
      private final BranchTarget visit(InstructionHandle target, int stackDepth) {
        BranchTarget bt = new BranchTarget(target, stackDepth);
        visitedTargets.put(target, bt);
  
        return bt;
      }
  
      private final boolean visited(InstructionHandle target) {
        return (visitedTargets.get(target) != null);
      }
    }
  
    /**
     * Computes stack usage of an instruction list by performing control flow analysis.
     *
     * @return maximum stack depth used by method
     */
    public static int getMaxStack(ConstantPoolGen cp, InstructionList il, CodeExceptionGen[] et) {
      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 (int i = 0; i < et.length; i++) {
        InstructionHandle handler_pc = et[i].getHandlerPC();
        if (handler_pc != null)
          branchTargets.push(handler_pc, 1);
      }
  
      int               stackDepth = 0, maxStackDepth = 0;
      InstructionHandle ih         = il.getStart();
  
      while(ih != null) {
        Instruction instruction = ih.getInstruction();
        short opcode = instruction.getOpcode();
        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) {
          BranchInstruction branch = (BranchInstruction) instruction;
          if(instruction instanceof Select) {
            // explore all of the select's targets. the default target is handled below.
            Select select = (Select) branch;
            InstructionHandle[] targets = select.getTargets();
            for (int i = 0; i < targets.length; i++)
              branchTargets.push(targets[i], 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 == Constants.JSR || opcode == Constants.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 == Constants.ATHROW || opcode == Constants.RET ||
             (opcode >= Constants.IRETURN && opcode <= Constants.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) {
          BranchTarget bt = branchTargets.pop();
          if (bt != null) {
            ih = bt.target;
            stackDepth = bt.stackDepth;
          }
        }
      }
  
      return maxStackDepth;
    }
  
    private ArrayList observers;
  
    /** Add observer for this object.
     */
    public void addObserver(MethodObserver o) {
      if(observers == null)
        observers = new ArrayList();
  
      observers.add(o);
    }
  
    /** Remove observer for this object.
     */
    public void removeObserver(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.
     */
    public void update() {
      if(observers != null)
        for(Iterator e = observers.iterator(); e.hasNext(); )
          ((MethodObserver)e.next()).notify(this);
    }
  
    /**
     * Return string representation close to declaration format,
     * `public static void _main(String[]) throws IOException', e.g.
     *
     * @return String representation of the method.
     */
    public final String toString() {
      String access    = Utility.accessToString(access_flags);
      String signature = Type.getMethodSignature(type, arg_types);
  
      signature = Utility.methodSignatureToString(signature, name, access,
                                                  true, getLocalVariableTable(cp));
  
      StringBuffer buf = new StringBuffer(signature);
  
      if(throws_vec.size() > 0) {
        for(Iterator e = throws_vec.iterator(); e.hasNext(); )
          buf.append("\n\t\tthrows " + e.next());
      }
  
      return buf.toString();
    }
  
    /** @return deep copy of this method
     */
    public MethodGen copy(String class_name, ConstantPoolGen cp) {
      Method    m  = ((MethodGen)clone()).getMethod();
      MethodGen mg = new MethodGen(m, class_name, this.cp);
  
      if(this.cp != cp) {
        mg.setConstantPool(cp);
        mg.getInstructionList().replaceConstantPool(this.cp, cp);
      }
  
      return mg;
    }
  }
  