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=25f22beccf1cf53d272efae836795f60632f33a9;hb=69b2d27ebab56f1b0e4df2a3a301f4d852439e8e;hpb=cd0ae78576749ddda5d9dfda5b9e88dd78fda0c9

diff --git a/src/org/ibex/classgen/CPGen.java b/src/org/ibex/classgen/CPGen.java
index 25f22be..edc4d9c 100644
--- a/src/org/ibex/classgen/CPGen.java
+++ b/src/org/ibex/classgen/CPGen.java
@@ -17,40 +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 e0;
         
-        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) {
@@ -72,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()) + "]"; }
         
@@ -86,31 +81,37 @@ class CPGen {
         }
         
         private String fixme() { throw new Error("fixme"); }
-        Object key() throws ClassGen.ClassReadExn {
+        Object key() throws ClassFile.ClassReadExn {
             switch(tag) {
-                case 7: return new Type.Object(((Utf8Ent)e0).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 10: case 11: {
                     NameAndTypeKey nt = (NameAndTypeKey) e2.key();
-                    return new MethodRef((Type.Object)e1.key(), fixme(), null, null);
+                    if (e1.key() == null) throw new Error(e1.tag + " => " + e1.key());
+                    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); 
                 }
             }
-            throw new Error("FIXME");
+            throw new Error("FIXME " + tag);
         }
     }
         
-    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() { throw new Error("Brian is lame"); }
+        Object key() {
+            return s;
+        }
     }
     
     /*
@@ -146,6 +147,9 @@ class CPGen {
         if(e == null) throw new IllegalStateException("entry not found");
         return getIndex(e);
     }
+    public final String getUtf8ByIndex(int i) {
+        return ((Utf8Ent)getByIndex(i)).s;
+    }
     public final int getUtf8Index(String s) {
         Ent e = getUtf8(s);
         if(e == null) throw new IllegalStateException("entry not found");
@@ -156,7 +160,11 @@ class CPGen {
         return ent.n;
     }
 
-    public final Type.Object getType(int index) { return new Type.Object(((Utf8Ent)getByIndex(index)).s); }
+    public final Type getType(int index) throws ClassFile.ClassReadExn {
+        Ent e = getByIndex(index);
+        if (e instanceof Utf8Ent) return Type.instance(((Utf8Ent)e).s);
+        else return (Type)e.key();
+    }
 
     public final Ent getByIndex(int index) {
         if(state < STABLE) throw new IllegalStateException("constant pool is not stable");
@@ -166,10 +174,11 @@ class CPGen {
         return e;
     }
     
-    public final Ent addNameAndType(String name, String descriptor) { return add(new NameAndTypeKey(name,descriptor)); }
+    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);
@@ -178,60 +187,54 @@ 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
 
         usedSlots += spaces;        
 
-        entries.put(o,ent);
+        entries.put(o, ent);
         return ent;
     }
     
@@ -281,7 +284,7 @@ class CPGen {
     public void optimize() {
         if(state != OPEN) throw new IllegalStateException("can't optimize a stable constant pool");
         Ent[] ents = asArray();
-        Sort.sort(ents,reverseCompareFunc);
+        Sort.sort(ents, reverseCompareFunc);
         state = STABLE;
         assignIndex(ents);
     }
@@ -299,7 +302,7 @@ class CPGen {
     
     public void dump(DataOutput o) throws IOException {
         Ent[] ents = asArray();
-        Sort.sort(ents,compareFunc);
+        Sort.sort(ents, compareFunc);
         o.writeShort(usedSlots);
         for(int i=0;i<ents.length;i++) {
             //System.err.println("" + ents[i].n + ": " + ents[i].debugToString());
@@ -307,12 +310,11 @@ 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 e0 and e1s we have to fix up
-        int[] e0s = new int[usedSlots];
+        // these are to remember the CPRefEnt e1 and e2s we have to fix up
         int[] e1s = new int[usedSlots];
         int[] e2s = new int[usedSlots];
         
@@ -324,81 +326,91 @@ 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);
-                    e1s[index] = in.readUnsignedShort();;
+                    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();
-                    index++;
                     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++;
         }
         
         for(int index=1;index<usedSlots;index++) {
             int i = index;
             Ent e = entriesByIndex[index];
-            if(e == null) throw new Error("should never happen");
-            if(e instanceof CPRefEnt) {
-                CPRefEnt ce = (CPRefEnt) e;
-                if(e0s[i] == 0 || e0s[i] >= usedSlots) throw new ClassGen.ClassReadExn("invalid cp index");
-                ce.e0 = entriesByIndex[e0s[i]];
-                if(ce.e0 == null)  throw new ClassGen.ClassReadExn("invalid cp index");
-                if(ce.tag != 7 && ce.tag != 8) {
-                    if(e1s[i] == 0 || e1s[i] >= usedSlots) throw new ClassGen.ClassReadExn("invalid cp index");
-                    ce.e1 = entriesByIndex[e1s[i]];
-                    if(ce.e1 == null)  throw new ClassGen.ClassReadExn("invalid cp index");
-                }
-                switch(ce.tag) {
-                    case 7:
-                    case 8:
-                        if(!(ce.e0 instanceof Utf8Ent)) throw new ClassGen.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");
-                        if(!(ce.e2 instanceof CPRefEnt) || ((CPRefEnt)ce.e2).tag != 12)
-                            throw new ClassGen.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");
-                }
-            } else if(e instanceof LongEnt) {
+            if (e == null) throw new Error("should never happen: " + i + "/"+usedSlots);
+            if (e instanceof LongEnt) {
                 index++;
+                continue;
             }
-            entries.put(e.key(),e);
+            if (!(e instanceof CPRefEnt)) continue;
+            CPRefEnt ce = (CPRefEnt) e;
+            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 ClassFile.ClassReadExn("invalid cp index");
+            if(ce.tag != 7 && ce.tag != 8) {
+                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 ClassFile.ClassReadExn("invalid cp index");
+            }
+            switch(ce.tag) {
+                case 7:
+                case 8:
+                    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 ClassFile.ClassReadExn("expected a type ent");
+                    if(!(ce.e2 instanceof CPRefEnt) || ((CPRefEnt)ce.e2).tag != 12)
+                        throw new ClassFile.ClassReadExn("expected a name and type ent");
+                    break;
+                case 12:
+                    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;
+            }
+        }
+        for(int i=1; i<usedSlots; i++) {
+            Ent e = entriesByIndex[i];
+            entries.put(e.key(), e);
+            if (e instanceof LongEnt) i++;
         }
         state = STABLE;
     }