/***

  * ASM: a very small and fast Java bytecode manipulation framework

  * Copyright (c) 2000-2005 INRIA, France Telecom

  * 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. Neither the name of the copyright holders nor the names of its

  *    contributors may be used to endorse or promote products derived from

  *    this software without specific prior written permission.

  *

  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

  * AND ANY EXPRESS 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 COPYRIGHT OWNER OR 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.

  */

 package clojure.asm;

 

 import java.lang.reflect.Constructor;

 import java.lang.reflect.Method;

 

 /**

  * A Java type. This class can be used to make it easier to manipulate type and

  * method descriptors.

  *

  * @author Eric Bruneton

  * @author Chris Nokleberg

  */

 public class Type{

 

 /**

  * The sort of the <tt>void</tt> type. See {@link #getSort getSort}.

  */

 public final static int VOID = 0;

 

 /**

  * The sort of the <tt>boolean</tt> type. See {@link #getSort getSort}.

  */

 public final static int BOOLEAN = 1;

 

 /**

  * The sort of the <tt>char</tt> type. See {@link #getSort getSort}.

  */

 public final static int CHAR = 2;

 

 /**

  * The sort of the <tt>byte</tt> type. See {@link #getSort getSort}.

  */

 public final static int BYTE = 3;

 

 /**

  * The sort of the <tt>short</tt> type. See {@link #getSort getSort}.

  */

 public final static int SHORT = 4;

 

 /**

  * The sort of the <tt>int</tt> type. See {@link #getSort getSort}.

  */

 public final static int INT = 5;

 

 /**

  * The sort of the <tt>float</tt> type. See {@link #getSort getSort}.

  */

 public final static int FLOAT = 6;

 

 /**

  * The sort of the <tt>long</tt> type. See {@link #getSort getSort}.

  */

 public final static int LONG = 7;

 

 /**

  * The sort of the <tt>double</tt> type. See {@link #getSort getSort}.

  */

 public final static int DOUBLE = 8;

 

 /**

  * The sort of array reference types. See {@link #getSort getSort}.

  */

 public final static int ARRAY = 9;

 

 /**

  * The sort of object reference type. See {@link #getSort getSort}.

  */

 public final static int OBJECT = 10;

 

 /**

  * The <tt>void</tt> type.

  */

 public final static Type VOID_TYPE = new Type(VOID);

 

 /**

  * The <tt>boolean</tt> type.

  */

 public final static Type BOOLEAN_TYPE = new Type(BOOLEAN);

 

 /**

  * The <tt>char</tt> type.

  */

 public final static Type CHAR_TYPE = new Type(CHAR);

 

 /**

  * The <tt>byte</tt> type.

  */

 public final static Type BYTE_TYPE = new Type(BYTE);

 

 /**

  * The <tt>short</tt> type.

  */

 public final static Type SHORT_TYPE = new Type(SHORT);

 

 /**

  * The <tt>int</tt> type.

  */

 public final static Type INT_TYPE = new Type(INT);

 

 /**

  * The <tt>float</tt> type.

  */

 public final static Type FLOAT_TYPE = new Type(FLOAT);

 

 /**

  * The <tt>long</tt> type.

  */

 public final static Type LONG_TYPE = new Type(LONG);

 

 /**

  * The <tt>double</tt> type.

  */

 public final static Type DOUBLE_TYPE = new Type(DOUBLE);

 

 // ------------------------------------------------------------------------

 // Fields

 // ------------------------------------------------------------------------

 

 /**

  * The sort of this Java type.

  */

 private final int sort;

 

 /**

  * A buffer containing the descriptor of this Java type. This field is only

  * used for reference types.

  */

 private char[] buf;

 

 /**

  * The offset of the descriptor of this Java type in {@link #buf buf}. This

  * field is only used for reference types.

  */

 private int off;

 

 /**

  * The length of the descriptor of this Java type.

  */

 private int len;

 

 // ------------------------------------------------------------------------

 // Constructors

 // ------------------------------------------------------------------------

 

 /**

  * Constructs a primitive type.

  *

  * @param sort the sort of the primitive type to be constructed.

  */

 private Type(final int sort){

 	this.sort = sort;

 	this.len = 1;

 }

 

 /**

  * Constructs a reference type.

  *

  * @param sort the sort of the reference type to be constructed.

  * @param buf  a buffer containing the descriptor of the previous type.

  * @param off  the offset of this descriptor in the previous buffer.

  * @param len  the length of this descriptor.

  */

 private Type(final int sort, final char[] buf, final int off, final int len){

 	this.sort = sort;

 	this.buf = buf;

 	this.off = off;

 	this.len = len;

 }

 

 /**

  * Returns the Java type corresponding to the given type descriptor.

  *

  * @param typeDescriptor a type descriptor.

  * @return the Java type corresponding to the given type descriptor.

  */

 public static Type getType(final String typeDescriptor){

 	return getType(typeDescriptor.toCharArray(), 0);

 }

 

 /**

  * Returns the Java type corresponding to the given class.

  *

  * @param c a class.

  * @return the Java type corresponding to the given class.

  */

 public static Type getType(final Class c){

 	if(c.isPrimitive())

 		{

 		if(c == Integer.TYPE)

 			{

 			return INT_TYPE;

 			}

 		else if(c == Void.TYPE)

 			{

 			return VOID_TYPE;

 			}

 		else if(c == Boolean.TYPE)

 			{

 			return BOOLEAN_TYPE;

 			}

 		else if(c == Byte.TYPE)

 			{

 			return BYTE_TYPE;

 			}

 		else if(c == Character.TYPE)

 			{

 			return CHAR_TYPE;

 			}

 		else if(c == Short.TYPE)

 			{

 			return SHORT_TYPE;

 			}

 		else if(c == Double.TYPE)

 			{

 			return DOUBLE_TYPE;

 			}

 		else if(c == Float.TYPE)

 			{

 			return FLOAT_TYPE;

 			}

 		else /* if (c == Long.TYPE) */

 			{

 			return LONG_TYPE;

 			}

 		}

 	else

 		{

 		return getType(getDescriptor(c));

 		}

 }

 

 /**

  * Returns the {@link Type#OBJECT} type for the given internal class name.

  * This is a shortcut method for <code>Type.getType("L"+name+";")</code>.

  * <i>Note that opposed to {@link Type#getType(String)}, this method takes

  * internal class names and not class descriptor.</i>

  *

  * @param name an internal class name.

  * @return the the {@link Type#OBJECT} type for the given class name.

  */

 public static Type getObjectType(String name){

 	int l = name.length();

 	char[] buf = new char[l + 2];

 	buf[0] = 'L';

 	buf[l + 1] = ';';

 	name.getChars(0, l, buf, 1);

 	return new Type(OBJECT, buf, 0, l + 2);

 }

 

 /**

  * Returns the Java types corresponding to the argument types of the given

  * method descriptor.

  *

  * @param methodDescriptor a method descriptor.

  * @return the Java types corresponding to the argument types of the given

  *         method descriptor.

  */

 public static Type[] getArgumentTypes(final String methodDescriptor){

 	char[] buf = methodDescriptor.toCharArray();

 	int off = 1;

 	int size = 0;

 	while(true)

 		{

 		char car = buf[off++];

 		if(car == ')')

 			{

 			break;

 			}

 		else if(car == 'L')

 			{

 			while(buf[off++] != ';')

 				{

 				}

 			++size;

 			}

 		else if(car != '[')

 			{

 			++size;

 			}

 		}

 	Type[] args = new Type[size];

 	off = 1;

 	size = 0;

 	while(buf[off] != ')')

 		{

 		args[size] = getType(buf, off);

 		off += args[size].len;

 		size += 1;

 		}

 	return args;

 }

 

 /**

  * Returns the Java types corresponding to the argument types of the given

  * method.

  *

  * @param method a method.

  * @return the Java types corresponding to the argument types of the given

  *         method.

  */

 public static Type[] getArgumentTypes(final Method method){

 	Class[] classes = method.getParameterTypes();

 	Type[] types = new Type[classes.length];

 	for(int i = classes.length - 1; i >= 0; --i)

 		{

 		types[i] = getType(classes[i]);

 		}

 	return types;

 }

 

 /**

  * Returns the Java type corresponding to the return type of the given

  * method descriptor.

  *

  * @param methodDescriptor a method descriptor.

  * @return the Java type corresponding to the return type of the given

  *         method descriptor.

  */

 public static Type getReturnType(final String methodDescriptor){

 	char[] buf = methodDescriptor.toCharArray();

 	return getType(buf, methodDescriptor.indexOf(')') + 1);

 }

 

 /**

  * Returns the Java type corresponding to the return type of the given

  * method.

  *

  * @param method a method.

  * @return the Java type corresponding to the return type of the given

  *         method.

  */

 public static Type getReturnType(final Method method){

 	return getType(method.getReturnType());

 }

 

 /**

  * Returns the Java type corresponding to the given type descriptor.

  *

  * @param buf a buffer containing a type descriptor.

  * @param off the offset of this descriptor in the previous buffer.

  * @return the Java type corresponding to the given type descriptor.

  */

 private static Type getType(final char[] buf, final int off){

 	int len;

 	switch(buf[off])

 		{

 		case'V':

 			return VOID_TYPE;

 		case'Z':

 			return BOOLEAN_TYPE;

 		case'C':

 			return CHAR_TYPE;

 		case'B':

 			return BYTE_TYPE;

 		case'S':

 			return SHORT_TYPE;

 		case'I':

 			return INT_TYPE;

 		case'F':

 			return FLOAT_TYPE;

 		case'J':

 			return LONG_TYPE;

 		case'D':

 			return DOUBLE_TYPE;

 		case'[':

 			len = 1;

 			while(buf[off + len] == '[')

 				{

 				++len;

 				}

 			if(buf[off + len] == 'L')

 				{

 				++len;

 				while(buf[off + len] != ';')

 					{

 					++len;

 					}

 				}

 			return new Type(ARRAY, buf, off, len + 1);

 			// case 'L':

 		default:

 			len = 1;

 			while(buf[off + len] != ';')

 				{

 				++len;

 				}

 			return new Type(OBJECT, buf, off, len + 1);

 		}

 }

 

 // ------------------------------------------------------------------------

 // Accessors

 // ------------------------------------------------------------------------

 

 /**

  * Returns the sort of this Java type.

  *

  * @return {@link #VOID VOID}, {@link #BOOLEAN BOOLEAN},

  *         {@link #CHAR CHAR}, {@link #BYTE BYTE}, {@link #SHORT SHORT},

  *         {@link #INT INT}, {@link #FLOAT FLOAT}, {@link #LONG LONG},

  *         {@link #DOUBLE DOUBLE}, {@link #ARRAY ARRAY} or

  *         {@link #OBJECT OBJECT}.

  */

 public int getSort(){

 	return sort;

 }

 

 /**

  * Returns the number of dimensions of this array type. This method should

  * only be used for an array type.

  *

  * @return the number of dimensions of this array type.

  */

 public int getDimensions(){

 	int i = 1;

 	while(buf[off + i] == '[')

 		{

 		++i;

 		}

 	return i;

 }

 

 /**

  * Returns the type of the elements of this array type. This method should

  * only be used for an array type.

  *

  * @return Returns the type of the elements of this array type.

  */

 public Type getElementType(){

 	return getType(buf, off + getDimensions());

 }

 

 /**

  * Returns the name of the class corresponding to this type.

  *

  * @return the fully qualified name of the class corresponding to this type.

  */

 public String getClassName(){

 	switch(sort)

 		{

 		case VOID:

 			return "void";

 		case BOOLEAN:

 			return "boolean";

 		case CHAR:

 			return "char";

 		case BYTE:

 			return "byte";

 		case SHORT:

 			return "short";

 		case INT:

 			return "int";

 		case FLOAT:

 			return "float";

 		case LONG:

 			return "long";

 		case DOUBLE:

 			return "double";

 		case ARRAY:

 			StringBuffer b = new StringBuffer(getElementType().getClassName());

 			for(int i = getDimensions(); i > 0; --i)

 				{

 				b.append("[]");

 				}

 			return b.toString();

 			// case OBJECT:

 		default:

 			return new String(buf, off + 1, len - 2).replace('/', '.');

 		}

 }

 

 /**

  * Returns the internal name of the class corresponding to this object type.

  * The internal name of a class is its fully qualified name, where '.' are

  * replaced by '/'. This method should only be used for an object type.

  *

  * @return the internal name of the class corresponding to this object type.

  */

 public String getInternalName(){

 	return new String(buf, off + 1, len - 2);

 }

 

 // ------------------------------------------------------------------------

 // Conversion to type descriptors

 // ------------------------------------------------------------------------

 

 /**

  * Returns the descriptor corresponding to this Java type.

  *

  * @return the descriptor corresponding to this Java type.

  */

 public String getDescriptor(){

 	StringBuffer buf = new StringBuffer();

 	getDescriptor(buf);

 	return buf.toString();

 }

 

 /**

  * Returns the descriptor corresponding to the given argument and return

  * types.

  *

  * @param returnType    the return type of the method.

  * @param argumentTypes the argument types of the method.

  * @return the descriptor corresponding to the given argument and return

  *         types.

  */

 public static String getMethodDescriptor(

 		final Type returnType,

 		final Type[] argumentTypes){

 	StringBuffer buf = new StringBuffer();

 	buf.append('(');

 	for(int i = 0; i < argumentTypes.length; ++i)

 		{

 		argumentTypes[i].getDescriptor(buf);

 		}

 	buf.append(')');

 	returnType.getDescriptor(buf);

 	return buf.toString();

 }

 

 /**

  * Appends the descriptor corresponding to this Java type to the given

  * string buffer.

  *

  * @param buf the string buffer to which the descriptor must be appended.

  */

 private void getDescriptor(final StringBuffer buf){

 	switch(sort)

 		{

 		case VOID:

 			buf.append('V');

 			return;

 		case BOOLEAN:

 			buf.append('Z');

 			return;

 		case CHAR:

 			buf.append('C');

 			return;

 		case BYTE:

 			buf.append('B');

 			return;

 		case SHORT:

 			buf.append('S');

 			return;

 		case INT:

 			buf.append('I');

 			return;

 		case FLOAT:

 			buf.append('F');

 			return;

 		case LONG:

 			buf.append('J');

 			return;

 		case DOUBLE:

 			buf.append('D');

 			return;

 			// case ARRAY:

 			// case OBJECT:

 		default:

 			buf.append(this.buf, off, len);

 		}

 }

 

 // ------------------------------------------------------------------------

 // Direct conversion from classes to type descriptors,

 // without intermediate Type objects

 // ------------------------------------------------------------------------

 

 /**

  * Returns the internal name of the given class. The internal name of a

  * class is its fully qualified name, where '.' are replaced by '/'.

  *

  * @param c an object class.

  * @return the internal name of the given class.

  */

 public static String getInternalName(final Class c){

 	return c.getName().replace('.', '/');

 }

 

 /**

  * Returns the descriptor corresponding to the given Java type.

  *

  * @param c an object class, a primitive class or an array class.

  * @return the descriptor corresponding to the given class.

  */

 public static String getDescriptor(final Class c){

 	StringBuffer buf = new StringBuffer();

 	getDescriptor(buf, c);

 	return buf.toString();

 }

 

 /**

  * Returns the descriptor corresponding to the given constructor.

  *

  * @param c a {@link Constructor Constructor} object.

  * @return the descriptor of the given constructor.

  */

 public static String getConstructorDescriptor(final Constructor c){

 	Class[] parameters = c.getParameterTypes();

 	StringBuffer buf = new StringBuffer();

 	buf.append('(');

 	for(int i = 0; i < parameters.length; ++i)

 		{

 		getDescriptor(buf, parameters[i]);

 		}

 	return buf.append(")V").toString();

 }

 

 /**

  * Returns the descriptor corresponding to the given method.

  *

  * @param m a {@link Method Method} object.

  * @return the descriptor of the given method.

  */

 public static String getMethodDescriptor(final Method m){

 	Class[] parameters = m.getParameterTypes();

 	StringBuffer buf = new StringBuffer();

 	buf.append('(');

 	for(int i = 0; i < parameters.length; ++i)

 		{

 		getDescriptor(buf, parameters[i]);

 		}

 	buf.append(')');

 	getDescriptor(buf, m.getReturnType());

 	return buf.toString();

 }

 

 /**

  * Appends the descriptor of the given class to the given string buffer.

  *

  * @param buf the string buffer to which the descriptor must be appended.

  * @param c   the class whose descriptor must be computed.

  */

 private static void getDescriptor(final StringBuffer buf, final Class c){

 	Class d = c;

 	while(true)

 		{

 		if(d.isPrimitive())

 			{

 			char car;

 			if(d == Integer.TYPE)

 				{

 				car = 'I';

 				}

 			else if(d == Void.TYPE)

 				{

 				car = 'V';

 				}

 			else if(d == Boolean.TYPE)

 				{

 				car = 'Z';

 				}

 			else if(d == Byte.TYPE)

 				{

 				car = 'B';

 				}

 			else if(d == Character.TYPE)

 				{

 				car = 'C';

 				}

 			else if(d == Short.TYPE)

 				{

 				car = 'S';

 				}

 			else if(d == Double.TYPE)

 				{

 				car = 'D';

 				}

 			else if(d == Float.TYPE)

 				{

 				car = 'F';

 				}

 			else /* if (d == Long.TYPE) */

 				{

 				car = 'J';

 				}

 			buf.append(car);

 			return;

 			}

 		else if(d.isArray())

 			{

 			buf.append('[');

 			d = d.getComponentType();

 			}

 		else

 			{

 			buf.append('L');

 			String name = d.getName();

 			int len = name.length();

 			for(int i = 0; i < len; ++i)

 				{

 				char car = name.charAt(i);

 				buf.append(car == '.' ? '/' : car);

 				}

 			buf.append(';');

 			return;

 			}

 		}

 }

 

 // ------------------------------------------------------------------------

 // Corresponding size and opcodes

 // ------------------------------------------------------------------------

 

 /**

  * Returns the size of values of this type.

  *

  * @return the size of values of this type, i.e., 2 for <tt>long</tt> and

  *         <tt>double</tt>, and 1 otherwise.

  */

 public int getSize(){

 	return sort == LONG || sort == DOUBLE ? 2 : 1;

 }

 

 /**

  * Returns a JVM instruction opcode adapted to this Java type.

  *

  * @param opcode a JVM instruction opcode. This opcode must be one of ILOAD,

  *               ISTORE, IALOAD, IASTORE, IADD, ISUB, IMUL, IDIV, IREM, INEG, ISHL,

  *               ISHR, IUSHR, IAND, IOR, IXOR and IRETURN.

  * @return an opcode that is similar to the given opcode, but adapted to

  *         this Java type. For example, if this type is <tt>float</tt> and

  *         <tt>opcode</tt> is IRETURN, this method returns FRETURN.

  */

 public int getOpcode(final int opcode){

 	if(opcode == Opcodes.IALOAD || opcode == Opcodes.IASTORE)

 		{

 		switch(sort)

 			{

 			case BOOLEAN:

 			case BYTE:

 				return opcode + 5;

 			case CHAR:

 				return opcode + 6;

 			case SHORT:

 				return opcode + 7;

 			case INT:

 				return opcode;

 			case FLOAT:

 				return opcode + 2;

 			case LONG:

 				return opcode + 1;

 			case DOUBLE:

 				return opcode + 3;

 				// case ARRAY:

 				// case OBJECT:

 			default:

 				return opcode + 4;

 			}

 		}

 	else

 		{

 		switch(sort)

 			{

 			case VOID:

 				return opcode + 5;

 			case BOOLEAN:

 			case CHAR:

 			case BYTE:

 			case SHORT:

 			case INT:

 				return opcode;

 			case FLOAT:

 				return opcode + 2;

 			case LONG:

 				return opcode + 1;

 			case DOUBLE:

 				return opcode + 3;

 				// case ARRAY:

 				// case OBJECT:

 			default:

 				return opcode + 4;

 			}

 		}

 }

 

 // ------------------------------------------------------------------------

 // Equals, hashCode and toString

 // ------------------------------------------------------------------------

 

 /**

  * Tests if the given object is equal to this type.

  *

  * @param o the object to be compared to this type.

  * @return <tt>true</tt> if the given object is equal to this type.

  */

 public boolean equals(final Object o){

 	if(this == o)

 		{

 		return true;

 		}

 	if(!(o instanceof Type))

 		{

 		return false;

 		}

 	Type t = (Type) o;

 	if(sort != t.sort)

 		{

 		return false;

 		}

 	if(sort == Type.OBJECT || sort == Type.ARRAY)

 		{

 		if(len != t.len)

 			{

 			return false;

 			}

 		for(int i = off, j = t.off, end = i + len; i < end; i++, j++)

 			{

 			if(buf[i] != t.buf[j])

 				{

 				return false;

 				}

 			}

 		}

 	return true;

 }

 

 /**

  * Returns a hash code value for this type.

  *

  * @return a hash code value for this type.

  */

 public int hashCode(){

 	int hc = 13 * sort;

 	if(sort == Type.OBJECT || sort == Type.ARRAY)

 		{

 		for(int i = off, end = i + len; i < end; i++)

 			{

 			hc = 17 * (hc + buf[i]);

 			}

 		}

 	return hc;

 }

 

 /**

  * Returns a string representation of this type.

  *

  * @return the descriptor of this type.

  */

 public String toString(){

 	return getDescriptor();

 }

 }