path: root/bcel-builder/src/org/aspectj/apache/bcel/generic/MethodGen.java

package org.aspectj.apache.bcel.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 java.util.ArrayList;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Stack;

import org.aspectj.apache.bcel.Constants;
import org.aspectj.apache.bcel.classfile.Attribute;
import org.aspectj.apache.bcel.classfile.Code;
import org.aspectj.apache.bcel.classfile.CodeException;
import org.aspectj.apache.bcel.classfile.ExceptionTable;
import org.aspectj.apache.bcel.classfile.LineNumber;
import org.aspectj.apache.bcel.classfile.LineNumberTable;
import org.aspectj.apache.bcel.classfile.LocalVariable;
import org.aspectj.apache.bcel.classfile.LocalVariableTable;
import org.aspectj.apache.bcel.classfile.Method;
import org.aspectj.apache.bcel.classfile.Utility;
import org.aspectj.apache.bcel.classfile.annotation.Annotation;
import org.aspectj.apache.bcel.classfile.annotation.RuntimeAnnotations;
import org.aspectj.apache.bcel.classfile.annotation.RuntimeParameterAnnotations;
import org.aspectj.apache.bcel.generic.annotation.AnnotationGen;

/** 
 * 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,v 1.7 2006/02/21 10:49:15 aclement Exp $
 * @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 int highestLineNumber = 0;

  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();
  private List[] param_annotations; // Array of lists containing AnnotationGen objects
  private boolean hasParameterAnnotations = false;
  private boolean haveUnpackedParameterAnnotations = false;

  /**
   * 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);
	}
      }
    }
  }
  
  public int getHighestlinenumber() { return highestLineNumber; }

  /**
   * 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,class_name,cp,false);
  }
  
  public MethodGen(Method m, String class_name, ConstantPoolGen cp,boolean useTags) {
	  
    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();
	
    	  InstructionHandle[] arrayOfInstructions = il.getInstructionsAsArray();
	
    	  // process the exception table
    	  // - 
    	  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, arrayOfInstructions);// il.findHandle(end_pc);
					end = end.getPrev(); // Make it inclusive
				}

				addExceptionHandler(
						il.findHandle(ce.getStartPC(),arrayOfInstructions),
						end, 
						il.findHandle(ce.getHandlerPC(),arrayOfInstructions),
						c_type);
			}
		}

			Attribute[] codeAttrs = c.getAttributes();
			for (int j = 0; j < codeAttrs.length; j++) {
				a = codeAttrs[j];

				if (a instanceof LineNumberTable) {
					LineNumber[] ln = ((LineNumberTable) a).getLineNumberTable();
					if (useTags) {
						// abracadabra, lets create tags rather than linenumbergens.
						for (int k = 0; k < ln.length; k++) {
							LineNumber l = ln[k];
							int lnum = l.getLineNumber();
							if (lnum>highestLineNumber) highestLineNumber=lnum;
							LineNumberTag lt = new LineNumberTag(lnum);
							il.findHandle(l.getStartPC(),arrayOfInstructions).addTargeter(lt);
						}
					} else {
						for (int k = 0; k < ln.length; k++) {
							LineNumber l = ln[k];
							addLineNumber(il.findHandle(l.getStartPC(),arrayOfInstructions),
									l.getLineNumber());
						}
					}
				} else if (a instanceof LocalVariableTable) {
					
					// Lets have a go at creating Tags directly
					if (useTags) {
						LocalVariable[] lv = ((LocalVariableTable) a).getLocalVariableTable();
						
						for (int k = 0; k < lv.length; k++) {
							LocalVariable l = lv[k];
							Type t = Type.getType(l.getSignature());
							LocalVariableTag lvt = new LocalVariableTag(t,l.getSignature(),l.getName(),l.getIndex(),l.getStartPC());
							InstructionHandle start = il.findHandle(l.getStartPC(), arrayOfInstructions);
							byte b = t.getType();
							if (b!= Constants.T_ADDRESS) {
								int increment = t.getSize();
								if (l.getIndex()+increment>max_locals) max_locals = l.getIndex()+increment;
							}
							int end = l.getStartPC()+l.getLength();
							do {
								start.addTargeter(lvt);
								start = start.getNext();
							} while (start!=null && start.getPosition()<end);
						}
					} else {
					
						LocalVariable[] lv = ((LocalVariableTable) a).getLocalVariableTable();

						removeLocalVariables();
	
						for (int k = 0; k < lv.length; k++) {
							LocalVariable l = lv[k];
							InstructionHandle start = il.findHandle(l.getStartPC(), arrayOfInstructions);
							InstructionHandle end   = il.findHandle(l.getStartPC() + l.getLength(), arrayOfInstructions);
							// AMC, this actually gives us the first instruction AFTER the range,
							// so move back one... (findHandle can't cope with mid-instruction indices)
							if (end != null) end = end.getPrev();
							// 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 if (a instanceof RuntimeAnnotations) {
			RuntimeAnnotations runtimeAnnotations = (RuntimeAnnotations) a;
			List l = runtimeAnnotations.getAnnotations();
			for (Iterator it = l.iterator(); it.hasNext();) {
				Annotation element = (Annotation) it.next();
				addAnnotation(new AnnotationGen(element, cp, false));
			}
		} 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) variable_vec.set(i, l); // Overwrite if necessary
      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); }

  public void addAnnotationsAsAttribute(ConstantPoolGen cp) {
  	Attribute[] attrs = Utility.getAnnotationAttributes(cp,annotation_vec);
  	if (attrs!=null) {
      for (int i = 0; i < attrs.length; i++) {
		  addAttribute(attrs[i]);
	  }
  	}
  }
  
  public void addParameterAnnotationsAsAttribute(ConstantPoolGen cp) {
  	if (!hasParameterAnnotations) return;
  	Attribute[] attrs = Utility.getParameterAnnotationAttributes(cp,param_annotations);
  	if (attrs!=null) {
      for (int i = 0; i < attrs.length; i++) {
		  addAttribute(attrs[i]);
	  }
  	}
  }
  
  /**
   * 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;
    //J5TODO: LocalVariableTypeTable support!

    /* 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);
    }

    
    addAnnotationsAsAttribute(cp);
    addParameterAnnotationsAsAttribute(cp);
    
    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);
//J5TODO: Remove the annotation attributes that may have been added
    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()                   { 
  	if (arg_names!=null) return (String[])arg_names.clone(); 
  	else                 return new String[0];
  }
  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;
  }
  
  //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
   */
  public List getAnnotationsOnParameter(int i) {
  	ensureExistingParameterAnnotationsUnpacked();
  	if (!hasParameterAnnotations || i>arg_types.length) return null;
  	return param_annotations[i];
  }
  
  /** 
   * Goes through the attributes on the method and identifies any that are RuntimeParameterAnnotations, 
   * extracting their contents and storing them as parameter annotations.  There are two kinds of
   * parameter annotation - visible and invisible.  Once they have been unpacked, these attributes are
   * deleted.  (The annotations will be rebuilt as attributes when someone builds a Method object out
   * of this MethodGen object).
   */
  private void ensureExistingParameterAnnotationsUnpacked() { 
  	if (haveUnpackedParameterAnnotations) return;
  	// Find attributes that contain parameter annotation data
  	Attribute[] attrs = getAttributes();
  	RuntimeParameterAnnotations paramAnnVisAttr = null;
  	RuntimeParameterAnnotations paramAnnInvisAttr=null;
  	List accumulatedAnnotations = new ArrayList();
  	for (int i = 0; i < attrs.length; i++) {
		Attribute attribute = attrs[i];
		if (attribute instanceof RuntimeParameterAnnotations) {	
			
			// Initialize param_annotations
			if (!hasParameterAnnotations) {
				param_annotations = new List[arg_types.length];
				for (int j=0;j<arg_types.length;j++) param_annotations[j]=new ArrayList();
			}
			
			hasParameterAnnotations = true;
			RuntimeParameterAnnotations rpa = (RuntimeParameterAnnotations)attribute;
			if (rpa.areVisible()) paramAnnVisAttr = rpa;
			else                  paramAnnInvisAttr=rpa;
			for (int j=0; j<arg_types.length; j++) {
			  // This returns Annotation[] ...
			  Annotation[] immutableArray = rpa.getAnnotationsOnParameter(j);
			  // ... which needs transforming into an AnnotationGen[] ...
			  List mutable = makeMutableVersion(immutableArray);
			  // ... 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 /*AnnotationGen*/ makeMutableVersion(Annotation[] mutableArray) {
  	List result = new ArrayList();
  	for (int i = 0; i < mutableArray.length; i++) {
		result.add(new AnnotationGen(mutableArray[i],getConstantPool(),false));
	}
  	return result;
  }

  public void addParameterAnnotation(int parameterIndex, AnnotationGen annotation) {
  	ensureExistingParameterAnnotationsUnpacked();
  	if (!hasParameterAnnotations) {
  		param_annotations = new List[arg_types.length];
  		hasParameterAnnotations = true;
  	}
  	List existingAnnotations = param_annotations[parameterIndex];
  	if (existingAnnotations != null) {
  		existingAnnotations.add(annotation);
  	} else {
  		List l = new ArrayList();
  		l.add(annotation);
  		param_annotations[parameterIndex] = l;
  	}
  }          
}