/*
* Copyright (c) 1994, 2003, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package sun.tools.java;
import java.util.Hashtable;
/**
* This class represents an Java Type.<p>
*
* 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.<p>
*
* 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 typeHash = new Hashtable(231);
/**
* The TypeCode of this type. The value of this field is one
* of the TC_* contant values defined in Constants.
* @see Constants
*/
protected int typeCode;
/**
* The TypeSignature of this type. This type signature is
* equivalent to the runtime type signatures used by the
* interpreter.
*/
protected String typeSig;
/*
* Predefined types.
*/
public static final Type noArgs[] = new Type[0];
public static final Type tError = new Type(TC_ERROR, "?");
public static final Type tPackage = new Type(TC_ERROR, ".");
public static final Type tNull = new Type(TC_NULL, "*");
public static final Type tVoid = new Type(TC_VOID, SIG_VOID);
public static final Type tBoolean = new Type(TC_BOOLEAN, SIG_BOOLEAN);
public static final Type tByte = new Type(TC_BYTE, SIG_BYTE);
public static final Type tChar = new Type(TC_CHAR, SIG_CHAR);
public static final Type tShort = new Type(TC_SHORT, SIG_SHORT);
public static final Type tInt = new Type(TC_INT, SIG_INT);
public static final Type tFloat = new Type(TC_FLOAT, SIG_FLOAT);
public static final Type tLong = new Type(TC_LONG, SIG_LONG);
public static final Type tDouble = new Type(TC_DOUBLE, SIG_DOUBLE);
public static final Type tObject = Type.tClass(idJavaLangObject);
public static final Type tClassDesc = Type.tClass(idJavaLangClass);
public static final Type tString = Type.tClass(idJavaLangString);
public static final Type tCloneable = Type.tClass(idJavaLangCloneable);
public static final Type tSerializable = Type.tClass(idJavaIoSerializable);
/**
* Create a type given a typecode and a type signature.
*/
protected Type(int typeCode, String typeSig) {
this.typeCode = typeCode;
this.typeSig = typeSig;
typeHash.put(typeSig, this);
}
/**
* Return the Java type signature.
*/
public final String getTypeSignature() {
return typeSig;
}
/**
* Return the type code.
*/
public final int getTypeCode() {
return typeCode;
}
/**
* Return the type mask. The bits in this mask correspond
* to the TM_* constants defined in Constants. Only one bit
* is set at a type.
* @see Constants
*/
public final int getTypeMask() {
return 1 << typeCode;
}
/**
* Check for a certain type.
*/
public final boolean isType(int tc) {
return typeCode == tc;
}
/**
* Check to see if this is the bogus type "array of void"
*
* Although this highly degenerate "type" is not constructable from
* the grammar, the Parser accepts it. Rather than monkey with the
* Parser, we check for the bogus type at specific points and give
* a nice error.
*/
public boolean isVoidArray() {
// a void type is not a void array.
if (!isType(TC_ARRAY)) {
return false;
}
// If this is an array, find out what its element type is.
Type type = this;
while (type.isType(TC_ARRAY))
type = type.getElementType();
return type.isType(TC_VOID);
}
/**
* Check for a certain set of types.
*/
public final boolean inMask(int tm) {
return ((1 << typeCode) & tm) != 0;
}
/**
* Create an array type.
*/
public static synchronized Type tArray(Type elem) {
String sig = new String(SIG_ARRAY + elem.getTypeSignature());
Type t = (Type)typeHash.get(sig);
if (t == null) {
t = new ArrayType(sig, elem);
}
return t;
}
/**
* Return the element type of an array type. Only works
* for array types.
*/
public Type getElementType() {
throw new CompilerError("getElementType");
}
/**
* Return the array dimension. Only works for
* array types.
*/
public int getArrayDimension() {
return 0;
}
/**
* Create a class type.
* @arg className the fully qualified class name
*/
public static synchronized Type tClass(Identifier className) {
if (className.isInner()) {
Type t = tClass(mangleInnerType(className));
if (t.getClassName() != className)
// Somebody got here first with a mangled name.
// (Perhaps it came from a binary.)
changeClassName(t.getClassName(), className);
return t;
}
// see if we've cached the object in the Identifier
if (className.typeObject != null) {
return className.typeObject;
}
String sig =
new String(SIG_CLASS +
className.toString().replace('.', SIGC_PACKAGE) +
SIG_ENDCLASS);
Type t = (Type)typeHash.get(sig);
if (t == null) {
t = new ClassType(sig, className);
}
className.typeObject = t; // cache the Type object in the Identifier
return t;
}
/**
* Return the ClassName. Only works on class types.
*/
public Identifier getClassName() {
throw new CompilerError("getClassName:" + this);
}
/**
* Given an inner identifier, return the non-inner, mangled
* representation used to manage signatures.
*
* Note: It is changed to 'public' for Jcov file generation.
* (see Assembler.java)
*/
public static Identifier mangleInnerType(Identifier className) {
// Map "pkg.Foo. Bar" to "pkg.Foo$Bar".
if (!className.isInner()) return className;
Identifier mname = Identifier.lookup(
className.getFlatName().toString().
replace('.', SIGC_INNERCLASS) );
if (mname.isInner()) throw new CompilerError("mangle "+mname);
return Identifier.lookup(className.getQualifier(), mname);
}
/**
* We have learned that a signature means something other
* that what we thought it meant. Live with it: Change all
* affected data structures to reflect the new name of the old type.
* <p>
* (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[]) {
StringBuffer buf = new StringBuffer();
buf.append(SIG_METHOD);
for (int i = 0 ; i < argTypes.length ; i++) {
buf.append(argTypes[i].getTypeSignature());
}
buf.append(SIG_ENDMETHOD);
buf.append(returnType.getTypeSignature());
String sig = buf.toString();
Type t = (Type)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 = (Type)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 = "<error>";
if (this==tPackage) s = "<package>";
break;
default: s = "unknown";
}
return (id.length() > 0) ? s + " " + id : s;
}
/**
* Create a type string, given an identifier.
*/
public String typeString(String id) {
return typeString(id, false, true);
}
/**
* Convert to a String
*/
public String toString() {
return typeString("", false, true);
}
}