X-Git-Url: http://git.megacz.com/?p=org.ibex.classgen.git;a=blobdiff_plain;f=src%2Forg%2Fibex%2Fclassgen%2FCPGen.java;h=edc4d9c350188711307af52ce6109104e3e18ab9;hp=3682fe92bd472e538cbb82279059de101753c7ca;hb=69b2d27ebab56f1b0e4df2a3a301f4d852439e8e;hpb=d4d0c4d937a3c18d559e335a84aed3eb4e406723 diff --git a/src/org/ibex/classgen/CPGen.java b/src/org/ibex/classgen/CPGen.java index 3682fe9..edc4d9c 100644 --- a/src/org/ibex/classgen/CPGen.java +++ b/src/org/ibex/classgen/CPGen.java @@ -17,39 +17,35 @@ class CPGen { CPGen() { } - /* - * Entries - */ - public abstract static class Ent { - CPGen owner; // don't need this yet, but we will to implement ref() and unref() + public abstract class Ent { int n; // this is the refcount if state == OPEN, index if >= STABLE int tag; - Ent(CPGen owner, int tag) { this.owner = owner; this.tag = tag; } + Ent(int tag) { this.tag = tag; } void dump(DataOutput o) throws IOException { o.writeByte(tag); } String debugToString() { return toString(); } // so we can remove this method when not debugging - abstract Object key() throws ClassGen.ClassReadExn; // be careful using this, it drags in a bunch of code + abstract Object key() throws ClassFile.ClassReadExn; // be careful using this, it drags in a bunch of code } - // INVARIANTS: tag == 3 || tag == 4 - static class IntEnt extends Ent { - int i; - IntEnt(CPGen owner, int tag) { super(owner, tag); } + class IntEnt extends Ent { + final int i; + IntEnt(int i) { super(3); this.i = i; } void dump(DataOutput o) throws IOException { super.dump(o); o.writeInt(i); } - Object key() { - switch(tag) { - case 3: return new Integer(i); - case 4: return new Float(Float.intBitsToFloat(i)); - default: throw new Error("should never happen"); - } - } + Object key() { return new Integer(i); } + } + + class FloatEnt extends Ent { + final float f; + FloatEnt(float f) { super(4); this.f = f; } + void dump(DataOutput o) throws IOException { super.dump(o); o.writeFloat(f); } + Object key() { return new Float(f); } } // INVARIANTS: tag == 5 || tag == 6 - static class LongEnt extends Ent { + class LongEnt extends Ent { long l; - LongEnt(CPGen owner, int tag) { super(owner, tag); } + LongEnt(int tag) { super(tag); } void dump(DataOutput o) throws IOException { super.dump(o); o.writeLong(l); } Object key() { switch(tag) { @@ -71,10 +67,10 @@ class CPGen { e0 instanceof Utf8Ent } */ - static class CPRefEnt extends Ent { + class CPRefEnt extends Ent { Ent e1; Ent e2; - CPRefEnt(CPGen owner, int tag) { super(owner, tag); } + CPRefEnt(int tag) { super(tag); } String debugToString() { return "[" + e1.n + ":" + e1.debugToString() + (e2 == null ? "" : " + " + e2.n + ":" + e2.debugToString()) + "]"; } @@ -85,20 +81,20 @@ class CPGen { } private String fixme() { throw new Error("fixme"); } - Object key() throws ClassGen.ClassReadExn { + Object key() throws ClassFile.ClassReadExn { switch(tag) { - case 7: return Type.fromDescriptor(((Utf8Ent)e1).s); + case 7: return Type.instance(((Utf8Ent)e1).s); case 8: return (((Utf8Ent)e1).s); case 9: { NameAndTypeKey nt = (NameAndTypeKey) e2.key(); - Type t = Type.fromDescriptor(nt.type); - if(t == null) throw new ClassGen.ClassReadExn("invalid type descriptor"); - return new FieldRef((Type.Object)e1.key(), nt.name, t); + Type t = Type.instance(nt.type); + if(t == null) throw new ClassFile.ClassReadExn("invalid type descriptor"); + return ((Type.Class)e1.key()).field(nt.name, t); } case 10: case 11: { NameAndTypeKey nt = (NameAndTypeKey) e2.key(); if (e1.key() == null) throw new Error(e1.tag + " => " + e1.key()); - return new MethodRef((Type.Object)e1.key(), "methodname", Type.VOID, new Type[0]); // FIXME FIXME + return ((Type.Class)e1.key()).method("methodname", Type.VOID, new Type[0]); // FIXME FIXME } case 12: { return new NameAndTypeKey(((Utf8Ent)e1).s, ((Utf8Ent)e2).s); @@ -108,9 +104,9 @@ class CPGen { } } - static class Utf8Ent extends Ent { + class Utf8Ent extends Ent { String s; - Utf8Ent(CPGen owner) { super(owner, 1); } + Utf8Ent() { super(1); } String debugToString() { return s; } void dump(DataOutput o) throws IOException { super.dump(o); o.writeUTF(s); } Object key() { @@ -164,9 +160,9 @@ class CPGen { return ent.n; } - public final Type getType(int index) throws ClassGen.ClassReadExn { + public final Type getType(int index) throws ClassFile.ClassReadExn { Ent e = getByIndex(index); - if (e instanceof Utf8Ent) return Type.fromDescriptor(((Utf8Ent)e).s); + if (e instanceof Utf8Ent) return Type.instance(((Utf8Ent)e).s); else return (Type)e.key(); } @@ -181,7 +177,8 @@ class CPGen { public final Ent addNameAndType(String name, String descriptor) { return add(new NameAndTypeKey(name, descriptor)); } public final Ent addUtf8(String s) { return add(new Utf8Key(s)); } - public final Ent add(Object o) { + public final Ent add(Object o) { return add(o, false); } + public final Ent add(Object o, boolean invokeInterface) { if(state == SEALED) throw new IllegalStateException("constant pool is sealed"); Ent ent = get(o); @@ -190,54 +187,48 @@ class CPGen { return ent; } - if(o instanceof Type.Object) { - CPRefEnt ce = new CPRefEnt(this, 7); - ce.e1 = addUtf8(((Type.Object)o).internalForm()); + if(o instanceof Type.Class) { + CPRefEnt ce = new CPRefEnt(7); + ce.e1 = addUtf8(((Type.Class)o).internalForm()); ent = ce; } else if(o instanceof String) { - CPRefEnt ce = new CPRefEnt(this, 8); + CPRefEnt ce = new CPRefEnt(8); ce.e1 = addUtf8((String)o); ent = ce; - } else if(o instanceof Integer) { - IntEnt ue = new IntEnt(this, 3); - ue.i = ((Integer)o).intValue(); - ent = ue; - } else if(o instanceof Float) { - IntEnt ue = new IntEnt(this, 4); - ue.i = Float.floatToIntBits(((Float)o).floatValue()); - ent = ue; + } else if(o instanceof Integer) { ent = new IntEnt(((Integer)o).intValue()); + } else if(o instanceof Float) { ent = new FloatEnt(((Float)o).floatValue()); } else if(o instanceof Long) { - LongEnt le = new LongEnt(this, 5); + LongEnt le = new LongEnt(5); le.l = ((Long)o).longValue(); ent = le; } else if(o instanceof Double) { - LongEnt le = new LongEnt(this, 6); + LongEnt le = new LongEnt(6); le.l = Double.doubleToLongBits(((Double)o).doubleValue()); ent = le; } else if(o instanceof Utf8Key) { - Utf8Ent ue = new Utf8Ent(this); + Utf8Ent ue = new Utf8Ent(); ue.s = ((Utf8Key)o).s; ent = ue; } else if(o instanceof NameAndTypeKey) { - CPRefEnt ce = new CPRefEnt(this, 12); + CPRefEnt ce = new CPRefEnt(12); NameAndTypeKey key = (NameAndTypeKey) o; ce.e1 = addUtf8(key.name); ce.e2 = addUtf8(key.type); ent = ce; - } else if(o instanceof ClassGen.FieldOrMethodRef) { - ClassGen.FieldOrMethodRef key = (ClassGen.FieldOrMethodRef) o; - int tag = o instanceof FieldRef ? 9 : o instanceof MethodRef ? 10 : o instanceof MethodRef.I ? 11 : 0; + } else if(o instanceof Type.Class.Member) { + Type.Class.Member key = (Type.Class.Member) o; + int tag = invokeInterface ? 11 : o instanceof Type.Class.Field ? 9 : o instanceof Type.Class.Method ? 10 : 0; if(tag == 0) throw new Error("should never happen"); - CPRefEnt ce = new CPRefEnt(this, tag); - ce.e1 = add(key.klass); - ce.e2 = addNameAndType(key.name, key.descriptor); + CPRefEnt ce = new CPRefEnt(tag); + ce.e1 = add(key.getDeclaringClass()); + ce.e2 = addNameAndType(key.name, key.getDescriptor()); ent = ce; } else { throw new IllegalArgumentException("Unknown type passed to add"); } int spaces = ent instanceof LongEnt ? 2 : 1; - if(usedSlots + spaces > 65536) throw new ClassGen.Exn("constant pool full"); + if(usedSlots + spaces > 65536) throw new ClassFile.Exn("constant pool full"); ent.n = state == OPEN ? 1 : usedSlots; // refcount or index @@ -319,9 +310,9 @@ class CPGen { } } - CPGen(DataInput in) throws ClassGen.ClassReadExn, IOException { + CPGen(DataInput in) throws ClassFile.ClassReadExn, IOException { usedSlots = in.readUnsignedShort(); - if(usedSlots==0) throw new ClassGen.ClassReadExn("invalid used slots"); + if(usedSlots==0) throw new ClassFile.ClassReadExn("invalid used slots"); // these are to remember the CPRefEnt e1 and e2s we have to fix up int[] e1s = new int[usedSlots]; @@ -335,41 +326,45 @@ class CPGen { switch(tag) { case 7: // Object Type case 8: // String - case 9: // FieldRef - case 10: // MethodRef + case 9: // Type.Class.Field + case 10: // Type.Class.Method case 11: // Instance Method Ref case 12: // NameAndType { - e = new CPRefEnt(this, tag); + e = new CPRefEnt(tag); e1s[index] = in.readUnsignedShort(); if(tag != 7 && tag != 8) e2s[index] = in.readUnsignedShort(); break; } case 3: // Integer + { + FloatEnt ie; + e = ie = new FloatEnt(in.readFloat()); + break; + } case 4: // Float { IntEnt ie; - e = ie = new IntEnt(this, tag); - ie.i = in.readInt(); + e = ie = new IntEnt(in.readInt()); break; } case 5: // Long case 6: // Double { LongEnt le; - e = le = new LongEnt(this, tag); + e = le = new LongEnt(tag); le.l = in.readLong(); break; } case 1: // Utf8 { Utf8Ent ue; - e = ue = new Utf8Ent(this); + e = ue = new Utf8Ent(); ue.s = in.readUTF(); break; } default: - throw new ClassGen.ClassReadExn("invalid cp ent tag"); + throw new ClassFile.ClassReadExn("invalid cp ent tag"); } entriesByIndex[index] = e; if (e instanceof LongEnt) index++; @@ -385,30 +380,30 @@ class CPGen { } if (!(e instanceof CPRefEnt)) continue; CPRefEnt ce = (CPRefEnt) e; - if(e1s[i] == 0 || e1s[i] >= usedSlots) throw new ClassGen.ClassReadExn("invalid cp index"); + if(e1s[i] == 0 || e1s[i] >= usedSlots) throw new ClassFile.ClassReadExn("invalid cp index"); ce.e1 = entriesByIndex[e1s[i]]; - if(ce.e1 == null) throw new ClassGen.ClassReadExn("invalid cp index"); + if(ce.e1 == null) throw new ClassFile.ClassReadExn("invalid cp index"); if(ce.tag != 7 && ce.tag != 8) { - if(e2s[i] == 0 || e2s[i] >= usedSlots) throw new ClassGen.ClassReadExn("invalid cp index"); + if(e2s[i] == 0 || e2s[i] >= usedSlots) throw new ClassFile.ClassReadExn("invalid cp index"); ce.e2 = entriesByIndex[e2s[i]]; - if(ce.e2 == null) throw new ClassGen.ClassReadExn("invalid cp index"); + if(ce.e2 == null) throw new ClassFile.ClassReadExn("invalid cp index"); } switch(ce.tag) { case 7: case 8: - if(!(ce.e1 instanceof Utf8Ent)) throw new ClassGen.ClassReadExn("expected a utf8 ent"); + if(!(ce.e1 instanceof Utf8Ent)) throw new ClassFile.ClassReadExn("expected a utf8 ent"); break; case 9: case 10: case 11: if(!(ce.e1 instanceof CPRefEnt) || ((CPRefEnt)ce.e1).tag != 7) - throw new ClassGen.ClassReadExn("expected a type ent"); + throw new ClassFile.ClassReadExn("expected a type ent"); if(!(ce.e2 instanceof CPRefEnt) || ((CPRefEnt)ce.e2).tag != 12) - throw new ClassGen.ClassReadExn("expected a name and type ent"); + throw new ClassFile.ClassReadExn("expected a name and type ent"); break; case 12: - if(!(ce.e1 instanceof Utf8Ent)) throw new ClassGen.ClassReadExn("expected a utf8 ent"); - if(!(ce.e2 instanceof Utf8Ent)) throw new ClassGen.ClassReadExn("expected a utf8 ent"); + if(!(ce.e1 instanceof Utf8Ent)) throw new ClassFile.ClassReadExn("expected a utf8 ent"); + if(!(ce.e2 instanceof Utf8Ent)) throw new ClassFile.ClassReadExn("expected a utf8 ent"); break; } }