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=84c934325714583536082483a51ca22d94797632;hb=76a1336320be6b7dbae29acd341659ed648f9487;hpb=20b36057bc5aee6e799cce02a3bf289916889fc1 diff --git a/src/org/ibex/classgen/Type.java b/src/org/ibex/classgen/Type.java index 84c9343..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 @@ -38,11 +38,13 @@ public class Type { } 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.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"); } @@ -69,6 +71,14 @@ public class Type { 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; } @@ -89,13 +99,129 @@ public class Type { for(int i=0;st.hasMoreTokens();i++) a[i] = st.nextToken(); return a; } - } - 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 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