Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
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 [email protected].
*
* 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
* .
*/
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 M. Dahm
* @author Patrick C. Beard [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 localVariablesList = new ArrayList();
private ArrayList lineNumbersList = new ArrayList();
private ArrayList exceptionsList = new ArrayList();
private ArrayList exceptionsThrown = new ArrayList();
private ArrayList codeAttributesList = 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, 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 l = runtimeAnnotations.getAnnotations();
annotationList.addAll(l);
// for (Iterator 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 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 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 = 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 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 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 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();
}
}
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 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 */ makeMutableVersion(AnnotationGen[] 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[parameterTypes.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;
}
}
}
