Back to index...

	/*
	* 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);
	}
	}

Back to index...