Java example source code file (MethodGen.java)
The MethodGen.java Java example source code
/*
* reserved comment block
* DO NOT REMOVE OR ALTER!
*/
package com.sun.org.apache.bcel.internal.generic;
/* ====================================================================
* The Apache Software License, Version 1.1
*
* Copyright (c) 2001 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution,
* if any, must include the following acknowledgment:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowledgment may appear in the software itself,
* if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Apache" and "Apache Software Foundation" and
* "Apache BCEL" must not be used to endorse or promote products
* derived from this software without prior written permission. For
* written permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache",
* "Apache BCEL", nor may "Apache" appear in their name, without
* prior written permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*/
import com.sun.org.apache.bcel.internal.Constants;
import com.sun.org.apache.bcel.internal.classfile.*;
import java.util.*;
/**
* Template class for building up a method. This is done by defining exception
* handlers, adding thrown exceptions, local variables and attributes, whereas
* the `LocalVariableTable' and `LineNumberTable' attributes will be set
* automatically for the code. Use stripAttributes() if you don't like this.
*
* While generating code it may be necessary to insert NOP operations. You can
* use the `removeNOPs' method to get rid off them.
* The resulting method object can be obtained via the `getMethod()' method.
*
* @author <A HREF="mailto:markus.dahm@berlin.de">M. Dahm
* @author <A HREF="http://www.vmeng.com/beard">Patrick C. Beard [setMaxStack()]
* @see InstructionList
* @see Method
*/
public class MethodGen extends FieldGenOrMethodGen {
private String class_name;
private Type[] arg_types;
private String[] arg_names;
private int max_locals;
private int max_stack;
private InstructionList il;
private boolean strip_attributes;
private ArrayList variable_vec = new ArrayList();
private ArrayList line_number_vec = new ArrayList();
private ArrayList exception_vec = new ArrayList();
private ArrayList throws_vec = new ArrayList();
private ArrayList code_attrs_vec = new ArrayList();
/**
* Declare method. If the method is non-static the constructor
* automatically declares a local variable `$this' in slot 0. The
* actual code is contained in the `il' parameter, which may further
* manipulated by the user. But he must take care not to remove any
* instruction (handles) that are still referenced from this object.
*
* For example one may not add a local variable and later remove the
* instructions it refers to without causing havoc. It is safe
* however if you remove that local variable, too.
*
* @param access_flags access qualifiers
* @param return_type method type
* @param arg_types argument types
* @param arg_names argument names (if this is null, default names will be provided
* for them)
* @param method_name name of method
* @param class_name class name containing this method (may be null, if you don't care)
* @param il instruction list associated with this method, may be null only for
* abstract or native methods
* @param cp constant pool
*/
public MethodGen(int access_flags, Type return_type, Type[] arg_types,
String[] arg_names, String method_name, String class_name,
InstructionList il, ConstantPoolGen cp) {
setAccessFlags(access_flags);
setType(return_type);
setArgumentTypes(arg_types);
setArgumentNames(arg_names);
setName(method_name);
setClassName(class_name);
setInstructionList(il);
setConstantPool(cp);
boolean abstract_ = isAbstract() || isNative();
InstructionHandle start = null;
InstructionHandle end = null;
if(!abstract_) {
start = il.getStart();
end = il.getEnd();
/* Add local variables, namely the implicit `this' and the arguments
*/
if(!isStatic() && (class_name != null)) { // Instance method -> `this' is local var 0
addLocalVariable("this", new ObjectType(class_name), start, end);
}
}
if(arg_types != null) {
int size = arg_types.length;
for(int i=0; i < size; i++) {
if(Type.VOID == arg_types[i]) {
throw new ClassGenException("'void' is an illegal argument type for a method");
}
}
if(arg_names != null) { // Names for variables provided?
if(size != arg_names.length)
throw new ClassGenException("Mismatch in argument array lengths: " +
size + " vs. " + arg_names.length);
} else { // Give them dummy names
arg_names = new String[size];
for(int i=0; i < size; i++)
arg_names[i] = "arg" + i;
setArgumentNames(arg_names);
}
if(!abstract_) {
for(int i=0; i < size; i++) {
addLocalVariable(arg_names[i], arg_types[i], start, end);
}
}
}
}
/**
* Instantiate from existing method.
*
* @param m method
* @param class_name class name containing this method
* @param cp constant pool
*/
public MethodGen(Method m, String class_name, ConstantPoolGen cp) {
this(m.getAccessFlags(), Type.getReturnType(m.getSignature()),
Type.getArgumentTypes(m.getSignature()), null /* may be overridden anyway */,
m.getName(), class_name,
((m.getAccessFlags() & (Constants.ACC_ABSTRACT | Constants.ACC_NATIVE)) == 0)?
new InstructionList(m.getCode().getCode()) : null,
cp);
Attribute[] attributes = m.getAttributes();
for(int i=0; i < attributes.length; i++) {
Attribute a = attributes[i];
if(a instanceof Code) {
Code c = (Code)a;
setMaxStack(c.getMaxStack());
setMaxLocals(c.getMaxLocals());
CodeException[] ces = c.getExceptionTable();
if(ces != null) {
for(int j=0; j < ces.length; j++) {
CodeException ce = ces[j];
int type = ce.getCatchType();
ObjectType c_type = null;
if(type > 0) {
String cen = m.getConstantPool().getConstantString(type, Constants.CONSTANT_Class);
c_type = new ObjectType(cen);
}
int end_pc = ce.getEndPC();
int length = m.getCode().getCode().length;
InstructionHandle end;
if(length == end_pc) { // May happen, because end_pc is exclusive
end = il.getEnd();
} else {
end = il.findHandle(end_pc);
end = end.getPrev(); // Make it inclusive
}
addExceptionHandler(il.findHandle(ce.getStartPC()), end,
il.findHandle(ce.getHandlerPC()), c_type);
}
}
Attribute[] c_attributes = c.getAttributes();
for(int j=0; j < c_attributes.length; j++) {
a = c_attributes[j];
if(a instanceof LineNumberTable) {
LineNumber[] ln = ((LineNumberTable)a).getLineNumberTable();
for(int k=0; k < ln.length; k++) {
LineNumber l = ln[k];
addLineNumber(il.findHandle(l.getStartPC()), l.getLineNumber());
}
} else if(a instanceof LocalVariableTable) {
LocalVariable[] lv = ((LocalVariableTable)a).getLocalVariableTable();
removeLocalVariables();
for(int k=0; k < lv.length; k++) {
LocalVariable l = lv[k];
InstructionHandle start = il.findHandle(l.getStartPC());
InstructionHandle end = il.findHandle(l.getStartPC() + l.getLength());
// Repair malformed handles
if(null == start) {
start = il.getStart();
}
if(null == end) {
end = il.getEnd();
}
addLocalVariable(l.getName(), Type.getType(l.getSignature()),
l.getIndex(), start, end);
}
} else if (a instanceof LocalVariableTypeTable) {
LocalVariable[] lv = ((LocalVariableTypeTable) a).getLocalVariableTypeTable();
removeLocalVariables();
for (int k = 0; k < lv.length; k++) {
LocalVariable l = lv[k];
InstructionHandle start = il.findHandle(l.getStartPC());
InstructionHandle end = il.findHandle(l.getStartPC() + l.getLength());
// Repair malformed handles
if (null == start) {
start = il.getStart();
}
if (null == end) {
end = il.getEnd();
}
addLocalVariable(l.getName(), Type.getType(l.getSignature()), l
.getIndex(), start, end);
}
} else
addCodeAttribute(a);
}
} else if(a instanceof ExceptionTable) {
String[] names = ((ExceptionTable)a).getExceptionNames();
for(int j=0; j < names.length; j++)
addException(names[j]);
} else
addAttribute(a);
}
}
/**
* Adds a local variable to this method.
*
* @param name variable name
* @param type variable type
* @param slot the index of the local variable, if type is long or double, the next available
* index is slot+2
* @param start from where the variable is valid
* @param end until where the variable is valid
* @return new local variable object
* @see LocalVariable
*/
public LocalVariableGen addLocalVariable(String name, Type type, int slot,
InstructionHandle start,
InstructionHandle end) {
byte t = type.getType();
if(t != Constants.T_ADDRESS) {
int add = type.getSize();
if(slot + add > max_locals)
max_locals = slot + add;
LocalVariableGen l = new LocalVariableGen(slot, name, type, start, end);
int i;
if((i = variable_vec.indexOf(l)) >= 0) // Overwrite if necessary
variable_vec.set(i, l);
else
variable_vec.add(l);
return l;
} else {
throw new IllegalArgumentException("Can not use " + type +
" as type for local variable");
}
}
/**
* Adds a local variable to this method and assigns an index automatically.
*
* @param name variable name
* @param type variable type
* @param start from where the variable is valid, if this is null,
* it is valid from the start
* @param end until where the variable is valid, if this is null,
* it is valid to the end
* @return new local variable object
* @see LocalVariable
*/
public LocalVariableGen addLocalVariable(String name, Type type,
InstructionHandle start,
InstructionHandle end) {
return addLocalVariable(name, type, max_locals, start, end);
}
/**
* Remove a local variable, its slot will not be reused, if you do not use addLocalVariable
* with an explicit index argument.
*/
public void removeLocalVariable(LocalVariableGen l) {
variable_vec.remove(l);
}
/**
* Remove all local variables.
*/
public void removeLocalVariables() {
variable_vec.clear();
}
/**
* Sort local variables by index
*/
private static final void sort(LocalVariableGen[] vars, int l, int r) {
int i = l, j = r;
int m = vars[(l + r) / 2].getIndex();
LocalVariableGen h;
do {
while(vars[i].getIndex() < m) i++;
while(m < vars[j].getIndex()) j--;
if(i <= j) {
h=vars[i]; vars[i]=vars[j]; vars[j]=h; // Swap elements
i++; j--;
}
} while(i <= j);
if(l < j) sort(vars, l, j);
if(i < r) sort(vars, i, r);
}
/*
* If the range of the variable has not been set yet, it will be set to be valid from
* the start to the end of the instruction list.
*
* @return array of declared local variables sorted by index
*/
public LocalVariableGen[] getLocalVariables() {
int size = variable_vec.size();
LocalVariableGen[] lg = new LocalVariableGen[size];
variable_vec.toArray(lg);
for(int i=0; i < size; i++) {
if(lg[i].getStart() == null)
lg[i].setStart(il.getStart());
if(lg[i].getEnd() == null)
lg[i].setEnd(il.getEnd());
}
if(size > 1)
sort(lg, 0, size - 1);
return lg;
}
/**
* @return `LocalVariableTable' attribute of all the local variables of this method.
*/
public LocalVariableTable getLocalVariableTable(ConstantPoolGen cp) {
LocalVariableGen[] lg = getLocalVariables();
int size = lg.length;
LocalVariable[] lv = new LocalVariable[size];
for(int i=0; i < size; i++)
lv[i] = lg[i].getLocalVariable(cp);
return new LocalVariableTable(cp.addUtf8("LocalVariableTable"),
2 + lv.length * 10, lv, cp.getConstantPool());
}
/**
* Give an instruction a line number corresponding to the source code line.
*
* @param ih instruction to tag
* @return new line number object
* @see LineNumber
*/
public LineNumberGen addLineNumber(InstructionHandle ih, int src_line) {
LineNumberGen l = new LineNumberGen(ih, src_line);
line_number_vec.add(l);
return l;
}
/**
* Remove a line number.
*/
public void removeLineNumber(LineNumberGen l) {
line_number_vec.remove(l);
}
/**
* Remove all line numbers.
*/
public void removeLineNumbers() {
line_number_vec.clear();
}
/*
* @return array of line numbers
*/
public LineNumberGen[] getLineNumbers() {
LineNumberGen[] lg = new LineNumberGen[line_number_vec.size()];
line_number_vec.toArray(lg);
return lg;
}
/**
* @return `LineNumberTable' attribute of all the local variables of this method.
*/
public LineNumberTable getLineNumberTable(ConstantPoolGen cp) {
int size = line_number_vec.size();
LineNumber[] ln = new LineNumber[size];
try {
for(int i=0; i < size; i++)
ln[i] = ((LineNumberGen)line_number_vec.get(i)).getLineNumber();
} catch(ArrayIndexOutOfBoundsException e) {} // Never occurs
return new LineNumberTable(cp.addUtf8("LineNumberTable"),
2 + ln.length * 4, ln, cp.getConstantPool());
}
/**
* Add an exception handler, i.e., specify region where a handler is active and an
* instruction where the actual handling is done.
*
* @param start_pc Start of region (inclusive)
* @param end_pc End of region (inclusive)
* @param handler_pc Where handling is done
* @param catch_type class type of handled exception or null if any
* exception is handled
* @return new exception handler object
*/
public CodeExceptionGen addExceptionHandler(InstructionHandle start_pc,
InstructionHandle end_pc,
InstructionHandle handler_pc,
ObjectType catch_type) {
if((start_pc == null) || (end_pc == null) || (handler_pc == null))
throw new ClassGenException("Exception handler target is null instruction");
CodeExceptionGen c = new CodeExceptionGen(start_pc, end_pc,
handler_pc, catch_type);
exception_vec.add(c);
return c;
}
/**
* Remove an exception handler.
*/
public void removeExceptionHandler(CodeExceptionGen c) {
exception_vec.remove(c);
}
/**
* Remove all line numbers.
*/
public void removeExceptionHandlers() {
exception_vec.clear();
}
/*
* @return array of declared exception handlers
*/
public CodeExceptionGen[] getExceptionHandlers() {
CodeExceptionGen[] cg = new CodeExceptionGen[exception_vec.size()];
exception_vec.toArray(cg);
return cg;
}
/**
* @return code exceptions for `Code' attribute
*/
private CodeException[] getCodeExceptions() {
int size = exception_vec.size();
CodeException[] c_exc = new CodeException[size];
try {
for(int i=0; i < size; i++) {
CodeExceptionGen c = (CodeExceptionGen)exception_vec.get(i);
c_exc[i] = c.getCodeException(cp);
}
} catch(ArrayIndexOutOfBoundsException e) {}
return c_exc;
}
/**
* Add an exception possibly thrown by this method.
*
* @param class_name (fully qualified) name of exception
*/
public void addException(String class_name) {
throws_vec.add(class_name);
}
/**
* Remove an exception.
*/
public void removeException(String c) {
throws_vec.remove(c);
}
/**
* Remove all exceptions.
*/
public void removeExceptions() {
throws_vec.clear();
}
/*
* @return array of thrown exceptions
*/
public String[] getExceptions() {
String[] e = new String[throws_vec.size()];
throws_vec.toArray(e);
return e;
}
/**
* @return `Exceptions' attribute of all the exceptions thrown by this method.
*/
private ExceptionTable getExceptionTable(ConstantPoolGen cp) {
int size = throws_vec.size();
int[] ex = new int[size];
try {
for(int i=0; i < size; i++)
ex[i] = cp.addClass((String)throws_vec.get(i));
} catch(ArrayIndexOutOfBoundsException e) {}
return new ExceptionTable(cp.addUtf8("Exceptions"),
2 + 2 * size, ex, cp.getConstantPool());
}
/**
* Add an attribute to the code. Currently, the JVM knows about the
* LineNumberTable, LocalVariableTable and StackMap attributes,
* where the former two will be generated automatically and the
* latter is used for the MIDP only. Other attributes will be
* ignored by the JVM but do no harm.
*
* @param a attribute to be added
*/
public void addCodeAttribute(Attribute a) { code_attrs_vec.add(a); }
/**
* Remove a code attribute.
*/
public void removeCodeAttribute(Attribute a) { code_attrs_vec.remove(a); }
/**
* Remove all code attributes.
*/
public void removeCodeAttributes() {
code_attrs_vec.clear();
}
/**
* @return all attributes of this method.
*/
public Attribute[] getCodeAttributes() {
Attribute[] attributes = new Attribute[code_attrs_vec.size()];
code_attrs_vec.toArray(attributes);
return attributes;
}
/**
* Get method object. Never forget to call setMaxStack() or setMaxStack(max), respectively,
* before calling this method (the same applies for max locals).
*
* @return method object
*/
public Method getMethod() {
String signature = getSignature();
int name_index = cp.addUtf8(name);
int signature_index = cp.addUtf8(signature);
/* Also updates positions of instructions, i.e., their indices
*/
byte[] byte_code = null;
if(il != null)
byte_code = il.getByteCode();
LineNumberTable lnt = null;
LocalVariableTable lvt = null;
/* Create LocalVariableTable and LineNumberTable attributes (for debuggers, e.g.)
*/
if((variable_vec.size() > 0) && !strip_attributes)
addCodeAttribute(lvt = getLocalVariableTable(cp));
if((line_number_vec.size() > 0) && !strip_attributes)
addCodeAttribute(lnt = getLineNumberTable(cp));
Attribute[] code_attrs = getCodeAttributes();
/* Each attribute causes 6 additional header bytes
*/
int attrs_len = 0;
for(int i=0; i < code_attrs.length; i++)
attrs_len += (code_attrs[i].getLength() + 6);
CodeException[] c_exc = getCodeExceptions();
int exc_len = c_exc.length * 8; // Every entry takes 8 bytes
Code code = null;
if((il != null) && !isAbstract()) {
// Remove any stale code attribute
Attribute[] attributes = getAttributes();
for(int i=0; i < attributes.length; i++) {
Attribute a = attributes[i];
if(a instanceof Code)
removeAttribute(a);
}
code = new Code(cp.addUtf8("Code"),
8 + byte_code.length + // prologue byte code
2 + exc_len + // exceptions
2 + attrs_len, // attributes
max_stack, max_locals,
byte_code, c_exc,
code_attrs,
cp.getConstantPool());
addAttribute(code);
}
ExceptionTable et = null;
if(throws_vec.size() > 0)
addAttribute(et = getExceptionTable(cp)); // Add `Exceptions' if there are "throws" clauses
Method m = new Method(access_flags, name_index, signature_index,
getAttributes(), cp.getConstantPool());
// Undo effects of adding attributes
if(lvt != null) removeCodeAttribute(lvt);
if(lnt != null) removeCodeAttribute(lnt);
if(code != null) removeAttribute(code);
if(et != null) removeAttribute(et);
return m;
}
/**
* Remove all NOPs from the instruction list (if possible) and update every
* object refering to them, i.e., branch instructions, local variables and
* exception handlers.
*/
public void removeNOPs() {
if(il != null) {
InstructionHandle next;
/* Check branch instructions.
*/
for(InstructionHandle ih = il.getStart(); ih != null; ih = next) {
next = ih.next;
if((next != null) && (ih.getInstruction() instanceof NOP)) {
try {
il.delete(ih);
} catch(TargetLostException e) {
InstructionHandle[] targets = e.getTargets();
for(int i=0; i < targets.length; i++) {
InstructionTargeter[] targeters = targets[i].getTargeters();
for(int j=0; j < targeters.length; j++)
targeters[j].updateTarget(targets[i], next);
}
}
}
}
}
}
/**
* Set maximum number of local variables.
*/
public void setMaxLocals(int m) { max_locals = m; }
public int getMaxLocals() { return max_locals; }
/**
* Set maximum stack size for this method.
*/
public void setMaxStack(int m) { max_stack = m; }
public int getMaxStack() { return max_stack; }
/** @return class that contains this method
*/
public String getClassName() { return class_name; }
public void setClassName(String class_name) { this.class_name = class_name; }
public void setReturnType(Type return_type) { setType(return_type); }
public Type getReturnType() { return getType(); }
public void setArgumentTypes(Type[] arg_types) { this.arg_types = arg_types; }
public Type[] getArgumentTypes() { return (Type[])arg_types.clone(); }
public void setArgumentType(int i, Type type) { arg_types[i] = type; }
public Type getArgumentType(int i) { return arg_types[i]; }
public void setArgumentNames(String[] arg_names) { this.arg_names = arg_names; }
public String[] getArgumentNames() { return (String[])arg_names.clone(); }
public void setArgumentName(int i, String name) { arg_names[i] = name; }
public String getArgumentName(int i) { return arg_names[i]; }
public InstructionList getInstructionList() { return il; }
public void setInstructionList(InstructionList il) { this.il = il; }
public String getSignature() {
return Type.getMethodSignature(type, arg_types);
}
/**
* Computes max. stack size by performing control flow analysis.
*/
public void setMaxStack() {
if(il != null)
max_stack = getMaxStack(cp, il, getExceptionHandlers());
else
max_stack = 0;
}
/**
* Compute maximum number of local variables.
*/
public void setMaxLocals() {
if(il != null) {
int max = isStatic()? 0 : 1;
if(arg_types != null)
for(int i=0; i < arg_types.length; i++)
max += arg_types[i].getSize();
for(InstructionHandle ih = il.getStart(); ih != null; ih = ih.getNext()) {
Instruction ins = ih.getInstruction();
if((ins instanceof LocalVariableInstruction) ||
(ins instanceof RET) || (ins instanceof IINC))
{
int index = ((IndexedInstruction)ins).getIndex() +
((TypedInstruction)ins).getType(cp).getSize();
if(index > max)
max = index;
}
}
max_locals = max;
} else
max_locals = 0;
}
/** Do not/Do produce attributes code attributesLineNumberTable and
* LocalVariableTable, like javac -O
*/
public void stripAttributes(boolean flag) { strip_attributes = flag; }
static final class BranchTarget {
InstructionHandle target;
int stackDepth;
BranchTarget(InstructionHandle target, int stackDepth) {
this.target = target;
this.stackDepth = stackDepth;
}
}
static final class BranchStack {
Stack branchTargets = new Stack();
Hashtable visitedTargets = new Hashtable();
public void push(InstructionHandle target, int stackDepth) {
if(visited(target))
return;
branchTargets.push(visit(target, stackDepth));
}
public BranchTarget pop() {
if(!branchTargets.empty()) {
BranchTarget bt = (BranchTarget) branchTargets.pop();
return bt;
}
return null;
}
private final BranchTarget visit(InstructionHandle target, int stackDepth) {
BranchTarget bt = new BranchTarget(target, stackDepth);
visitedTargets.put(target, bt);
return bt;
}
private final boolean visited(InstructionHandle target) {
return (visitedTargets.get(target) != null);
}
}
/**
* Computes stack usage of an instruction list by performing control flow analysis.
*
* @return maximum stack depth used by method
*/
public static int getMaxStack(ConstantPoolGen cp, InstructionList il, CodeExceptionGen[] et) {
BranchStack branchTargets = new BranchStack();
/* Initially, populate the branch stack with the exception
* handlers, because these aren't (necessarily) branched to
* explicitly. in each case, the stack will have depth 1,
* containing the exception object.
*/
for (int i = 0; i < et.length; i++) {
InstructionHandle handler_pc = et[i].getHandlerPC();
if (handler_pc != null)
branchTargets.push(handler_pc, 1);
}
int stackDepth = 0, maxStackDepth = 0;
InstructionHandle ih = il.getStart();
while(ih != null) {
Instruction instruction = ih.getInstruction();
short opcode = instruction.getOpcode();
int delta = instruction.produceStack(cp) - instruction.consumeStack(cp);
stackDepth += delta;
if(stackDepth > maxStackDepth)
maxStackDepth = stackDepth;
// choose the next instruction based on whether current is a branch.
if(instruction instanceof BranchInstruction) {
BranchInstruction branch = (BranchInstruction) instruction;
if(instruction instanceof Select) {
// explore all of the select's targets. the default target is handled below.
Select select = (Select) branch;
InstructionHandle[] targets = select.getTargets();
for (int i = 0; i < targets.length; i++)
branchTargets.push(targets[i], stackDepth);
// nothing to fall through to.
ih = null;
} else if(!(branch instanceof IfInstruction)) {
// if an instruction that comes back to following PC,
// push next instruction, with stack depth reduced by 1.
if(opcode == Constants.JSR || opcode == Constants.JSR_W)
branchTargets.push(ih.getNext(), stackDepth - 1);
ih = null;
}
// for all branches, the target of the branch is pushed on the branch stack.
// conditional branches have a fall through case, selects don't, and
// jsr/jsr_w return to the next instruction.
branchTargets.push(branch.getTarget(), stackDepth);
} else {
// check for instructions that terminate the method.
if(opcode == Constants.ATHROW || opcode == Constants.RET ||
(opcode >= Constants.IRETURN && opcode <= Constants.RETURN))
ih = null;
}
// normal case, go to the next instruction.
if(ih != null)
ih = ih.getNext();
// if we have no more instructions, see if there are any deferred branches to explore.
if(ih == null) {
BranchTarget bt = branchTargets.pop();
if (bt != null) {
ih = bt.target;
stackDepth = bt.stackDepth;
}
}
}
return maxStackDepth;
}
private ArrayList observers;
/** Add observer for this object.
*/
public void addObserver(MethodObserver o) {
if(observers == null)
observers = new ArrayList();
observers.add(o);
}
/** Remove observer for this object.
*/
public void removeObserver(MethodObserver o) {
if(observers != null)
observers.remove(o);
}
/** Call notify() method on all observers. This method is not called
* automatically whenever the state has changed, but has to be
* called by the user after he has finished editing the object.
*/
public void update() {
if(observers != null)
for(Iterator e = observers.iterator(); e.hasNext(); )
((MethodObserver)e.next()).notify(this);
}
/**
* Return string representation close to declaration format,
* `public static void _main(String[]) throws IOException', e.g.
*
* @return String representation of the method.
*/
public final String toString() {
String access = Utility.accessToString(access_flags);
String signature = Type.getMethodSignature(type, arg_types);
signature = Utility.methodSignatureToString(signature, name, access,
true, getLocalVariableTable(cp));
StringBuffer buf = new StringBuffer(signature);
if(throws_vec.size() > 0) {
for(Iterator e = throws_vec.iterator(); e.hasNext(); )
buf.append("\n\t\tthrows " + e.next());
}
return buf.toString();
}
/** @return deep copy of this method
*/
public MethodGen copy(String class_name, ConstantPoolGen cp) {
Method m = ((MethodGen)clone()).getMethod();
MethodGen mg = new MethodGen(m, class_name, this.cp);
if(this.cp != cp) {
mg.setConstantPool(cp);
mg.getInstructionList().replaceConstantPool(this.cp, cp);
}
return mg;
}
}
Other Java examples (source code examples)Here is a short list of links related to this Java MethodGen.java source code file: |
The search page
Other Java source code examples at this package level
Click here to learn more about this project
