* * It encapsulates an Java type signature and it provides * quick access to the components of the type. Note that * all types are hashed into a hashtable (typeHash), that * means that each distinct type is only allocated once, * saving space and making equality checks cheap.
*
* For simple types use the constants defined in this class.
* (Type.tInt, Type.tShort, ...). To create complex types use
* the static methods Type.tArray, Type.tMethod or Type.tClass.
*
* For classes, arrays and method types a sub class of class
* type is created which defines the extra type components.
*
* WARNING: The contents of this source file are not part of any
* supported API. Code that depends on them does so at its own risk:
* they are subject to change or removal without notice.
*
* @see ArrayType
* @see ClassType
* @see MethodType
* @author Arthur van Hoff
*/
public
class Type implements Constants {
/**
* This hashtable is used to cache types
*/
private static final Hashtable
* (This is necessary because of an ambiguity between the
* low-level signatures of inner types and their manglings.
* Note that the latter are also valid class names.)
*/
static void changeClassName(Identifier oldName, Identifier newName) {
// Note: If we are upgrading "pkg.Foo$Bar" to "pkg.Foo. Bar",
// we assume someone else will come along and deal with any types
// inner within Bar. So, there's only one change to make.
((ClassType)Type.tClass(oldName)).className = newName;
}
/**
* Create a method type with no arguments.
*/
public static synchronized Type tMethod(Type ret) {
return tMethod(ret, noArgs);
}
/**
* Create a method type with arguments.
*/
public static synchronized Type tMethod(Type returnType, Type argTypes[]) {
StringBuilder sb = new StringBuilder();
sb.append(SIG_METHOD);
for (int i = 0 ; i < argTypes.length ; i++) {
sb.append(argTypes[i].getTypeSignature());
}
sb.append(SIG_ENDMETHOD);
sb.append(returnType.getTypeSignature());
String sig = sb.toString();
Type t = typeHash.get(sig);
if (t == null) {
t = new MethodType(sig, returnType, argTypes);
}
return t;
}
/**
* Return the return type. Only works for method types.
*/
public Type getReturnType() {
throw new CompilerError("getReturnType");
}
/**
* Return the argument types. Only works for method types.
*/
public Type[] getArgumentTypes() {
throw new CompilerError("getArgumentTypes");
}
/**
* Create a Type from an Java type signature.
* @exception CompilerError invalid type signature.
*/
public static synchronized Type tType(String sig) {
Type t = typeHash.get(sig);
if (t != null) {
return t;
}
switch (sig.charAt(0)) {
case SIGC_ARRAY:
return Type.tArray(tType(sig.substring(1)));
case SIGC_CLASS:
return Type.tClass(Identifier.lookup(sig.substring(1, sig.length() - 1).replace(SIGC_PACKAGE, '.')));
case SIGC_METHOD: {
Type argv[] = new Type[8];
int argc = 0;
int i, j;
for (i = 1 ; sig.charAt(i) != SIGC_ENDMETHOD ; i = j) {
for (j = i ; sig.charAt(j) == SIGC_ARRAY ; j++);
if (sig.charAt(j++) == SIGC_CLASS) {
while (sig.charAt(j++) != SIGC_ENDCLASS);
}
if (argc == argv.length) {
Type newargv[] = new Type[argc * 2];
System.arraycopy(argv, 0, newargv, 0, argc);
argv = newargv;
}
argv[argc++] = tType(sig.substring(i, j));
}
Type argtypes[] = new Type[argc];
System.arraycopy(argv, 0, argtypes, 0, argc);
return Type.tMethod(tType(sig.substring(i + 1)), argtypes);
}
}
throw new CompilerError("invalid TypeSignature:" + sig);
}
/**
* Check if the type arguments are the same.
* @return true if both types are method types and the
* argument types are identical.
*/
public boolean equalArguments(Type t) {
return false;
}
/**
* Return the amount of space this type takes up on the
* Java operand stack. For a method this is equal to the
* total space taken up by the arguments.
*/
public int stackSize() {
switch (typeCode) {
case TC_ERROR:
case TC_VOID:
return 0;
case TC_BOOLEAN:
case TC_BYTE:
case TC_SHORT:
case TC_CHAR:
case TC_INT:
case TC_FLOAT:
case TC_ARRAY:
case TC_CLASS:
return 1;
case TC_LONG:
case TC_DOUBLE:
return 2;
}
throw new CompilerError("stackSize " + toString());
}
/**
* Return the type code offset. This offset can be added to
* an opcode to get the right opcode type. Most opcodes
* are ordered: int, long, float, double, array. For
* example: iload, lload fload, dload, aload. So the
* appropriate opcode is iadd + type.getTypeCodeOffset().
*/
public int getTypeCodeOffset() {
switch (typeCode) {
case TC_BOOLEAN:
case TC_BYTE:
case TC_SHORT:
case TC_CHAR:
case TC_INT:
return 0;
case TC_LONG:
return 1;
case TC_FLOAT:
return 2;
case TC_DOUBLE:
return 3;
case TC_NULL:
case TC_ARRAY:
case TC_CLASS:
return 4;
}
throw new CompilerError("invalid typecode: " + typeCode);
}
/**
* Convert a Type to a string, if abbrev is true class names are
* not fully qualified, if ret is true the return type is included.
*/
public String typeString(String id, boolean abbrev, boolean ret) {
String s = null;
switch (typeCode) {
case TC_NULL: s = "null"; break;
case TC_VOID: s = "void"; break;
case TC_BOOLEAN: s = "boolean"; break;
case TC_BYTE: s = "byte"; break;
case TC_CHAR: s = "char"; break;
case TC_SHORT: s = "short"; break;
case TC_INT: s = "int"; break;
case TC_LONG: s = "long"; break;
case TC_FLOAT: s = "float"; break;
case TC_DOUBLE: s = "double"; break;
case TC_ERROR: s = "