org.aspectj.weaver/source/org/aspectj/apache/bcel/generic/Type.java - ajdt/org.eclipse.ajdt - Git at Google

 package org.aspectj.apache.bcel.generic;

 /* ====================================================================
  * The Apache Software License, Version 1.1
  *
  * Copyright (c) 2001 The Apache Software Foundation.  All rights
  * reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  *
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in
  *    the documentation and/or other materials provided with the
  *    distribution.
  *
  * 3. The end-user documentation included with the redistribution,
  *    if any, must include the following acknowledgment:
  *       "This product includes software developed by the
  *        Apache Software Foundation (http://www.apache.org/)."
  *    Alternately, this acknowledgment may appear in the software itself,
  *    if and wherever such third-party acknowledgments normally appear.
  *
  * 4. The names "Apache" and "Apache Software Foundation" and
  *    "Apache BCEL" must not be used to endorse or promote products
  *    derived from this software without prior written permission. For
  *    written permission, please contact apache@apache.org.
  *
  * 5. Products derived from this software may not be called "Apache",
  *    "Apache BCEL", nor may "Apache" appear in their name, without
  *    prior written permission of the Apache Software Foundation.
  *
  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  * ====================================================================
  *
  * This software consists of voluntary contributions made by many
  * individuals on behalf of the Apache Software Foundation.  For more
  * information on the Apache Software Foundation, please see
  * <http://www.apache.org/>.
  */

 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 import org.aspectj.apache.bcel.Constants;
 import org.aspectj.apache.bcel.ConstantsInitializer;
 import org.aspectj.apache.bcel.classfile.ClassFormatException;
 import org.aspectj.apache.bcel.classfile.Utility;

 /**
  * Abstract super class for all possible java types, namely basic types such as int, object types like String and array types, e.g.
  * int[]
  *
  * @version $Id: Type.java,v 1.14 2011/09/28 01:14:54 aclement Exp $
  * @author <A HREF="mailto:markus.dahm@berlin.de">M. Dahm</A>
  *
  *         modified: AndyClement 2-mar-05: Removed unnecessary static and optimized
  */
 public abstract class Type {
 	protected byte type;
 	protected String signature;

 	/* Predefined constants */
 	public static final BasicType VOID = new BasicType(Constants.T_VOID);
 	public static final BasicType BOOLEAN = new BasicType(Constants.T_BOOLEAN);
 	public static final BasicType INT = new BasicType(Constants.T_INT);
 	public static final BasicType SHORT = new BasicType(Constants.T_SHORT);
 	public static final BasicType BYTE = new BasicType(Constants.T_BYTE);
 	public static final BasicType LONG = new BasicType(Constants.T_LONG);
 	public static final BasicType DOUBLE = new BasicType(Constants.T_DOUBLE);
 	public static final BasicType FLOAT = new BasicType(Constants.T_FLOAT);
 	public static final BasicType CHAR = new BasicType(Constants.T_CHAR);
 	public static final ObjectType OBJECT = new ObjectType("java.lang.Object");
 	public static final ObjectType STRING = new ObjectType("java.lang.String");
 	public static final ArrayType OBJECT_ARRAY = new ArrayType("java.lang.Object",1);
 	public static final ArrayType STRING_ARRAY = new ArrayType("java.lang.String",1);
 	public static final ArrayType CLASS_ARRAY = new ArrayType("java.lang.Class",1);
 	public static final ObjectType STRINGBUFFER = new ObjectType("java.lang.StringBuffer");
 	public static final ObjectType STRINGBUILDER = new ObjectType("java.lang.StringBuilder");
 	public static final ObjectType THROWABLE = new ObjectType("java.lang.Throwable");
 	public static final ObjectType CLASS = new ObjectType("java.lang.Class");
 	public static final ObjectType INTEGER = new ObjectType("java.lang.Integer");
 	public static final ObjectType EXCEPTION = new ObjectType("java.lang.Exception");
 	public static final ObjectType LIST = new ObjectType("java.util.List");
 	public static final ObjectType ITERATOR = new ObjectType("java.util.Iterator");
 	public static final Type[] NO_ARGS = new Type[0];
 	public static final ReferenceType NULL = new ReferenceType() {
 	};
 	public static final Type UNKNOWN = new Type(Constants.T_UNKNOWN, "<unknown object>") {
 	};
 	public static final Type[] STRINGARRAY1 = new Type[] { STRING };
 	public static final Type[] STRINGARRAY2 = new Type[] { STRING, STRING };
 	public static final Type[] STRINGARRAY3 = new Type[] { STRING, STRING, STRING };
 	public static final Type[] STRINGARRAY4 = new Type[] { STRING, STRING, STRING, STRING };
 	public static final Type[] STRINGARRAY5 = new Type[] { STRING, STRING, STRING, STRING, STRING };
 	public static final Type[] STRINGARRAY6 = new Type[] { STRING, STRING, STRING, STRING, STRING, STRING };
 	public static final Type[] STRINGARRAY7 = new Type[] { STRING, STRING, STRING, STRING, STRING, STRING, STRING };

 	private static Map<String, Type> commonTypes = new HashMap<String, Type>();

 	static {
 		commonTypes.put(STRING.getSignature(), STRING);
 		commonTypes.put(THROWABLE.getSignature(), THROWABLE);
 		commonTypes.put(VOID.getSignature(), VOID);
 		commonTypes.put(BOOLEAN.getSignature(), BOOLEAN);
 		commonTypes.put(BYTE.getSignature(), BYTE);
 		commonTypes.put(SHORT.getSignature(), SHORT);
 		commonTypes.put(CHAR.getSignature(), CHAR);
 		commonTypes.put(INT.getSignature(), INT);
 		commonTypes.put(LONG.getSignature(), LONG);
 		commonTypes.put(DOUBLE.getSignature(), DOUBLE);
 		commonTypes.put(FLOAT.getSignature(), FLOAT);
 		commonTypes.put(CLASS.getSignature(), CLASS);
 		commonTypes.put(OBJECT.getSignature(), OBJECT);
 		commonTypes.put(STRING_ARRAY.getSignature(), STRING_ARRAY);
 		commonTypes.put(CLASS_ARRAY.getSignature(), CLASS_ARRAY);
 		commonTypes.put(OBJECT_ARRAY.getSignature(), OBJECT_ARRAY);
 		commonTypes.put(INTEGER.getSignature(), INTEGER);
 		commonTypes.put(EXCEPTION.getSignature(), EXCEPTION);
 		commonTypes.put(STRINGBUFFER.getSignature(), STRINGBUFFER);
 		commonTypes.put(STRINGBUILDER.getSignature(), STRINGBUILDER);
 		commonTypes.put(LIST.getSignature(), LIST);
 		commonTypes.put(ITERATOR.getSignature(), ITERATOR);
 		ConstantsInitializer.initialize(); // needs calling because it will not have run properly the first time
 	}

 	protected Type(byte t, String s) {
 		type = t;
 		signature = s;
 	}

 	public String getSignature() {
 		return signature;
 	}

 	public byte getType() {
 		return type;
 	}

 	/**
 	 * @return stack size of this type (2 for long and double, 0 for void, 1 otherwise)
 	 */
 	public int getSize() {
 		switch (type) {
 		case Constants.T_DOUBLE:
 		case Constants.T_LONG:
 			return 2;
 		case Constants.T_VOID:
 			return 0;
 		default:
 			return 1;
 		}
 	}

 	/**
 	 * @return Type string, e.g. 'int[]'
 	 */
 	@Override
 	public String toString() {
 		return ((this.equals(Type.NULL) || (type >= Constants.T_UNKNOWN))) ? signature : Utility
 				.signatureToString(signature, false);
 	}

 	public static final Type getType(String signature) {
 		Type t = commonTypes.get(signature);
 		if (t != null) {
 			return t;
 		}
 		byte type = Utility.typeOfSignature(signature);
 		if (type <= Constants.T_VOID) {
 			return BasicType.getType(type);
 		} else if (type == Constants.T_ARRAY) {
 			int dim = 0;
 			do {
 				dim++;
 			} while (signature.charAt(dim) == '[');
 			// Recurse, but just once, if the signature is ok
 			Type componentType = getType(signature.substring(dim));
 			return new ArrayType(componentType, dim);
 		} else { // type == T_REFERENCE
 			// generics awareness
 			int nextAngly = signature.indexOf('<');
 			// Format is 'Lblahblah;'
 			int index = signature.indexOf(';'); // Look for closing ';'

 			String typeString = null;
 			if (nextAngly == -1 || nextAngly > index) {
 				typeString = signature.substring(1, index).replace('/', '.');
 			} else {
 				boolean endOfSigReached = false;
 				int posn = nextAngly;
 				int genericDepth = 0;
 				while (!endOfSigReached) {
 					switch (signature.charAt(posn++)) {
 					case '<':
 						genericDepth++;
 						break;
 					case '>':
 						genericDepth--;
 						break;
 					case ';':
 						if (genericDepth == 0) {
 							endOfSigReached = true;
 						}
 						break;
 					default:
 					}
 				}
 				index = posn - 1;
 				typeString = signature.substring(1, nextAngly).replace('/', '.');
 			}
 			// ObjectType doesn't currently store parameterized info
 			return new ObjectType(typeString);
 		}
 	}

 	/**
 	 * Convert signature to a Type object.
 	 *
 	 * @param signature signature string such as Ljava/lang/String;
 	 * @return type object
 	 */
 	public static final TypeHolder getTypeInternal(String signature) throws StringIndexOutOfBoundsException {
 		byte type = Utility.typeOfSignature(signature);

 		if (type <= Constants.T_VOID) {
 			return new TypeHolder(BasicType.getType(type), 1);
 		} else if (type == Constants.T_ARRAY) {
 			int dim = 0;
 			do {
 				dim++;
 			} while (signature.charAt(dim) == '[');
 			// Recurse, but just once, if the signature is ok
 			TypeHolder th = getTypeInternal(signature.substring(dim));
 			return new TypeHolder(new ArrayType(th.getType(), dim), dim + th.getConsumed());
 		} else { // type == T_REFERENCE
 			// Format is 'Lblahblah;'
 			int index = signature.indexOf(';'); // Look for closing ';'
 			if (index < 0) {
 				throw new ClassFormatException("Invalid signature: " + signature);
 			}

 			// generics awareness
 			int nextAngly = signature.indexOf('<');
 			String typeString = null;
 			if (nextAngly == -1 || nextAngly > index) {
 				typeString = signature.substring(1, index).replace('/', '.');
 			} else {
 				boolean endOfSigReached = false;
 				int posn = nextAngly;
 				int genericDepth = 0;
 				while (!endOfSigReached) {
 					switch (signature.charAt(posn++)) {
 					case '<':
 						genericDepth++;
 						break;
 					case '>':
 						genericDepth--;
 						break;
 					case ';':
 						if (genericDepth == 0) {
 							endOfSigReached = true;
 						}
 						break;
 					default:
 					}
 				}
 				index = posn - 1;
 				typeString = signature.substring(1, nextAngly).replace('/', '.');
 			}
 			// ObjectType doesn't currently store parameterized info
 			return new TypeHolder(new ObjectType(typeString), index + 1);
 		}
 	}

 	/**
 	 * Convert return value of a method (signature) to a Type object.
 	 *
 	 * @param signature signature string such as (Ljava/lang/String;)V
 	 * @return return type
 	 */
 	public static Type getReturnType(String signature) {
 		try {
 			// Read return type after ')'
 			int index = signature.lastIndexOf(')') + 1;
 			return getType(signature.substring(index));
 		} catch (StringIndexOutOfBoundsException e) { // Should never occur
 			throw new ClassFormatException("Invalid method signature: " + signature);
 		}
 	}

 	/**
 	 * Convert arguments of a method (signature) to an array of Type objects.
 	 *
 	 * @param signature signature string such as (Ljava/lang/String;)V
 	 * @return array of argument types
 	 */
 	// OPTIMIZE crap impl
 	public static Type[] getArgumentTypes(String signature) {
 		List<Type> argumentTypes = new ArrayList<Type>();
 		int index;
 		Type[] types;

 		try { // Read all declarations between for `(' and `)'
 			if (signature.charAt(0) != '(') {
 				throw new ClassFormatException("Invalid method signature: " + signature);
 			}

 			index = 1; // current string position

 			while (signature.charAt(index) != ')') {
 				TypeHolder th = getTypeInternal(signature.substring(index));
 				argumentTypes.add(th.getType());
 				index += th.getConsumed(); // update position
 			}
 		} catch (StringIndexOutOfBoundsException e) { // Should never occur
 			throw new ClassFormatException("Invalid method signature: " + signature);
 		}

 		types = new Type[argumentTypes.size()];
 		argumentTypes.toArray(types);
 		return types;
 	}

 	/**
 	 * Work out the type of each argument in the signature and return the cumulative sizes of all the types (size means number of
 	 * stack slots it consumes, eg double=2, int=1). Unlike the call above, this does minimal unpacking
 	 */
 	public static int getArgumentSizes(String signature) {
 		int size = 0;
 		if (signature.charAt(0) != '(') {
 			throw new ClassFormatException("Invalid method signature: " + signature);
 		}

 		int index = 1; // current string position
 		try {
 			while (signature.charAt(index) != ')') {
 				byte type = Utility.typeOfSignature(signature.charAt(index));
 				if (type <= Constants.T_VOID) {
 					size += BasicType.getType(type).getSize();
 					index++;
 				} else if (type == Constants.T_ARRAY) {
 					int dim = 0;
 					do {
 						dim++;
 					} while (signature.charAt(dim + index) == '[');
 					TypeHolder th = getTypeInternal(signature.substring(dim + index));
 					size += 1;
 					index += dim + th.getConsumed();
 				} else { // type == T_REFERENCE
 					// Format is 'Lblahblah;'
 					int index2 = signature.indexOf(';', index); // Look for closing ';'

 					// generics awareness
 					int nextAngly = signature.indexOf('<', index);
 					if (nextAngly == -1 || nextAngly > index2) {
 					} else {
 						boolean endOfSigReached = false;
 						int posn = nextAngly;
 						int genericDepth = 0;
 						while (!endOfSigReached) {
 							switch (signature.charAt(posn++)) {
 							case '<':
 								genericDepth++;
 								break;
 							case '>':
 								genericDepth--;
 								break;
 							case ';':
 								if (genericDepth == 0) {
 									endOfSigReached = true;
 								}
 								break;
 							default:
 							}
 						}
 						index2 = posn - 1;
 					}
 					size++;
 					index = index2 + 1;
 				}
 			}
 		} catch (StringIndexOutOfBoundsException e) { // Should never occur
 			throw new ClassFormatException("Invalid method signature: " + signature);
 		}
 		return size;
 	}

 	/**
 	 * Return the size of the type expressed in the signature. The signature should contain only one type.
 	 */
 	public static int getTypeSize(String signature) {
 		byte type = Utility.typeOfSignature(signature.charAt(0));
 		if (type <= Constants.T_VOID) {
 			return BasicType.getType(type).getSize();
 		} else if (type == Constants.T_ARRAY) {
 			return 1;
 		} else { // type == T_REFERENCE
 			return 1;
 		}
 	}

 	/**
 	 * Convert runtime java.lang.Class to BCEL Type object.
 	 *
 	 * @param cl Java class
 	 * @return corresponding Type object
 	 */
 	public static Type getType(java.lang.Class cl) {
 		if (cl == null) {
 			throw new IllegalArgumentException("Class must not be null");
 		}

 		/*
 		 * That's an amazingly easy case, because getName() returns the signature. That's what we would have liked anyway.
 		 */
 		if (cl.isArray()) {
 			return getType(cl.getName());
 		} else if (cl.isPrimitive()) {
 			if (cl == Integer.TYPE) {
 				return INT;
 			} else if (cl == Void.TYPE) {
 				return VOID;
 			} else if (cl == Double.TYPE) {
 				return DOUBLE;
 			} else if (cl == Float.TYPE) {
 				return FLOAT;
 			} else if (cl == Boolean.TYPE) {
 				return BOOLEAN;
 			} else if (cl == Byte.TYPE) {
 				return BYTE;
 			} else if (cl == Short.TYPE) {
 				return SHORT;
 			} else if (cl == Byte.TYPE) {
 				return BYTE;
 			} else if (cl == Long.TYPE) {
 				return LONG;
 			} else if (cl == Character.TYPE) {
 				return CHAR;
 			} else {
 				throw new IllegalStateException("Ooops, what primitive type is " + cl);
 			}
 		} else { // "Real" class
 			return new ObjectType(cl.getName());
 		}
 	}

 	public static String getSignature(java.lang.reflect.Method meth) {
 		StringBuffer sb = new StringBuffer("(");
 		Class[] params = meth.getParameterTypes(); // avoid clone

 		for (int j = 0; j < params.length; j++) {
 			sb.append(getType(params[j]).getSignature());
 		}

 		sb.append(")");
 		sb.append(getType(meth.getReturnType()).getSignature());
 		return sb.toString();
 	}

 	public static String getSignature(java.lang.reflect.Constructor<?> cons) {
 		StringBuffer sb = new StringBuffer("(");
 		Class<?>[] params = cons.getParameterTypes(); // avoid clone

 		for (int j = 0; j < params.length; j++) {
 			sb.append(getType(params[j]).getSignature());
 		}

 		sb.append(")V");
 		return sb.toString();
 	}

 	public static class TypeHolder {
 		private Type t;
 		private int consumed;

 		public Type getType() {
 			return t;
 		}

 		public int getConsumed() {
 			return consumed;
 		}

 		public TypeHolder(Type t, int i) {
 			this.t = t;
 			this.consumed = i;
 		}
 	}

 }
	package org.aspectj.apache.bcel.generic;

	/* ====================================================================
	* The Apache Software License, Version 1.1
	*
	* Copyright (c) 2001 The Apache Software Foundation. All rights
	* reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	*
	* 1. Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	*
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in
	* the documentation and/or other materials provided with the
	* distribution.
	*
	* 3. The end-user documentation included with the redistribution,
	* if any, must include the following acknowledgment:
	* "This product includes software developed by the
	* Apache Software Foundation (http://www.apache.org/)."
	* Alternately, this acknowledgment may appear in the software itself,
	* if and wherever such third-party acknowledgments normally appear.
	*
	* 4. The names "Apache" and "Apache Software Foundation" and
	* "Apache BCEL" must not be used to endorse or promote products
	* derived from this software without prior written permission. For
	* written permission, please contact apache@apache.org.
	*
	* 5. Products derived from this software may not be called "Apache",
	* "Apache BCEL", nor may "Apache" appear in their name, without
	* prior written permission of the Apache Software Foundation.
	*
	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
	* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
	* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
	* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	* SUCH DAMAGE.
	* ====================================================================
	*
	* This software consists of voluntary contributions made by many
	* individuals on behalf of the Apache Software Foundation. For more
	* information on the Apache Software Foundation, please see
	* <http://www.apache.org/>.
	*/

	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;

	import org.aspectj.apache.bcel.Constants;
	import org.aspectj.apache.bcel.ConstantsInitializer;
	import org.aspectj.apache.bcel.classfile.ClassFormatException;
	import org.aspectj.apache.bcel.classfile.Utility;

	/**
	* Abstract super class for all possible java types, namely basic types such as int, object types like String and array types, e.g.
	* int[]
	*
	* @version $Id: Type.java,v 1.14 2011/09/28 01:14:54 aclement Exp $
	* @author <A HREF="mailto:markus.dahm@berlin.de">M. Dahm</A>
	*
	* modified: AndyClement 2-mar-05: Removed unnecessary static and optimized
	*/
	public abstract class Type {
	protected byte type;
	protected String signature;

	/* Predefined constants */
	public static final BasicType VOID = new BasicType(Constants.T_VOID);
	public static final BasicType BOOLEAN = new BasicType(Constants.T_BOOLEAN);
	public static final BasicType INT = new BasicType(Constants.T_INT);
	public static final BasicType SHORT = new BasicType(Constants.T_SHORT);
	public static final BasicType BYTE = new BasicType(Constants.T_BYTE);
	public static final BasicType LONG = new BasicType(Constants.T_LONG);
	public static final BasicType DOUBLE = new BasicType(Constants.T_DOUBLE);
	public static final BasicType FLOAT = new BasicType(Constants.T_FLOAT);
	public static final BasicType CHAR = new BasicType(Constants.T_CHAR);
	public static final ObjectType OBJECT = new ObjectType("java.lang.Object");
	public static final ObjectType STRING = new ObjectType("java.lang.String");
	public static final ArrayType OBJECT_ARRAY = new ArrayType("java.lang.Object",1);
	public static final ArrayType STRING_ARRAY = new ArrayType("java.lang.String",1);
	public static final ArrayType CLASS_ARRAY = new ArrayType("java.lang.Class",1);
	public static final ObjectType STRINGBUFFER = new ObjectType("java.lang.StringBuffer");
	public static final ObjectType STRINGBUILDER = new ObjectType("java.lang.StringBuilder");
	public static final ObjectType THROWABLE = new ObjectType("java.lang.Throwable");
	public static final ObjectType CLASS = new ObjectType("java.lang.Class");
	public static final ObjectType INTEGER = new ObjectType("java.lang.Integer");
	public static final ObjectType EXCEPTION = new ObjectType("java.lang.Exception");
	public static final ObjectType LIST = new ObjectType("java.util.List");
	public static final ObjectType ITERATOR = new ObjectType("java.util.Iterator");
	public static final Type[] NO_ARGS = new Type[0];
	public static final ReferenceType NULL = new ReferenceType() {
	};
	public static final Type UNKNOWN = new Type(Constants.T_UNKNOWN, "<unknown object>") {
	};
	public static final Type[] STRINGARRAY1 = new Type[] { STRING };
	public static final Type[] STRINGARRAY2 = new Type[] { STRING, STRING };
	public static final Type[] STRINGARRAY3 = new Type[] { STRING, STRING, STRING };
	public static final Type[] STRINGARRAY4 = new Type[] { STRING, STRING, STRING, STRING };
	public static final Type[] STRINGARRAY5 = new Type[] { STRING, STRING, STRING, STRING, STRING };
	public static final Type[] STRINGARRAY6 = new Type[] { STRING, STRING, STRING, STRING, STRING, STRING };
	public static final Type[] STRINGARRAY7 = new Type[] { STRING, STRING, STRING, STRING, STRING, STRING, STRING };

	private static Map<String, Type> commonTypes = new HashMap<String, Type>();

	static {
	commonTypes.put(STRING.getSignature(), STRING);
	commonTypes.put(THROWABLE.getSignature(), THROWABLE);
	commonTypes.put(VOID.getSignature(), VOID);
	commonTypes.put(BOOLEAN.getSignature(), BOOLEAN);
	commonTypes.put(BYTE.getSignature(), BYTE);
	commonTypes.put(SHORT.getSignature(), SHORT);
	commonTypes.put(CHAR.getSignature(), CHAR);
	commonTypes.put(INT.getSignature(), INT);
	commonTypes.put(LONG.getSignature(), LONG);
	commonTypes.put(DOUBLE.getSignature(), DOUBLE);
	commonTypes.put(FLOAT.getSignature(), FLOAT);
	commonTypes.put(CLASS.getSignature(), CLASS);
	commonTypes.put(OBJECT.getSignature(), OBJECT);
	commonTypes.put(STRING_ARRAY.getSignature(), STRING_ARRAY);
	commonTypes.put(CLASS_ARRAY.getSignature(), CLASS_ARRAY);
	commonTypes.put(OBJECT_ARRAY.getSignature(), OBJECT_ARRAY);
	commonTypes.put(INTEGER.getSignature(), INTEGER);
	commonTypes.put(EXCEPTION.getSignature(), EXCEPTION);
	commonTypes.put(STRINGBUFFER.getSignature(), STRINGBUFFER);
	commonTypes.put(STRINGBUILDER.getSignature(), STRINGBUILDER);
	commonTypes.put(LIST.getSignature(), LIST);
	commonTypes.put(ITERATOR.getSignature(), ITERATOR);
	ConstantsInitializer.initialize(); // needs calling because it will not have run properly the first time
	}

	protected Type(byte t, String s) {
	type = t;
	signature = s;
	}

	public String getSignature() {
	return signature;
	}

	public byte getType() {
	return type;
	}

	/**
	* @return stack size of this type (2 for long and double, 0 for void, 1 otherwise)
	*/
	public int getSize() {
	switch (type) {
	case Constants.T_DOUBLE:
	case Constants.T_LONG:
	return 2;
	case Constants.T_VOID:
	return 0;
	default:
	return 1;
	}
	}

	/**
	* @return Type string, e.g. 'int[]'
	*/
	@Override
	public String toString() {
	return ((this.equals(Type.NULL) \|\| (type >= Constants.T_UNKNOWN))) ? signature : Utility
	.signatureToString(signature, false);
	}

	public static final Type getType(String signature) {
	Type t = commonTypes.get(signature);
	if (t != null) {
	return t;
	}
	byte type = Utility.typeOfSignature(signature);
	if (type <= Constants.T_VOID) {
	return BasicType.getType(type);
	} else if (type == Constants.T_ARRAY) {
	int dim = 0;
	do {
	dim++;
	} while (signature.charAt(dim) == '[');
	// Recurse, but just once, if the signature is ok
	Type componentType = getType(signature.substring(dim));
	return new ArrayType(componentType, dim);
	} else { // type == T_REFERENCE
	// generics awareness
	int nextAngly = signature.indexOf('<');
	// Format is 'Lblahblah;'
	int index = signature.indexOf(';'); // Look for closing ';'

	String typeString = null;
	if (nextAngly == -1 \|\| nextAngly > index) {
	typeString = signature.substring(1, index).replace('/', '.');
	} else {
	boolean endOfSigReached = false;
	int posn = nextAngly;
	int genericDepth = 0;
	while (!endOfSigReached) {
	switch (signature.charAt(posn++)) {
	case '<':
	genericDepth++;
	break;
	case '>':
	genericDepth--;
	break;
	case ';':
	if (genericDepth == 0) {
	endOfSigReached = true;
	}
	break;
	default:
	}
	}
	index = posn - 1;
	typeString = signature.substring(1, nextAngly).replace('/', '.');
	}
	// ObjectType doesn't currently store parameterized info
	return new ObjectType(typeString);
	}
	}

	/**
	* Convert signature to a Type object.
	*
	* @param signature signature string such as Ljava/lang/String;
	* @return type object
	*/
	public static final TypeHolder getTypeInternal(String signature) throws StringIndexOutOfBoundsException {
	byte type = Utility.typeOfSignature(signature);

	if (type <= Constants.T_VOID) {
	return new TypeHolder(BasicType.getType(type), 1);
	} else if (type == Constants.T_ARRAY) {
	int dim = 0;
	do {
	dim++;
	} while (signature.charAt(dim) == '[');
	// Recurse, but just once, if the signature is ok
	TypeHolder th = getTypeInternal(signature.substring(dim));
	return new TypeHolder(new ArrayType(th.getType(), dim), dim + th.getConsumed());
	} else { // type == T_REFERENCE
	// Format is 'Lblahblah;'
	int index = signature.indexOf(';'); // Look for closing ';'
	if (index < 0) {
	throw new ClassFormatException("Invalid signature: " + signature);
	}

	// generics awareness
	int nextAngly = signature.indexOf('<');
	String typeString = null;
	if (nextAngly == -1 \|\| nextAngly > index) {
	typeString = signature.substring(1, index).replace('/', '.');
	} else {
	boolean endOfSigReached = false;
	int posn = nextAngly;
	int genericDepth = 0;
	while (!endOfSigReached) {
	switch (signature.charAt(posn++)) {
	case '<':
	genericDepth++;
	break;
	case '>':
	genericDepth--;
	break;
	case ';':
	if (genericDepth == 0) {
	endOfSigReached = true;
	}
	break;
	default:
	}
	}
	index = posn - 1;
	typeString = signature.substring(1, nextAngly).replace('/', '.');
	}
	// ObjectType doesn't currently store parameterized info
	return new TypeHolder(new ObjectType(typeString), index + 1);
	}
	}

	/**
	* Convert return value of a method (signature) to a Type object.
	*
	* @param signature signature string such as (Ljava/lang/String;)V
	* @return return type
	*/
	public static Type getReturnType(String signature) {
	try {
	// Read return type after ')'
	int index = signature.lastIndexOf(')') + 1;
	return getType(signature.substring(index));
	} catch (StringIndexOutOfBoundsException e) { // Should never occur
	throw new ClassFormatException("Invalid method signature: " + signature);
	}
	}

	/**
	* Convert arguments of a method (signature) to an array of Type objects.
	*
	* @param signature signature string such as (Ljava/lang/String;)V
	* @return array of argument types
	*/
	// OPTIMIZE crap impl
	public static Type[] getArgumentTypes(String signature) {
	List<Type> argumentTypes = new ArrayList<Type>();
	int index;
	Type[] types;

	try { // Read all declarations between for `(' and `)'
	if (signature.charAt(0) != '(') {
	throw new ClassFormatException("Invalid method signature: " + signature);
	}

	index = 1; // current string position

	while (signature.charAt(index) != ')') {
	TypeHolder th = getTypeInternal(signature.substring(index));
	argumentTypes.add(th.getType());
	index += th.getConsumed(); // update position
	}
	} catch (StringIndexOutOfBoundsException e) { // Should never occur
	throw new ClassFormatException("Invalid method signature: " + signature);
	}

	types = new Type[argumentTypes.size()];
	argumentTypes.toArray(types);
	return types;
	}

	/**
	* Work out the type of each argument in the signature and return the cumulative sizes of all the types (size means number of
	* stack slots it consumes, eg double=2, int=1). Unlike the call above, this does minimal unpacking
	*/
	public static int getArgumentSizes(String signature) {
	int size = 0;
	if (signature.charAt(0) != '(') {
	throw new ClassFormatException("Invalid method signature: " + signature);
	}

	int index = 1; // current string position
	try {
	while (signature.charAt(index) != ')') {
	byte type = Utility.typeOfSignature(signature.charAt(index));
	if (type <= Constants.T_VOID) {
	size += BasicType.getType(type).getSize();
	index++;
	} else if (type == Constants.T_ARRAY) {
	int dim = 0;
	do {
	dim++;
	} while (signature.charAt(dim + index) == '[');
	TypeHolder th = getTypeInternal(signature.substring(dim + index));
	size += 1;
	index += dim + th.getConsumed();
	} else { // type == T_REFERENCE
	// Format is 'Lblahblah;'
	int index2 = signature.indexOf(';', index); // Look for closing ';'

	// generics awareness
	int nextAngly = signature.indexOf('<', index);
	if (nextAngly == -1 \|\| nextAngly > index2) {
	} else {
	boolean endOfSigReached = false;
	int posn = nextAngly;
	int genericDepth = 0;
	while (!endOfSigReached) {
	switch (signature.charAt(posn++)) {
	case '<':
	genericDepth++;
	break;
	case '>':
	genericDepth--;
	break;
	case ';':
	if (genericDepth == 0) {
	endOfSigReached = true;
	}
	break;
	default:
	}
	}
	index2 = posn - 1;
	}
	size++;
	index = index2 + 1;
	}
	}
	} catch (StringIndexOutOfBoundsException e) { // Should never occur
	throw new ClassFormatException("Invalid method signature: " + signature);
	}
	return size;
	}

	/**
	* Return the size of the type expressed in the signature. The signature should contain only one type.
	*/
	public static int getTypeSize(String signature) {
	byte type = Utility.typeOfSignature(signature.charAt(0));
	if (type <= Constants.T_VOID) {
	return BasicType.getType(type).getSize();
	} else if (type == Constants.T_ARRAY) {
	return 1;
	} else { // type == T_REFERENCE
	return 1;
	}
	}

	/**
	* Convert runtime java.lang.Class to BCEL Type object.
	*
	* @param cl Java class
	* @return corresponding Type object
	*/
	public static Type getType(java.lang.Class cl) {
	if (cl == null) {
	throw new IllegalArgumentException("Class must not be null");
	}

	/*
	* That's an amazingly easy case, because getName() returns the signature. That's what we would have liked anyway.
	*/
	if (cl.isArray()) {
	return getType(cl.getName());
	} else if (cl.isPrimitive()) {
	if (cl == Integer.TYPE) {
	return INT;
	} else if (cl == Void.TYPE) {
	return VOID;
	} else if (cl == Double.TYPE) {
	return DOUBLE;
	} else if (cl == Float.TYPE) {
	return FLOAT;
	} else if (cl == Boolean.TYPE) {
	return BOOLEAN;
	} else if (cl == Byte.TYPE) {
	return BYTE;
	} else if (cl == Short.TYPE) {
	return SHORT;
	} else if (cl == Byte.TYPE) {
	return BYTE;
	} else if (cl == Long.TYPE) {
	return LONG;
	} else if (cl == Character.TYPE) {
	return CHAR;
	} else {
	throw new IllegalStateException("Ooops, what primitive type is " + cl);
	}
	} else { // "Real" class
	return new ObjectType(cl.getName());
	}
	}

	public static String getSignature(java.lang.reflect.Method meth) {
	StringBuffer sb = new StringBuffer("(");
	Class[] params = meth.getParameterTypes(); // avoid clone

	for (int j = 0; j < params.length; j++) {
	sb.append(getType(params[j]).getSignature());
	}

	sb.append(")");
	sb.append(getType(meth.getReturnType()).getSignature());
	return sb.toString();
	}

	public static String getSignature(java.lang.reflect.Constructor<?> cons) {
	StringBuffer sb = new StringBuffer("(");
	Class<?>[] params = cons.getParameterTypes(); // avoid clone

	for (int j = 0; j < params.length; j++) {
	sb.append(getType(params[j]).getSignature());
	}

	sb.append(")V");
	return sb.toString();
	}

	public static class TypeHolder {
	private Type t;
	private int consumed;

	public Type getType() {
	return t;
	}

	public int getConsumed() {
	return consumed;
	}

	public TypeHolder(Type t, int i) {
	this.t = t;
	this.consumed = i;
	}
	}

	}