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.ConstantPool;
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.AnnotationGen;
import org.aspectj.apache.bcel.classfile.annotation.RuntimeAnnos;
import org.aspectj.apache.bcel.classfile.annotation.RuntimeParamAnnos;

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:
M. Dahm, Patrick C. Beard [setMaxStack()]
See Also:
InstructionList
Method
Version:
$Id: MethodGen.java,v 1.17 2011/05/19 23:23:46 aclement Exp $/**
 * 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.17 2011/05/19 23:23:46 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 classname;
	private Type[] parameterTypes;
	private String[] parameterNames;
	private int maxLocals;
	private int maxStack;
	private InstructionList il;

	// Indicates whether to produce code attributes for LineNumberTable and LocalVariableTable, like javac -O
	private boolean stripAttributes;

	private int highestLineNumber = 0;

	private ArrayList<LocalVariableGen> localVariablesList = new ArrayList<LocalVariableGen>();
	private ArrayList<LineNumberGen> lineNumbersList = new ArrayList<LineNumberGen>();
	private ArrayList<CodeExceptionGen> exceptionsList = new ArrayList<CodeExceptionGen>();
	private ArrayList<String> exceptionsThrown = new ArrayList<String>();
	private ArrayList<Attribute> codeAttributesList = new ArrayList<Attribute>();
	private List<AnnotationGen>[] 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.
Params:
access_flags – access qualifiers
return_type – method type
arg_types – argument types
arg_names – argument names (if this is null, default names will be provided for them)
method_name – name of method
class_name – class name containing this method (may be null, if you don't care)
il – instruction list associated with this method, may be null only for abstract or native methods
cp – constant pool/**
	 * Declare method. If the method is non-static the constructor automatically declares a local variable `$this' in slot 0. The
	 * actual code is contained in the `il' parameter, which may further manipulated by the user. But he must take care not to
	 * remove any instruction (handles) that are still referenced from this object.
	 * 
	 * For example one may not add a local variable and later remove the instructions it refers to without causing havoc. It is safe
	 * however if you remove that local variable, too.
	 * 
	 * @param access_flags access qualifiers
	 * @param return_type method type
	 * @param arg_types argument types
	 * @param arg_names argument names (if this is null, default names will be provided for them)
	 * @param method_name name of method
	 * @param class_name class name containing this method (may be null, if you don't care)
	 * @param il instruction list associated with this method, may be null only for abstract or native methods
	 * @param cp constant pool
	 */
	public MethodGen(int access_flags, Type return_type, Type[] arg_types, String[] arg_names, String method_name,
			String class_name, InstructionList il, ConstantPool cp) {

		this.modifiers = access_flags;
		this.type = return_type;
		this.parameterTypes = arg_types;
		this.parameterNames = arg_names;
		this.name = method_name;
		this.classname = class_name;
		this.il = il;
		this.cp = cp;

		// OPTIMIZE this code messes with the local variables - do we need it?
		// 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.
Params:
m – method
class_name – class name containing this method
cp – constant pool/**
	 * Instantiate from existing method.
	 * 
	 * @param m method
	 * @param class_name class name containing this method
	 * @param cp constant pool
	 */

	public MethodGen(Method m, String class_name, ConstantPool cp) {
		this(m, class_name, cp, false);
	}

	// OPTIMIZE should always use tags and never anything else!
	public MethodGen(Method m, String class_name, ConstantPool cp, boolean useTags) {
		this(m.getModifiers(),
		// OPTIMIZE implementation of getReturnType() and getArgumentTypes() on Method seems weak
				m.getReturnType(), m.getArgumentTypes(), null /* may be overridden anyway */, m.getName(), class_name, ((m
						.getModifiers() & (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 code = (Code) a;
				setMaxStack(code.getMaxStack());
				setMaxLocals(code.getMaxLocals());

				CodeException[] ces = code.getExceptionTable();

				InstructionHandle[] arrayOfInstructions = il.getInstructionsAsArray();

				// process the exception table
				// -
				if (ces != null) {
					for (CodeException ce : ces) {
						int type = ce.getCatchType();
						ObjectType catchType = null;

						if (type > 0) {
							String cen = m.getConstantPool().getConstantString_CONSTANTClass(type);
							catchType = 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), catchType);
					}
				}

				Attribute[] codeAttrs = code.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, true).addTargeter(lt);
							}
						} else {
							for (int k = 0; k < ln.length; k++) {
								LineNumber l = ln[k];
								addLineNumber(il.findHandle(l.getStartPC(), arrayOfInstructions, true), 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, true);
								byte b = t.getType();
								if (b != Constants.T_ADDRESS) {
									int increment = t.getSize();
									if (l.getIndex() + increment > maxLocals) {
										maxLocals = 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 RuntimeAnnos) {
				RuntimeAnnos runtimeAnnotations = (RuntimeAnnos) a;
				List<AnnotationGen> l = runtimeAnnotations.getAnnotations();
				annotationList.addAll(l);
				// for (Iterator<AnnotationGen> it = l.iterator(); it.hasNext();) {
				// AnnotationGen element = it.next();
				// addAnnotation(new AnnotationGen(element, cp, false));
				// }
			} else {
				addAttribute(a);
			}
		}
	}

	public LocalVariableGen addLocalVariable(String name, Type type, int slot, InstructionHandle start, InstructionHandle end) {
		int size = type.getSize();
		if (slot + size > maxLocals) {
			maxLocals = slot + size;
		}
		LocalVariableGen l = new LocalVariableGen(slot, name, type, start, end);
		int i = localVariablesList.indexOf(l);
		if (i >= 0) {
			localVariablesList.set(i, l); // Overwrite if necessary
		} else {
			localVariablesList.add(l);
		}
		return l;
	}

	
Adds a local variable to this method and assigns an index automatically.
Params:
name – variable name
type – variable type
start – from where the variable is valid, if this is null, it is valid from the start
end – until where the variable is valid, if this is null, it is valid to the end
See Also:
LocalVariable
Returns:
new local variable object/**
	 * Adds a local variable to this method and assigns an index automatically.
	 * 
	 * @param name variable name
	 * @param type variable type
	 * @param start from where the variable is valid, if this is null, it is valid from the start
	 * @param end until where the variable is valid, if this is null, it is valid to the end
	 * @return new local variable object
	 * @see LocalVariable
	 */
	public LocalVariableGen addLocalVariable(String name, Type type, InstructionHandle start, InstructionHandle end) {
		return addLocalVariable(name, type, maxLocals, start, end);
	}

	
Remove a local variable, its slot will not be reused, if you do not use addLocalVariable with an explicit index argument.
/**
	 * Remove a local variable, its slot will not be reused, if you do not use addLocalVariable with an explicit index argument.
	 */
	public void removeLocalVariable(LocalVariableGen l) {
		localVariablesList.remove(l);
	}

	
Remove all local variables.
/**
	 * Remove all local variables.
	 */
	public void removeLocalVariables() {
		localVariablesList.clear();
	}

	
Sort local variables by index
/**
	 * 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 = localVariablesList.size();
		LocalVariableGen[] lg = new LocalVariableGen[size];
		localVariablesList.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;
	}

	
Returns:
`LocalVariableTable' attribute of all the local variables of this method./**
	 * @return `LocalVariableTable' attribute of all the local variables of this method.
	 */
	public LocalVariableTable getLocalVariableTable(ConstantPool 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);
	}

	
Give an instruction a line number corresponding to the source code line.
Params:
ih – instruction to tag
See Also:
LineNumber
Returns:
new line number object/**
	 * Give an instruction a line number corresponding to the source code line.
	 * 
	 * @param ih instruction to tag
	 * @return new line number object
	 * @see LineNumber
	 */
	public LineNumberGen addLineNumber(InstructionHandle ih, int src_line) {
		LineNumberGen l = new LineNumberGen(ih, src_line);
		lineNumbersList.add(l);
		return l;
	}

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

	
Remove all line numbers.
/**
	 * Remove all line numbers.
	 */
	public void removeLineNumbers() {
		lineNumbersList.clear();
	}

	/*
	 * @return array of line numbers
	 */
	public LineNumberGen[] getLineNumbers() {
		LineNumberGen[] lg = new LineNumberGen[lineNumbersList.size()];
		lineNumbersList.toArray(lg);
		return lg;
	}

	
Returns:
'LineNumberTable' attribute for all the local variables of this method./**
	 * @return 'LineNumberTable' attribute for all the local variables of this method.
	 */
	public LineNumberTable getLineNumberTable(ConstantPool cp) {
		int size = lineNumbersList.size();
		LineNumber[] ln = new LineNumber[size];

		for (int i = 0; i < size; i++) {
			ln[i] = lineNumbersList.get(i).getLineNumber();
		}

		return new LineNumberTable(cp.addUtf8("LineNumberTable"), 2 + ln.length * 4, ln, cp);
	}

	
Add an exception handler, i.e., specify region where a handler is active and an instruction where the actual handling is
done.
Params:
start_pc – Start of region (inclusive)
end_pc – End of region (inclusive)
handler_pc – Where handling is done
catch_type – class type of handled exception or null if any exception is handled
Returns:
new exception handler object/**
	 * Add an exception handler, i.e., specify region where a handler is active and an instruction where the actual handling is
	 * done.
	 * 
	 * @param start_pc Start of region (inclusive)
	 * @param end_pc End of region (inclusive)
	 * @param handler_pc Where handling is done
	 * @param catch_type class type of handled exception or null if any exception is handled
	 * @return new exception handler object
	 */
	public CodeExceptionGen addExceptionHandler(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);
		exceptionsList.add(c);
		return c;
	}

	
Remove an exception handler.
/**
	 * Remove an exception handler.
	 */
	public void removeExceptionHandler(CodeExceptionGen c) {
		exceptionsList.remove(c);
	}

	
Remove all line numbers.
/**
	 * Remove all line numbers.
	 */
	public void removeExceptionHandlers() {
		exceptionsList.clear();
	}

	/*
	 * @return array of declared exception handlers
	 */
	public CodeExceptionGen[] getExceptionHandlers() {
		CodeExceptionGen[] cg = new CodeExceptionGen[exceptionsList.size()];
		exceptionsList.toArray(cg);
		return cg;
	}

	
Returns:
code exceptions for `Code' attribute/**
	 * @return code exceptions for `Code' attribute
	 */
	private CodeException[] getCodeExceptions() {
		int size = exceptionsList.size();
		CodeException[] c_exc = new CodeException[size];

		try {
			for (int i = 0; i < size; i++) {
				CodeExceptionGen c = exceptionsList.get(i);
				c_exc[i] = c.getCodeException(cp);
			}
		} catch (ArrayIndexOutOfBoundsException e) {
		}

		return c_exc;
	}

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

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

	
Remove all exceptions.
/**
	 * Remove all exceptions.
	 */
	public void removeExceptions() {
		exceptionsThrown.clear();
	}

	/*
	 * @return array of thrown exceptions
	 */
	public String[] getExceptions() {
		String[] e = new String[exceptionsThrown.size()];
		exceptionsThrown.toArray(e);
		return e;
	}

	
Returns:
`Exceptions' attribute of all the exceptions thrown by this method./**
	 * @return `Exceptions' attribute of all the exceptions thrown by this method.
	 */
	private ExceptionTable getExceptionTable(ConstantPool cp) {
		int size = exceptionsThrown.size();
		int[] ex = new int[size];

		try {
			for (int i = 0; i < size; i++) {
				ex[i] = cp.addClass(exceptionsThrown.get(i));
			}
		} catch (ArrayIndexOutOfBoundsException e) {
		}

		return new ExceptionTable(cp.addUtf8("Exceptions"), 2 + 2 * size, ex, cp);
	}

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

	public void addParameterAnnotationsAsAttribute(ConstantPool 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.
/**
	 * Remove a code attribute.
	 */
	public void removeCodeAttribute(Attribute a) {
		codeAttributesList.remove(a);
	}

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

	
Returns:
all attributes of this method./**
	 * @return all attributes of this method.
	 */
	public Attribute[] getCodeAttributes() {
		Attribute[] attributes = new Attribute[codeAttributesList.size()];
		codeAttributesList.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).
Returns:
method object/**
	 * Get method object. Never forget to call setMaxStack() or setMaxStack(max), respectively, before calling this method (the same
	 * applies for max locals).
	 * 
	 * @return method object
	 */
	public Method getMethod() {
		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) {
			try {
				byte_code = il.getByteCode();
			} catch (Exception e) {
				throw new IllegalStateException("Unexpected problem whilst preparing bytecode for " + this.getClassName() + "."
						+ this.getName() + this.getSignature(), e);
			}
		}

		LineNumberTable lnt = null;
		LocalVariableTable lvt = null;
		// J5TODO: LocalVariableTypeTable support!

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

		if ((lineNumbersList.size() > 0) && !stripAttributes) {
			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
			List<Attribute> attributes = getAttributes();
			for (int i = 0; i < attributes.size(); i++) {
				Attribute a = attributes.get(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
					maxStack, maxLocals, byte_code, c_exc, code_attrs, cp);

			addAttribute(code);
		}

		addAnnotationsAsAttribute(cp);
		addParameterAnnotationsAsAttribute(cp);

		ExceptionTable et = null;

		if (exceptionsThrown.size() > 0) {
			addAttribute(et = getExceptionTable(cp)); // Add `Exceptions' if there are "throws" clauses
		}

		Method m = new Method(modifiers, name_index, signature_index, getAttributesImmutable(), cp);

		// Undo effects of adding attributes
		// OPTIMIZE why redo this? is there a better way to clean up?
		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;
	}

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

	public int getMaxLocals() {
		return maxLocals;
	}

	
Set maximum stack size for this method.
/**
	 * Set maximum stack size for this method.
	 */
	public void setMaxStack(int m) {
		maxStack = m;
	}

	public int getMaxStack() {
		return maxStack;
	}

	
Returns:
class that contains this method/**
	 * @return class that contains this method
	 */
	public String getClassName() {
		return classname;
	}

	public void setClassName(String class_name) {
		this.classname = class_name;
	}

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

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

	public void setArgumentTypes(Type[] arg_types) {
		this.parameterTypes = arg_types;
	}

	public Type[] getArgumentTypes() {
		return this.parameterTypes;
	}// OPTIMIZE dont need clone here? (Type[])arg_types.clone(); }

	public void setArgumentType(int i, Type type) {
		parameterTypes[i] = type;
	}

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

	public void setArgumentNames(String[] arg_names) {
		this.parameterNames = arg_names;
	}

	public String[] getArgumentNames() {
		if (parameterNames != null) {
			return parameterNames.clone();
		} else {
			return new String[0];
		}
	}

	public void setArgumentName(int i, String name) {
		parameterNames[i] = name;
	}

	public String getArgumentName(int i) {
		return parameterNames[i];
	}

	public InstructionList getInstructionList() {
		return il;
	}

	public void setInstructionList(InstructionList il) {
		this.il = il;
	}

	@Override
	public String getSignature() {
		return Utility.toMethodSignature(type, parameterTypes);
	}

	
Computes max. stack size by performing control flow analysis.
/**
	 * Computes max. stack size by performing control flow analysis.
	 */
	public void setMaxStack() {
		if (il != null) {
			maxStack = getMaxStack(cp, il, getExceptionHandlers());
		} else {
			maxStack = 0;
		}
	}

	
Compute maximum number of local variables based on the parameter count and bytecode usage of variables.
/**
	 * Compute maximum number of local variables based on the parameter count and bytecode usage of variables.
	 */
	public void setMaxLocals() {
		setMaxLocals(false);
	}
	
	
Compute maximum number of local variables.
Params:
respectLocalVariableTable – if true and the local variable table indicates more are in use
than the code suggests, respect the higher value from the local variable table data./**
	 * Compute maximum number of local variables.
	 * 
	 * @param respectLocalVariableTable if true and the local variable table indicates more are in use
	 * than the code suggests, respect the higher value from the local variable table data.
	 */
	public void setMaxLocals(boolean respectLocalVariableTable) {
		if (il != null) {
			int max = isStatic() ? 0 : 1;

			if (parameterTypes != null) {
				for (int i = 0; i < parameterTypes.length; i++) {
					max += parameterTypes[i].getSize();
				}
			}

			for (InstructionHandle ih = il.getStart(); ih != null; ih = ih.getNext()) {
				Instruction ins = ih.getInstruction();

				if ((ins instanceof InstructionLV) || (ins instanceof RET)) {
					int index = ins.getIndex() + ins.getType(cp).getSize();

					if (index > max) {
						max = index;
					}
				}
			}
			if (!respectLocalVariableTable || max > maxLocals) {
				maxLocals = max;
			}
		} else {
			if (!respectLocalVariableTable) {
				maxLocals = 0;
			}
		}
	}

	public void stripAttributes(boolean flag) {
		stripAttributes = 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<BranchTarget> branchTargets = new Stack<BranchTarget>();
		Hashtable<InstructionHandle, BranchTarget> visitedTargets = new Hashtable<InstructionHandle, BranchTarget>();

		public void push(InstructionHandle target, int stackDepth) {
			if (visited(target)) {
				return;
			}

			branchTargets.push(visit(target, stackDepth));
		}

		public BranchTarget pop() {
			if (!branchTargets.empty()) {
				BranchTarget bt = 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.
Returns:
maximum stack depth used by method/**
	 * Computes stack usage of an instruction list by performing control flow analysis.
	 * 
	 * @return maximum stack depth used by method
	 */
	public static int getMaxStack(ConstantPool cp, InstructionList il, CodeExceptionGen[] et) {
		BranchStack branchTargets = new BranchStack();

		int stackDepth = 0;
		int maxStackDepth = 0;

		/*
		 * 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, max = et.length; i < max; i++) {
			InstructionHandle handlerPos = et[i].getHandlerPC();
			if (handlerPos != null) {
				// it must be at least 1 since there is an exception handler
				maxStackDepth = 1;
				branchTargets.push(handlerPos, 1);
			}
		}

		InstructionHandle ih = il.getStart();
		while (ih != null) {
			Instruction instruction = ih.getInstruction();
			short opcode = instruction.opcode;
			int prod = instruction.produceStack(cp);
			int con = instruction.consumeStack(cp);
			int delta = prod - con;

			stackDepth += delta;
			if (stackDepth > maxStackDepth) {
				maxStackDepth = stackDepth;
			}

			// choose the next instruction based on whether current is a branch.
			if (instruction instanceof InstructionBranch) {
				InstructionBranch branch = (InstructionBranch) instruction;
				if (instruction instanceof InstructionSelect) {
					// explore all of the select's targets. the default target is handled below.
					InstructionSelect select = (InstructionSelect) 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.isIfInstruction())) {
					// 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;
	}

	
Return string representation close to declaration format, `public static void main(String[]) throws IOException', e.g.
Returns:
String representation of the method./**
	 * Return string representation close to declaration format, `public static void main(String[]) throws IOException', e.g.
	 * 
	 * @return String representation of the method.
	 */
	@Override
	public final String toString() {
		String access = Utility.accessToString(modifiers);
		String signature = Utility.toMethodSignature(type, parameterTypes);

		signature = Utility.methodSignatureToString(signature, name, access, true, getLocalVariableTable(cp));

		StringBuffer buf = new StringBuffer(signature);

		if (exceptionsThrown.size() > 0) {
			for (Iterator<String> e = exceptionsThrown.iterator(); e.hasNext();) {
				buf.append("\n\t\tthrows " + e.next());
			}
		}

		return buf.toString();
	}

	// 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
/**
	 * Return a list of AnnotationGen objects representing parameter annotations
	 */
	public List<AnnotationGen> getAnnotationsOnParameter(int i) {
		ensureExistingParameterAnnotationsUnpacked();
		if (!hasParameterAnnotations || i > parameterTypes.length) {
			return null;
		}
		return param_annotations[i];
	}

	
Goes through the attributes on the method and identifies any that are RuntimeParameterAnnotations, extracting their contents
and storing them as parameter annotations. There are two kinds of parameter annotation - visible and invisible. Once they
have been unpacked, these attributes are deleted. (The annotations will be rebuilt as attributes when someone builds a Method
object out of this MethodGen object).
/**
	 * Goes through the attributes on the method and identifies any that are RuntimeParameterAnnotations, extracting their contents
	 * and storing them as parameter annotations. There are two kinds of parameter annotation - visible and invisible. Once they
	 * have been unpacked, these attributes are deleted. (The annotations will be rebuilt as attributes when someone builds a Method
	 * object out of this MethodGen object).
	 */
	private void ensureExistingParameterAnnotationsUnpacked() {
		if (haveUnpackedParameterAnnotations) {
			return;
		}
		// Find attributes that contain parameter annotation data
		List<Attribute> attrs = getAttributes();
		RuntimeParamAnnos paramAnnVisAttr = null;
		RuntimeParamAnnos paramAnnInvisAttr = null;

		for (Attribute attribute : attrs) {
			if (attribute instanceof RuntimeParamAnnos) {

				if (!hasParameterAnnotations) {
					param_annotations = new List[parameterTypes.length];
					for (int j = 0; j < parameterTypes.length; j++) {
						param_annotations[j] = new ArrayList<AnnotationGen>();
					}
				}

				hasParameterAnnotations = true;
				RuntimeParamAnnos rpa = (RuntimeParamAnnos) attribute;
				if (rpa.areVisible()) {
					paramAnnVisAttr = rpa;
				} else {
					paramAnnInvisAttr = rpa;
				}
				for (int j = 0; j < parameterTypes.length; j++) {
					// This returns Annotation[] ...
					AnnotationGen[] annos = rpa.getAnnotationsOnParameter(j);
					// ... which needs transforming into an AnnotationGen[] ...
					// List<AnnotationGen> mutable = makeMutableVersion(immutableArray);
					// ... then add these to any we already know about
					for (AnnotationGen anAnnotation : annos) {
						param_annotations[j].add(anAnnotation);
					}
				}
			}
		}
		if (paramAnnVisAttr != null) {
			removeAttribute(paramAnnVisAttr);
		}
		if (paramAnnInvisAttr != null) {
			removeAttribute(paramAnnInvisAttr);
		}
		haveUnpackedParameterAnnotations = true;
	}

	private List /* AnnotationGen */<AnnotationGen> makeMutableVersion(AnnotationGen[] mutableArray) {
		List<AnnotationGen> result = new ArrayList<AnnotationGen>();
		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[parameterTypes.length];
			hasParameterAnnotations = true;
		}
		List<AnnotationGen> existingAnnotations = param_annotations[parameterIndex];
		if (existingAnnotations != null) {
			existingAnnotations.add(annotation);
		} else {
			List<AnnotationGen> l = new ArrayList<AnnotationGen>();
			l.add(annotation);
			param_annotations[parameterIndex] = l;
		}
	}
}