X-Git-Url: http://git.megacz.com/?p=org.ibex.classgen.git;a=blobdiff_plain;f=src%2Forg%2Fibex%2Fclassgen%2FType.java;h=492986dab2da4f6fd4ba70ff17098f6e27b3db30;hp=0a35c653fecb9e72fbe8c6093ec8e62325f06c66;hb=76a1336320be6b7dbae29acd341659ed648f9487;hpb=be231cfa8ce0eac52873b9f0f82b8aecca9c458a diff --git a/src/org/ibex/classgen/Type.java b/src/org/ibex/classgen/Type.java index 0a35c65..492986d 100644 --- a/src/org/ibex/classgen/Type.java +++ b/src/org/ibex/classgen/Type.java @@ -3,7 +3,7 @@ package org.ibex.classgen; import java.util.StringTokenizer; import java.util.Hashtable; -public class Type { +public class Type implements CGConst { private static Hashtable instances = new Hashtable(); // this has to appear at the top of the file @@ -19,34 +19,40 @@ public class Type { public static final Type CHAR = new Type("C", "char"); public static final Type SHORT = new Type("S", "short"); - public static final Type.Object OBJECT = new Type.Object("java.lang.Object"); - public static final Type.Object STRING = new Type.Object("java.lang.String"); - public static final Type.Object STRINGBUFFER = new Type.Object("java.lang.StringBuffer"); - public static final Type.Object INTEGER_OBJECT = new Type.Object("java.lang.Integer"); - public static final Type.Object DOUBLE_OBJECT = new Type.Object("java.lang.Double"); - public static final Type.Object FLOAT_OBJECT = new Type.Object("java.lang.Float"); + public static final Type.Class OBJECT = new Type.Class("java.lang.Object"); + public static final Type.Class STRING = new Type.Class("java.lang.String"); + public static final Type.Class STRINGBUFFER = new Type.Class("java.lang.StringBuffer"); + public static final Type.Class INTEGER_OBJECT = new Type.Class("java.lang.Integer"); + public static final Type.Class DOUBLE_OBJECT = new Type.Class("java.lang.Double"); + public static final Type.Class FLOAT_OBJECT = new Type.Class("java.lang.Float"); /** A zero element Type[] array (can be passed as the "args" param when a method takes no arguments */ public static final Type[] NO_ARGS = new Type[0]; /** guarantee: there will only be one instance of Type for a given descriptor ==> equals() and == are interchangeable */ - public static Type fromDescriptor(String d) { + public static Type instance(String d) { Type ret = (Type)instances.get(d); if (ret != null) return ret; - if (d.endsWith("[")) return new Type.Array(fromDescriptor(d.substring(d.length()-1))); - return new Type.Object(d); + if (d.startsWith("[")) return new Type.Array(instance(d.substring(1))); + return new Type.Class(d); } public String toString() { return toString; } + public String debugToString() { return toString; } public final String getDescriptor() { return descriptor; } public int hashCode() { return descriptor.hashCode(); } public boolean equals(java.lang.Object o) { return this==o; } - public Type.Object asObject() { throw new RuntimeException("attempted to use "+this+" as a Type.Object, which it is not"); } - public Type.Array asArray() { throw new RuntimeException("attempted to use "+this+" as a Type.Array, which it is not"); } - public Type.Array makeArray() { return new Type.Array(this); } - public boolean isObject() { return false; } - public boolean isArray() { return false; } + public Type.Array makeArray() { return (Type.Array)instance("["+descriptor); } + public Type.Array makeArray(int i) { return i==0 ? (Type.Array)this : makeArray().makeArray(i-1); } + + public Type.Ref asRef() { throw new RuntimeException("attempted to use "+this+" as a Type.Ref, which it is not"); } + public Type.Class asClass() { throw new RuntimeException("attempted to use "+this+" as a Type.Class, which it is not"); } + public Type.Array asArray() { throw new RuntimeException("attempted to use "+this+" as a Type.Array, which it is not"); } + public boolean isPrimitive() { return !isRef(); } + public boolean isRef() { return false; } + public boolean isClass() { return false; } + public boolean isArray() { return false; } // Protected/Private ////////////////////////////////////////////////////////////////////////////// @@ -58,12 +64,25 @@ public class Type { instances.put(this.descriptor = descriptor, this); } - /** Class representing Object types (any non-primitive type) */ - public static class Object extends Type { - protected Object(String s) { super(_initHelper(s), _initHelper2(s)); } - protected Object(String descriptor, String hr) { super(_initHelper(descriptor), _initHelper2(hr)); } - public Type.Object asObject() { return this; } - public boolean isObject() { return true; } + public static class Ref extends Type { + protected Ref(String descriptor) { super(descriptor); } + protected Ref(String descriptor, String humanReadable) { super(descriptor, humanReadable); } + public Type.Ref asRef() { return this; } + public boolean isRef() { return true; } + } + + public static class Array extends Type.Ref { + protected Array(Type t) { super("[" + t.getDescriptor(), t.toString() + "[]"); } + public Type.Array asArray() { return this; } + public boolean isArray() { return true; } + public int dimension() { return getDescriptor().lastIndexOf('['); } + public Type getElementType() { return Type.instance(getDescriptor().substring(0, getDescriptor().length()-1)); } + } + + public static class Class extends Type.Ref { + protected Class(String s) { super(_initHelper(s), _initHelper2(s)); } + public Type.Class asClass() { return this; } + public boolean isClass() { return true; } public String getShortName() { return toString.substring(toString.lastIndexOf('.')+1); } String internalForm() { return descriptor.substring(1, descriptor.length()-1); } private static String _initHelper(String s) { @@ -80,14 +99,129 @@ public class Type { for(int i=0;st.hasMoreTokens();i++) a[i] = st.nextToken(); return a; } - } - public static class Array extends Type.Object { - protected Array(Type t) { super(t.getDescriptor() + "[", t.toString() + "[]"); } - public Type.Array asArray() { return this; } - public boolean isArray() { return true; } - public int dimension() { return descriptor.length() - descriptor.indexOf('['); } - String[] components() { throw new Error("Type.Array does not have components()"); } + public Field field(String name, Type type) { return new Field(name, type); } + public Method method(String name, Type returnType, Type[] argTypes) { return new Method(name, returnType, argTypes); } + public Method method(String signature) { + // FEATURE: This parser is ugly but it works (and shouldn't be a problem) might want to clean it up though + String s = signature; + String name = s.startsWith("(") ? "" : s.substring(0, s.indexOf('(')); + s = s.substring(s.indexOf('(')); + int p = s.indexOf(')'); + if(p == -1) throw new IllegalArgumentException("invalid method type descriptor"); + String argsDesc = s.substring(1,p); + String retDesc = s.substring(p+1); + Type[] argsBuf = new Type[argsDesc.length()]; + int i; + for(i=0,p=0;argsDesc.length() > 0;i++,p=0) { + while(p < argsDesc.length() && argsDesc.charAt(p) == '[') p++; + if(p == argsDesc.length()) throw new IllegalArgumentException("invalid method type descriptor"); + if(argsDesc.charAt(p) == 'L') { + p = argsDesc.indexOf(';'); + if(p == -1) throw new IllegalArgumentException("invalid method type descriptor"); + } + argsBuf[i] = Type.instance(argsDesc.substring(0,p+1)); + argsDesc = argsDesc.substring(p+1); + } + Type args[] = new Type[i]; + System.arraycopy(argsBuf,0,args,0,i); + return method(name, Type.instance(retDesc), args); + } + + public abstract class Member { + public final String name; + private Member(String name) { this.name = name; } + public Type.Class getDeclaringClass() { return Type.Class.this; } + public abstract String getDescriptor(); + public boolean equals(Object o_) { + if(!(o_ instanceof Member)) return false; + Member o = (Member) o_; + return o.getDeclaringClass().equals(getDeclaringClass()) && + o.name.equals(name) && + o.getDescriptor().equals(getDescriptor()); + } + public int hashCode() { return getDeclaringClass().hashCode() ^ name.hashCode() ^ getDescriptor().hashCode(); } + public String toString() { return debugToString(); } + public abstract String debugToString(); + } + + public class Field extends Member { + public final Type type; + private Field(String name, Type t) { super(name); this.type = t; } + public String getDescriptor() { return name; } + public Type getType() { return type; } + public String debugToString() { return getDeclaringClass()+"."+name+"["+type+"]"; } + } + + public class Method extends Member { + final Type[] argTypes; + public final Type returnType; + public Type getArgType(int i) { return argTypes[i]; } + public int getNumArgs() { return argTypes.length; } + public Type getReturnType() { return returnType; } + public String debugToString() { + StringBuffer sb = new StringBuffer(); + if (name.equals("")) sb.append("static "); + else { + if (name.equals("")) + sb.append(Class.this.getShortName()); + else + sb.append(returnType).append(" ").append(name); + sb.append("("); + for(int i=0; i 0) { + sb.append("throws"); + for(java.util.Enumeration e = thrownExceptions.keys();e.hasMoreElements();) + sb.append(" ").append(((Type.Class)e.nextElement()).debugToString()).append(","); + sb.setLength(sb.length()-1); + sb.append(" "); + } + if ((flags & (NATIVE|ABSTRACT))==0) { + sb.append("{\n"); + debugBodyToString(sb); + sb.append(" }\n"); + } else { + sb.append(";"); + } + } + } + } + } + + // FEATURE: This probably isn't the best place for these + static String methodTypeDescriptor(Type[] argTypes, Type returnType) { + StringBuffer sb = new StringBuffer(argTypes.length*4); + sb.append("("); + for(int i=0;i