Java tutorial
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. * * @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. * * @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. * * @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. * * @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. */ public void removeLocalVariable(LocalVariableGen l) { localVariablesList.remove(l); } /** * Remove all local variables. */ public void removeLocalVariables() { localVariablesList.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 = 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; } /** * @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. * * @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. */ public void removeLineNumber(LineNumberGen l) { lineNumbersList.remove(l); } /** * 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; } /** * @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. * * @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. */ public void removeExceptionHandler(CodeExceptionGen c) { exceptionsList.remove(c); } /** * 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; } /** * @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. * * @param class_name (fully qualified) name of exception */ public void addException(String class_name) { exceptionsThrown.add(class_name); } /** * Remove an exception. */ public void removeException(String c) { exceptionsThrown.remove(c); } /** * 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; } /** * @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. * * @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. */ public void removeCodeAttribute(Attribute a) { codeAttributesList.remove(a); } /** * Remove all code attributes. */ public void removeCodeAttributes() { codeAttributesList.clear(); } /** * @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). * * @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. */ public void setMaxLocals(int m) { maxLocals = m; } public int getMaxLocals() { return maxLocals; } /** * Set maximum stack size for this method. */ public void setMaxStack(int m) { maxStack = m; } public int getMaxStack() { return maxStack; } /** * @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. */ 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. */ public void setMaxLocals() { setMaxLocals(false); } /** * 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. * * @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. * * @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 */ 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). */ 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; } } }