X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;ds=sidebyside;f=src%2Forg%2Fibex%2Fclassgen%2FType.java;h=d61df3e470a6d9bde0ab0e4b8c3cb95b342f993a;hb=HEAD;hp=44e6476869d6794e3cefe094a4b35c03c8f4c0bc;hpb=5d8b492b2c284a96c9055a8d89bfac5bec7d09d5;p=org.ibex.classgen.git

diff --git a/src/org/ibex/classgen/Type.java b/src/org/ibex/classgen/Type.java
index 44e6476..d61df3e 100644
--- a/src/org/ibex/classgen/Type.java
+++ b/src/org/ibex/classgen/Type.java
@@ -10,14 +10,15 @@ public abstract class Type implements CGConst {
     // Public API //////////////////////////////////////////////////////////////////////////////
 
     public static final Type VOID = new Primitive("V", "void");
-    public static final Type INT = new Primitive("I", "int");
-    public static final Type LONG = new Primitive("J", "long");
-    public static final Type BOOLEAN = new Primitive("Z", "boolean");
-    public static final Type DOUBLE = new Primitive("D", "double");
-    public static final Type FLOAT = new Primitive("F", "float");
-    public static final Type BYTE = new Primitive("B", "byte");
-    public static final Type CHAR = new Primitive("C", "char");
-    public static final Type SHORT = new Primitive("S", "short");
+    public static final Type INT = new Primitive("I", "int", 10);
+    public static final Type LONG = new Primitive("J", "long", 11);
+    public static final Type BOOLEAN = new Primitive("Z", "boolean", 4);
+    public static final Type DOUBLE = new Primitive("D", "double", 7);
+    public static final Type FLOAT = new Primitive("F", "float", 6);
+    public static final Type BYTE = new Primitive("B", "byte", 8);
+    public static final Type CHAR = new Primitive("C", "char", 5);
+    public static final Type SHORT = new Primitive("S", "short", 9);
+    public static final Type NULL = new Null();
     
     public static final Type.Class OBJECT = Type.Class.instance("java.lang.Object");
     public static final Type.Class STRING = Type.Class.instance("java.lang.String");
@@ -40,9 +41,6 @@ public abstract class Type implements CGConst {
         return new Type.Class(d);
     }
 
-    public final String  toString() { return super.toString(); }
-    public abstract String debugToString();
-    
     public final String  getDescriptor() { return descriptor; }
 
     public Type.Array  makeArray() { return (Type.Array)Type.fromDescriptor("["+descriptor); }
@@ -56,6 +54,30 @@ public abstract class Type implements CGConst {
     public boolean     isClass()     { return false; }
     public boolean     isArray()     { return false; }
 
+    public static Type unify(Type t1, Type t2) {
+        if(t1 == Type.NULL) return t2;
+        if(t2 == Type.NULL) return t1;
+        if((t1 == Type.INT && t2 == Type.BOOLEAN) || (t2 == Type.INT & t1 == Type.BOOLEAN)) return Type.BOOLEAN;
+        if(t1 == t2) return t1;
+        // FIXME: This needs to do a lot more (subclasses, etc)
+        // it probably should be in Context.java
+        return null;
+    }
+
+    public static Type fromArraySpec(int i) {
+        switch(i) {
+            case 4: return Type.BOOLEAN;
+            case 5: return Type.CHAR;
+            case 6: return Type.FLOAT;
+            case 7: return Type.DOUBLE;
+            case 8: return Type.BYTE;
+            case 9: return Type.SHORT;
+            case 10: return Type.INT;
+            case 11: return Type.LONG;
+            default: throw new IllegalStateException("invalid array type");
+        }
+    }
+    
     // Protected/Private //////////////////////////////////////////////////////////////////////////////
 
     protected final String descriptor;
@@ -64,22 +86,34 @@ public abstract class Type implements CGConst {
         this.descriptor = descriptor;
         instances.put(descriptor, this);
     }
+    
+    public static class Null extends Type {
+        protected Null() { super(""); } // not really correct....
+    }
 
     public static class Primitive extends Type {
         private String humanReadable;
-        Primitive(String descriptor, String humanReadable) {
+        private int arraySpec;
+        Primitive(String descriptor, String humanReadable) { this(descriptor, humanReadable, -1); }
+        Primitive(String descriptor, String humanReadable, int arraySpec) {
             super(descriptor);
             this.humanReadable = humanReadable;
+            this.arraySpec = arraySpec;
         }
-        public String debugToString() { return humanReadable; }
+        public String toString() { return humanReadable; }
         public boolean     isPrimitive() { return true; }
+        public int toArraySpec() {
+            if (arraySpec < 0) throw new Error("you can't make arrays of " + this);
+            return arraySpec;
+        }
     }
     
     public abstract static class Ref extends Type {
         protected Ref(String descriptor) { super(descriptor); }
-        public abstract String debugToString();
+        public abstract String toString();
         public    Type.Ref asRef() { return this; }
         public    boolean  isRef() { return true; }
+        abstract String internalForm();
     }
 
     public static class Array extends Type.Ref {
@@ -87,8 +121,9 @@ public abstract class Type implements CGConst {
         protected Array(Type t) { super("[" + t.getDescriptor()); base = t; }
         public Type.Array asArray() { return this; }
         public boolean isArray() { return true; }
-        public String debugToString() { return base.debugToString() + "[]"; }
-        public Type getElementType() { return Type.fromDescriptor(getDescriptor().substring(0, getDescriptor().length()-1)); }
+        public String toString() { return base.toString() + "[]"; }
+        public Type getElementType() { return base; }
+        String internalForm() { return getDescriptor(); }
     }
 
     public static class Class extends Type.Ref {
@@ -111,14 +146,14 @@ public abstract class Type implements CGConst {
             return cf.superType.extendsOrImplements(c, cx);
         }
         String internalForm() { return descriptor.substring(1, descriptor.length()-1); }
-        public String debugToString() { return internalForm().replace('/','.'); }
+        public String toString() { return internalForm().replace('/','.'); }
         public String getName() { return internalForm().replace('/','.'); }
         public String getShortName() {
             int p = descriptor.lastIndexOf('/');
             return p == -1 ? descriptor.substring(1,descriptor.length()-1) : descriptor.substring(p+1,descriptor.length()-1);
         }
         private static String _initHelper(String s) {
-            if (!s.startsWith("L") || !s.endsWith(";")) s = "L" + s.replace('.', '/') + ";";
+            if (!s.startsWith("L") || !s.endsWith(";")) throw new Error("invalid: " + s);
             return s;
         }
         String[] components() {
@@ -128,9 +163,9 @@ public abstract class Type implements CGConst {
             return a;
         }
 
+        public Type.Class.Body getBody(Context cx) { return cx.resolve(this.getName()); }
         public abstract class Body extends HasAttributes {
             public abstract Type.Class.Method.Body[] methods();
-            public abstract Type.Class.Field.Body addField(Type.Class.Field field, int flags);
             public abstract Type.Class.Field.Body[] fields();
             public Body(int flags, ClassFile.AttrGen attrs) {
                 super(flags, attrs);
@@ -140,15 +175,14 @@ public abstract class Type implements CGConst {
         }
 
         public Field field(String name, Type type) { return new Field(name, type); }
+        public Field field(String name, String descriptor) { return field(name,Type.fromDescriptor(descriptor)); }
 
         public Method method(String name, Type returnType, Type[] argTypes) { return new Method(name, returnType, argTypes); }
-        public Method method(String leftCrap, String rightCrap) { return method(leftCrap+rightCrap); }
 
         /** see JVM Spec section 2.10.2 */
-        public Method method(String signature) {
+        public Method method(String name, String descriptor) {
             // FEATURE: This parser is ugly but it works (and shouldn't be a problem) might want to clean it up though
-            String name = signature.substring(0, signature.indexOf('('));
-            String s = signature.substring(signature.indexOf('('));
+            String s = descriptor;
             if(!s.startsWith("(")) throw new IllegalArgumentException("invalid method type descriptor");
             int p = s.indexOf(')');
             if(p == -1) throw new IllegalArgumentException("invalid method type descriptor");
@@ -177,7 +211,9 @@ public abstract class Type implements CGConst {
             public Type.Class getDeclaringClass() { return Type.Class.this; }
             public String getName() { return name; }
             public abstract String getTypeDescriptor();
-            public abstract String debugToString();
+            public abstract String toString();
+            public abstract int hashCode();
+            public abstract boolean equals(Object o);
         }
     
         public class Field extends Member {
@@ -185,7 +221,7 @@ public abstract class Type implements CGConst {
             private Field(String name, Type t) { super(name); this.type = t; }
             public String getTypeDescriptor() { return type.getDescriptor(); }
             public Type getType() { return type; }
-            public String debugToString() { return getDeclaringClass().debugToString()+"."+name+"["+type.debugToString()+"]"; }
+            public String toString() { return getDeclaringClass().toString()+"."+name+"["+type.toString()+"]"; }
             public class Body extends HasAttributes {
                 public Field getField() { return Field.this; }
                 public Body(int flags, ClassFile.AttrGen attrs) {
@@ -193,6 +229,15 @@ public abstract class Type implements CGConst {
                     if ((flags & ~VALID_FIELD_FLAGS) != 0) throw new IllegalArgumentException("invalid flags");
                 }
             }
+            public int hashCode() {
+                return type.hashCode() ^ name.hashCode() ^ getDeclaringClass().hashCode();
+            }
+            public boolean equals(Object o_) {
+                if(o_ == this) return true;
+                if(!(o_ instanceof Field)) return false;
+                Field o = (Field) o_;
+                return o.getDeclaringClass() == getDeclaringClass() && o.type == type && o.name.equals(name);
+            }
         }
 
         public class Method extends Member {
@@ -208,17 +253,18 @@ public abstract class Type implements CGConst {
             }
             public boolean isConstructor() { return getName().equals("<init>"); }
             public boolean isClassInitializer() { return getName().equals("<clinit>"); }
-            public String debugToString() {
+            
+            public String toString() {
                 StringBuffer sb = new StringBuffer();
                 if (name.equals("<clinit>")) sb.append("static ");
                 else {
                     if (name.equals("<init>"))
                         sb.append(Class.this.getShortName());
                     else
-                        sb.append(returnType.debugToString()).append(".").append(name);
+                        sb.append(returnType.toString()).append(" ").append(name);
                     sb.append("(");
                     for(int i=0; i<argTypes.length; i++)
-                        sb.append((i==0?"":", ")+argTypes[i].debugToString());
+                        sb.append((i==0?"":", ")+argTypes[i].toString());
                     sb.append(") ");
                 }
                 return sb.toString();
@@ -245,15 +291,16 @@ public abstract class Type implements CGConst {
                     super(flags, attrs);
                     if ((flags & ~VALID_METHOD_FLAGS) != 0) throw new IllegalArgumentException("invalid flags");
                 }
-                public void debugToString(StringBuffer sb, String constructorName) {
+                public boolean isConcrete() { return !isAbstract() && !isNative() /*FIXME: !inAnInterface*/; }
+                public void toString(StringBuffer sb, String constructorName) {
                     int flags = getFlags();
                     sb.append("  ").append(ClassFile.flagsToString(flags,false));
-                    sb.append(Method.this.debugToString());
+                    sb.append(Method.this.toString());
                     java.util.Hashtable thrownExceptions = getThrownExceptions();
                     if (thrownExceptions.size() > 0) {
                         sb.append("throws");
                         for(java.util.Enumeration e = thrownExceptions.keys();e.hasMoreElements();)
-                            sb.append(" ").append(((Type.Class)e.nextElement()).debugToString()).append(",");
+                            sb.append(" ").append(((Type.Class)e.nextElement()).toString()).append(",");
                         sb.setLength(sb.length()-1);
                         sb.append(" ");
                     }
@@ -266,6 +313,21 @@ public abstract class Type implements CGConst {
                     }
                 }
             }
+            public int hashCode() {
+                int h = returnType.hashCode() ^ name.hashCode() ^ getDeclaringClass().hashCode();
+                for(int i=0;i<argTypes.length;i++) h ^= argTypes[i].hashCode();
+                return h;
+            }
+            public boolean equals(Object o_) {
+                if(o_ == this) return true;
+                if(!(o_ instanceof Method)) return false;
+                Method o = (Method) o_;
+                if(!(o.getDeclaringClass() == getDeclaringClass() && o.returnType == returnType && o.name.equals(name))) return false;
+                if(o.argTypes.length != argTypes.length) return false;
+                for(int i=0;i<argTypes.length;i++)
+                    if(o.argTypes[i] != argTypes[i]) return false;
+                return true;
+            }
         }
     }