import java.util.*;
/** A class representing a method in a generated classfile
- @see ClassGen#addMethod */
+ @see ClassFile#addMethod */
public class MethodGen implements CGConst {
private final static boolean EMIT_NOPS = false;
private static final int NO_CODE = -1;
private static final int FINISHED = -2;
-
+
+ private final ClassFile owner;
private final CPGen cp;
private final String name;
private final Type ret;
private final Type[] args;
private final int flags;
- private final ClassGen.AttrGen attrs;
- private final ClassGen.AttrGen codeAttrs;
+ private final ClassFile.AttrGen attrs;
+ private final ClassFile.AttrGen codeAttrs;
private final Hashtable exnTable = new Hashtable();
private final Hashtable thrownExceptions = new Hashtable();
private byte[] op;
private Object[] arg;
- MethodGen(ClassGen owner, String name, Type ret, Type[] args, int flags) {
+ public String toString() { StringBuffer sb = new StringBuffer(); toString(sb, "<init>"); return sb.toString(); }
+ public void toString(StringBuffer sb, String constructorName) {
+ sb.append(ClassFile.flagsToString(flags));
+ sb.append(ret);
+ sb.append(" ");
+
+ if (name.equals("<clinit>")) sb.append("static ");
+ else {
+ if (name.equals("<init>")) sb.append(constructorName);
+ else sb.append(name);
+ sb.append("(");
+ for(int i=0; i<args.length; i++)
+ sb.append((i==0?"":", ")+args[i]);
+ sb.append(") ");
+ }
+ sb.append("{");
+ sb.append("}");
+ // FIXME: attrs, body
+ }
+
+ MethodGen(CPGen cp, DataInput in, ClassFile owner) throws IOException {
+ this.cp = cp;
+ this.owner = owner;
+ flags = in.readShort();
+ name = cp.getUtf8ByIndex(in.readShort());
+ String descriptor = cp.getUtf8ByIndex(in.readShort());
+ String ret = descriptor.substring(descriptor.indexOf(')')+1);
+ this.ret = Type.instance(ret);
+ //String args = descriptor.substring(1, descriptor.indexOf(')'));
+ args = new Type[0]; // FIXME
+ codeAttrs = null;
+ attrs = new ClassFile.AttrGen(cp, in);
+ }
+
+ MethodGen(ClassFile owner, String name, Type ret, Type[] args, int flags) {
if((flags & ~(ACC_PUBLIC|ACC_PRIVATE|ACC_PROTECTED|ACC_STATIC|ACC_FINAL|ACC_SYNCHRONIZED|ACC_NATIVE|ACC_ABSTRACT|ACC_STRICT)) != 0)
throw new IllegalArgumentException("invalid flags");
this.cp = owner.cp;
this.ret = ret;
this.args = args;
this.flags = flags;
+ this.owner = owner;
- attrs = new ClassGen.AttrGen(cp);
- codeAttrs = new ClassGen.AttrGen(cp);
+ attrs = new ClassFile.AttrGen(cp);
+ codeAttrs = new ClassFile.AttrGen(cp);
cp.addUtf8(name);
- cp.addUtf8(getDescriptor());
+ cp.addUtf8(owner.getType().method(name, ret, args).getDescriptor());
if((owner.flags & ACC_INTERFACE) != 0 || (flags & (ACC_ABSTRACT|ACC_NATIVE)) != 0) size = capacity = -1;
- maxLocals = Math.max(args.length + (flags&ACC_STATIC)==0 ? 1 : 0,4);
+ maxLocals = Math.max(args.length + (flags&ACC_STATIC)==0 ? 1 : 0, 4);
}
- /** Returns the descriptor string for this method */
- public String getDescriptor() { return MethodRef.getDescriptor(ret,args); }
-
private class ExnTableEnt {
public int start;
public int end;
o.writeShort(pc[start]);
o.writeShort(end==pc.length ? endPC : pc[end]);
o.writeShort(pc[handler]);
- o.writeShort(typeEnt.getIndex());
+ o.writeShort(cp.getIndex(typeEnt));
}
}
- /** Adds an exception handler for the range [<i>start</i>,<i>end</i>) pointing to <i>handler</i>
+ /** Adds an exception handler for the range [<i>start</i>, <i>end</i>) pointing to <i>handler</i>
@param start The instruction to start at (inclusive)
@param end The instruction to end at (exclusive)
@param handler The instruction of the excepton handler
@param type The type of exception that is to be handled (MUST inherit from Throwable)
*/
- public final void addExceptionHandler(int start, int end, int handler, Type.Object type) {
- exnTable.put(type, new ExnTableEnt(start,end,handler,cp.add(type)));
+ public final void addExceptionHandler(int start, int end, int handler, Type.Class type) {
+ exnTable.put(type, new ExnTableEnt(start, end, handler, cp.add(type)));
}
/** Adds a exception type that can be thrown from this method
NOTE: This isn't enforced by the JVM. This is for reference only. A method can throw exceptions not declared to be thrown
@param type The type of exception that can be thrown
*/
- public final void addThrow(Type.Object type) {
- thrownExceptions.put(type,cp.add(type));
+ public final void addThrow(Type.Class type) {
+ thrownExceptions.put(type, cp.add(type));
}
private final void grow() { if(size == capacity) grow(size+1); }
if(capacity == NO_CODE) throw new IllegalStateException("method can't have code");
if(capacity == FINISHED) throw new IllegalStateException("method has been finished");
if(newCap <= capacity) return;
- newCap = Math.max(newCap,capacity == 0 ? 256 : capacity*2);
+ newCap = Math.max(newCap, capacity == 0 ? 256 : capacity*2);
byte[] op2 = new byte[newCap];
- if(capacity != 0) System.arraycopy(op,0,op2,0,size);
+ if(capacity != 0) System.arraycopy(op, 0, op2, 0, size);
op = op2;
Object[] arg2 = new Object[newCap];
- if(capacity != 0) System.arraycopy(arg,0,arg2,0,size);
+ if(capacity != 0) System.arraycopy(arg, 0, arg2, 0, size);
arg = arg2;
capacity = newCap;
/** Adds a bytecode, <i>op</i>, with argument <i>arg</i> to the method
@return The position of the new bytecode
*/
- public final int add(byte op, Object arg) { if(capacity == size) grow(); set(size,op,arg); return size++; }
- /** Adds a bytecode with a boolean argument - equivalent to add(op,arg?1:0);
+ public final int add(byte op, Object arg) { if(capacity == size) grow(); set(size, op, arg); return size++; }
+ /** Adds a bytecode with a boolean argument - equivalent to add(op, arg?1:0);
@return The position of the new bytecode
- @see #add(byte,int)
+ @see #add(byte, int)
*/
- public final int add(byte op, boolean arg) { if(capacity == size) grow(); set(size,op,arg); return size++; }
- /** Adds a bytecode with an integer argument. This is equivalent to add(op,new Integer(arg)), but optimized to prevent the allocation when possible
+ public final int add(byte op, boolean arg) { if(capacity == size) grow(); set(size, op, arg); return size++; }
+ /** Adds a bytecode with an integer argument. This is equivalent to add(op, new Integer(arg)), but optimized to prevent the allocation when possible
@return The position of the new bytecode
- @see #add(byte,Object)
+ @see #add(byte, Object)
*/
- public final int add(byte op, int arg) { if(capacity == size) grow(); set(size,op,arg); return size++; }
+ public final int add(byte op, int arg) { if(capacity == size) grow(); set(size, op, arg); return size++; }
/** Gets the bytecode at position <i>pos</i>
@exception ArrayIndexOutOfBoundException if pos < 0 || pos >= size()
*/
public final Object getArg(int pos) { return arg[pos]; }
- /** Sets the argument for <i>pos</i> to <i>arg</i>. This is equivalent to set(pos,op,new Integer(arg)), but optimized to prevent the allocation when possible.
+ /** Sets the argument for <i>pos</i> to <i>arg</i>. This is equivalent to set(pos, op, new Integer(arg)), but optimized to prevent the allocation when possible.
@exception ArrayIndexOutOfBoundException if pos < 0 || pos >= size()
- @see #setArg(int,Object) */
- public final void setArg(int pos, int arg) { set(pos,op[pos],N(arg)); }
+ @see #setArg(int, Object) */
+ public final void setArg(int pos, int arg) { set(pos, op[pos], N(arg)); }
/** Sets the argument for <i>pos</i> to <i>arg</i>.
@exception ArrayIndexOutOfBoundException if pos < 0 || pos >= size()
*/
- public final void setArg(int pos, Object arg) { set(pos,op[pos],arg); }
+ public final void setArg(int pos, Object arg) { set(pos, op[pos], arg); }
/** Sets the bytecode and argument at <i>pos</i> to <i>op</i> and <i>arg</i> respectivly.
- This is equivalent to set(pos,op,arg?1:0)
+ This is equivalent to set(pos, op, arg?1:0)
@exception ArrayIndexOutOfBoundException if pos < 0 || pos >= size()
*/
- public final void set(int pos, byte op, boolean arg) { set(pos,op,arg?1:0); }
+ public final void set(int pos, byte op, boolean arg) { set(pos, op, arg?1:0); }
- // This MUST handle x{LOAD,STORE} and LDC with an int arg WITHOUT falling back to set(int,byte,Object)
+ // This MUST handle x{LOAD, STORE} and LDC with an int arg WITHOUT falling back to set(int, byte, Object)
/** Sets the bytecode and argument at <i>pos</i> to <i>op</i> and <i>n</i> respectivly.
- This is equivalent to set(pos,op, new Integer(n)), but optimized to prevent the allocation when possible.
+ This is equivalent to set(pos, op, new Integer(n)), but optimized to prevent the allocation when possible.
@exception ArrayIndexOutOfBoundException if pos < 0 || pos >= size()
*/
public final void set(int pos, byte op, int n) {
}
break;
default:
- set(pos,op,N(n));
+ set(pos, op, N(n));
return;
}
this.op[pos] = op;
switch(op) {
case ILOAD: case ISTORE: case LLOAD: case LSTORE: case FLOAD:
case FSTORE: case DLOAD: case DSTORE: case ALOAD: case ASTORE:
- // set(int,byte,int) always handles these ops itself
- set(pos,op,((Integer)arg).intValue());
+ // set(int, byte, int) always handles these ops itself
+ set(pos, op, ((Integer)arg).intValue());
return;
case LDC:
- // set(int,byte,int) always handles these opts itself
- if(arg instanceof Integer) { set(pos,op,((Integer)arg).intValue()); return; }
- if(arg instanceof Boolean) { set(pos,op,((Boolean)arg).booleanValue()); return; }
+ // set(int, byte, int) always handles these opts itself
+ if(arg instanceof Integer) { set(pos, op, ((Integer)arg).intValue()); return; }
+ if(arg instanceof Boolean) { set(pos, op, ((Boolean)arg).booleanValue()); return; }
if(arg instanceof Long) {
long l = ((Long)arg).longValue();
if(arg instanceof Long || arg instanceof Double) op = LDC2_W;
break;
- case INVOKEINTERFACE:
- if(arg instanceof MethodRef) arg = new MethodRef.I((MethodRef)arg);
+ case INVOKEINTERFACE: {
break;
+ }
}
int opdata = OP_DATA[op&0xff];
- if((opdata&OP_CPENT_FLAG) != 0 && !(arg instanceof CPGen.Ent))
- arg = cp.add(arg);
+ if((opdata&OP_CPENT_FLAG) != 0 && !(arg instanceof CPGen.Ent)) {
+ if (op==INVOKEINTERFACE) arg = cp.add(arg, true);
+ else arg = cp.add(arg);
+ }
else if((opdata&OP_VALID_FLAG) == 0)
throw new IllegalArgumentException("unknown bytecode");
this.op[pos] = op;
this.lo = lo;
this.hi = hi;
}
- public void setTargetForVal(int val, Object o) { setTarget(val-lo,o); }
- public void setTargetForVal(int val, int n) { setTarget(val-lo,n); }
+ public void setTargetForVal(int val, Object o) { setTarget(val-lo, o); }
+ public void setTargetForVal(int val, int n) { setTarget(val-lo, n); }
int length() { return 12 + targets.length * 4; } // 4bytes/target, hi, lo, default
}
public final byte op;
public final int varNum;
public final int n;
- Wide(byte op, int varNum) { this(op,varNum,0); }
+ Wide(byte op, int varNum) { this(op, varNum, 0); }
Wide(byte op, int varNum, int n) { this.op = op; this.varNum = varNum; this.n = n; }
}
int[] pc = new int[size];
int[] maxpc = pc;
- int p,i;
+ int p, i;
// Pass1 - Calculate maximum pc of each bytecode, widen some insns, resolve any unresolved jumps, etc
- for(i=0,p=0;i<size;i++) {
+ for(i=0, p=0;i<size;i++) {
byte op = this.op[i];
int opdata = OP_DATA[op&0xff];
int j;
int arg = ((Integer)this.arg[i]).intValue();
if(arg > 255) {
this.op[i] = WIDE;
- this.arg[i] = new Wide(op,arg);
+ this.arg[i] = new Wide(op, arg);
}
break;
}
Pair pair = (Pair) this.arg[i];
if(pair.i1 > 255 || pair.i2 < -128 || pair.i2 > 127) {
this.op[i] = WIDE;
- this.arg[i] = new Wide(IINC,pair.i1,pair.i2);
+ this.arg[i] = new Wide(IINC, pair.i1, pair.i2);
}
break;
}
case LDC:
- j = ((CPGen.Ent)arg[i]).getIndex();
+ j = cp.getIndex((CPGen.Ent)arg[i]);
if(j >= 256) this.op[i] = op = LDC_W;
break;
default:
}
// Pass3 - Calculate actual pc
- for(i=0,p=0;i<size;i++) {
+ for(i=0, p=0;i<size;i++) {
byte op = this.op[i];
pc[i] = p;
switch(op) {
p = (p + 3) & ~3; // padding
p += 4; // default
if(op == TABLESWITCH) p += 4 + 4 + si.size() * 4; // lo, hi, targets
- else p += 4 + si.size() * 4 * 2; // count, key,val * targets
+ else p += 4 + si.size() * 4 * 2; // count, key, val * targets
break;
}
case WIDE:
}
int codeSize = p;
- if(codeSize >= 65536) throw new ClassGen.Exn("method too large in size");
+ if(codeSize >= 65536) throw new ClassFile.Exn("method too large in size");
o.writeShort(maxStack);
o.writeShort(maxLocals);
switch(op) {
case IINC: {
Pair pair = (Pair) arg;
- if(pair.i1 > 255 || pair.i2 < -128 || pair.i2 > 127) throw new ClassGen.Exn("overflow of iinc arg");
+ if(pair.i1 > 255 || pair.i2 < -128 || pair.i2 > 127) throw new ClassFile.Exn("overflow of iinc arg");
o.writeByte(pair.i1);
o.writeByte(pair.i2);
break;
if((opdata & OP_BRANCH_FLAG) != 0) {
int v = pc[((Integer)arg).intValue()] - pc[i];
if(argLength == 2) {
- if(v < -32768 || v > 32767) throw new ClassGen.Exn("overflow of s2 offset");
+ if(v < -32768 || v > 32767) throw new ClassFile.Exn("overflow of s2 offset");
o.writeShort(v);
} else if(argLength == 4) {
o.writeInt(v);
throw new Error("should never happen");
}
} else if((opdata & OP_CPENT_FLAG) != 0) {
- int v = ((CPGen.Ent)arg).getIndex();
+ int v = cp.getIndex((CPGen.Ent)arg);
if(argLength == 1) o.writeByte(v);
else if(argLength == 2) o.writeShort(v);
else throw new Error("should never happen");
} else {
int iarg = ((Integer)arg).intValue();
if(argLength == 1) {
- if(iarg < -128 || iarg >= 256) throw new ClassGen.Exn("overflow of s/u1 option");
+ if(iarg < -128 || iarg >= 256) throw new ClassFile.Exn("overflow of s/u1 option");
o.writeByte(iarg);
} else if(argLength == 2) {
- if(iarg < -32768 || iarg >= 65536) throw new ClassGen.Exn("overflow of s/u2 option");
+ if(iarg < -32768 || iarg >= 65536) throw new ClassFile.Exn("overflow of s/u2 option");
o.writeShort(iarg);
} else {
throw new Error("should never happen");
o.writeShort(exnTable.size());
for(Enumeration e = exnTable.keys();e.hasMoreElements();)
- ((ExnTableEnt)exnTable.get(e.nextElement())).dump(o,pc,codeSize);
+ ((ExnTableEnt)exnTable.get(e.nextElement())).dump(o, pc, codeSize);
o.writeShort(codeAttrs.size());
codeAttrs.dump(o);
baos.close();
byte[] codeAttribute = baos.toByteArray();
- attrs.add("Code",codeAttribute);
+ attrs.add("Code", codeAttribute);
baos.reset();
o.writeShort(thrownExceptions.size());
for(Enumeration e = thrownExceptions.keys();e.hasMoreElements();)
- o.writeShort(((CPGen.Ent)thrownExceptions.get(e.nextElement())).getIndex());
- attrs.add("Exceptions",baos.toByteArray());
+ o.writeShort(cp.getIndex((CPGen.Ent)thrownExceptions.get(e.nextElement())));
+ attrs.add("Exceptions", baos.toByteArray());
size = capacity = FINISHED;
}
void dump(DataOutput o) throws IOException {
o.writeShort(flags);
o.writeShort(cp.getUtf8Index(name));
- o.writeShort(cp.getUtf8Index(getDescriptor()));
+ o.writeShort(cp.getUtf8Index(owner.getType().method(name, ret, args).getDescriptor()));
o.writeShort(attrs.size());
attrs.dump(o);
}
projects / org.ibex.classgen.git / blobdiff