clojure 1.0.0

data/src/jvm/clojure/asm/Opcodes.java

@@ -0,0 +1,341 @@
+/***
+ * 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;
+
+/**
+ * Defines the JVM opcodes, access flags and array type codes. This interface
+ * does not define all the JVM opcodes because some opcodes are automatically
+ * handled. For example, the xLOAD and xSTORE opcodes are automatically replaced
+ * by xLOAD_n and xSTORE_n opcodes when possible. The xLOAD_n and xSTORE_n
+ * opcodes are therefore not defined in this interface. Likewise for LDC,
+ * automatically replaced by LDC_W or LDC2_W when necessary, WIDE, GOTO_W and
+ * JSR_W.
+ *
+ * @author Eric Bruneton
+ * @author Eugene Kuleshov
+ */
+public interface Opcodes{
+
+// versions
+
+int V1_1 = 3 << 16 | 45;
+int V1_2 = 0 << 16 | 46;
+int V1_3 = 0 << 16 | 47;
+int V1_4 = 0 << 16 | 48;
+int V1_5 = 0 << 16 | 49;
+int V1_6 = 0 << 16 | 50;
+
+// access flags
+
+int ACC_PUBLIC = 0x0001; // class, field, method
+int ACC_PRIVATE = 0x0002; // class, field, method
+int ACC_PROTECTED = 0x0004; // class, field, method
+int ACC_STATIC = 0x0008; // field, method
+int ACC_FINAL = 0x0010; // class, field, method
+int ACC_SUPER = 0x0020; // class
+int ACC_SYNCHRONIZED = 0x0020; // method
+int ACC_VOLATILE = 0x0040; // field
+int ACC_BRIDGE = 0x0040; // method
+int ACC_VARARGS = 0x0080; // method
+int ACC_TRANSIENT = 0x0080; // field
+int ACC_NATIVE = 0x0100; // method
+int ACC_INTERFACE = 0x0200; // class
+int ACC_ABSTRACT = 0x0400; // class, method
+int ACC_STRICT = 0x0800; // method
+int ACC_SYNTHETIC = 0x1000; // class, field, method
+int ACC_ANNOTATION = 0x2000; // class
+int ACC_ENUM = 0x4000; // class(?) field inner
+
+// ASM specific pseudo access flags
+
+int ACC_DEPRECATED = 131072; // class, field, method
+
+// types for NEWARRAY
+
+int T_BOOLEAN = 4;
+int T_CHAR = 5;
+int T_FLOAT = 6;
+int T_DOUBLE = 7;
+int T_BYTE = 8;
+int T_SHORT = 9;
+int T_INT = 10;
+int T_LONG = 11;
+
+// stack map frame types
+
+/**
+ * Represents an expanded frame. See {@link ClassReader#EXPAND_FRAMES}.
+ */
+int F_NEW = -1;
+
+/**
+ * Represents a compressed frame with complete frame data.
+ */
+int F_FULL = 0;
+
+/**
+ * Represents a compressed frame where locals are the same as the locals in
+ * the previous frame, except that additional 1-3 locals are defined, and
+ * with an empty stack.
+ */
+int F_APPEND = 1;
+
+/**
+ * Represents a compressed frame where locals are the same as the locals in
+ * the previous frame, except that the last 1-3 locals are absent and with
+ * an empty stack.
+ */
+int F_CHOP = 2;
+
+/**
+ * Represents a compressed frame with exactly the same locals as the
+ * previous frame and with an empty stack.
+ */
+int F_SAME = 3;
+
+/**
+ * Represents a compressed frame with exactly the same locals as the
+ * previous frame and with a single value on the stack.
+ */
+int F_SAME1 = 4;
+
+Integer TOP = new Integer(0);
+Integer INTEGER = new Integer(1);
+Integer FLOAT = new Integer(2);
+Integer DOUBLE = new Integer(3);
+Integer LONG = new Integer(4);
+Integer NULL = new Integer(5);
+Integer UNINITIALIZED_THIS = new Integer(6);
+
+// opcodes // visit method (- = idem)
+
+int NOP = 0; // visitInsn
+int ACONST_NULL = 1; // -
+int ICONST_M1 = 2; // -
+int ICONST_0 = 3; // -
+int ICONST_1 = 4; // -
+int ICONST_2 = 5; // -
+int ICONST_3 = 6; // -
+int ICONST_4 = 7; // -
+int ICONST_5 = 8; // -
+int LCONST_0 = 9; // -
+int LCONST_1 = 10; // -
+int FCONST_0 = 11; // -
+int FCONST_1 = 12; // -
+int FCONST_2 = 13; // -
+int DCONST_0 = 14; // -
+int DCONST_1 = 15; // -
+int BIPUSH = 16; // visitIntInsn
+int SIPUSH = 17; // -
+int LDC = 18; // visitLdcInsn
+// int LDC_W = 19; // -
+// int LDC2_W = 20; // -
+int ILOAD = 21; // visitVarInsn
+int LLOAD = 22; // -
+int FLOAD = 23; // -
+int DLOAD = 24; // -
+int ALOAD = 25; // -
+// int ILOAD_0 = 26; // -
+// int ILOAD_1 = 27; // -
+// int ILOAD_2 = 28; // -
+// int ILOAD_3 = 29; // -
+// int LLOAD_0 = 30; // -
+// int LLOAD_1 = 31; // -
+// int LLOAD_2 = 32; // -
+// int LLOAD_3 = 33; // -
+// int FLOAD_0 = 34; // -
+// int FLOAD_1 = 35; // -
+// int FLOAD_2 = 36; // -
+// int FLOAD_3 = 37; // -
+// int DLOAD_0 = 38; // -
+// int DLOAD_1 = 39; // -
+// int DLOAD_2 = 40; // -
+// int DLOAD_3 = 41; // -
+// int ALOAD_0 = 42; // -
+// int ALOAD_1 = 43; // -
+// int ALOAD_2 = 44; // -
+// int ALOAD_3 = 45; // -
+int IALOAD = 46; // visitInsn
+int LALOAD = 47; // -
+int FALOAD = 48; // -
+int DALOAD = 49; // -
+int AALOAD = 50; // -
+int BALOAD = 51; // -
+int CALOAD = 52; // -
+int SALOAD = 53; // -
+int ISTORE = 54; // visitVarInsn
+int LSTORE = 55; // -
+int FSTORE = 56; // -
+int DSTORE = 57; // -
+int ASTORE = 58; // -
+// int ISTORE_0 = 59; // -
+// int ISTORE_1 = 60; // -
+// int ISTORE_2 = 61; // -
+// int ISTORE_3 = 62; // -
+// int LSTORE_0 = 63; // -
+// int LSTORE_1 = 64; // -
+// int LSTORE_2 = 65; // -
+// int LSTORE_3 = 66; // -
+// int FSTORE_0 = 67; // -
+// int FSTORE_1 = 68; // -
+// int FSTORE_2 = 69; // -
+// int FSTORE_3 = 70; // -
+// int DSTORE_0 = 71; // -
+// int DSTORE_1 = 72; // -
+// int DSTORE_2 = 73; // -
+// int DSTORE_3 = 74; // -
+// int ASTORE_0 = 75; // -
+// int ASTORE_1 = 76; // -
+// int ASTORE_2 = 77; // -
+// int ASTORE_3 = 78; // -
+int IASTORE = 79; // visitInsn
+int LASTORE = 80; // -
+int FASTORE = 81; // -
+int DASTORE = 82; // -
+int AASTORE = 83; // -
+int BASTORE = 84; // -
+int CASTORE = 85; // -
+int SASTORE = 86; // -
+int POP = 87; // -
+int POP2 = 88; // -
+int DUP = 89; // -
+int DUP_X1 = 90; // -
+int DUP_X2 = 91; // -
+int DUP2 = 92; // -
+int DUP2_X1 = 93; // -
+int DUP2_X2 = 94; // -
+int SWAP = 95; // -
+int IADD = 96; // -
+int LADD = 97; // -
+int FADD = 98; // -
+int DADD = 99; // -
+int ISUB = 100; // -
+int LSUB = 101; // -
+int FSUB = 102; // -
+int DSUB = 103; // -
+int IMUL = 104; // -
+int LMUL = 105; // -
+int FMUL = 106; // -
+int DMUL = 107; // -
+int IDIV = 108; // -
+int LDIV = 109; // -
+int FDIV = 110; // -
+int DDIV = 111; // -
+int IREM = 112; // -
+int LREM = 113; // -
+int FREM = 114; // -
+int DREM = 115; // -
+int INEG = 116; // -
+int LNEG = 117; // -
+int FNEG = 118; // -
+int DNEG = 119; // -
+int ISHL = 120; // -
+int LSHL = 121; // -
+int ISHR = 122; // -
+int LSHR = 123; // -
+int IUSHR = 124; // -
+int LUSHR = 125; // -
+int IAND = 126; // -
+int LAND = 127; // -
+int IOR = 128; // -
+int LOR = 129; // -
+int IXOR = 130; // -
+int LXOR = 131; // -
+int IINC = 132; // visitIincInsn
+int I2L = 133; // visitInsn
+int I2F = 134; // -
+int I2D = 135; // -
+int L2I = 136; // -
+int L2F = 137; // -
+int L2D = 138; // -
+int F2I = 139; // -
+int F2L = 140; // -
+int F2D = 141; // -
+int D2I = 142; // -
+int D2L = 143; // -
+int D2F = 144; // -
+int I2B = 145; // -
+int I2C = 146; // -
+int I2S = 147; // -
+int LCMP = 148; // -
+int FCMPL = 149; // -
+int FCMPG = 150; // -
+int DCMPL = 151; // -
+int DCMPG = 152; // -
+int IFEQ = 153; // visitJumpInsn
+int IFNE = 154; // -
+int IFLT = 155; // -
+int IFGE = 156; // -
+int IFGT = 157; // -
+int IFLE = 158; // -
+int IF_ICMPEQ = 159; // -
+int IF_ICMPNE = 160; // -
+int IF_ICMPLT = 161; // -
+int IF_ICMPGE = 162; // -
+int IF_ICMPGT = 163; // -
+int IF_ICMPLE = 164; // -
+int IF_ACMPEQ = 165; // -
+int IF_ACMPNE = 166; // -
+int GOTO = 167; // -
+int JSR = 168; // -
+int RET = 169; // visitVarInsn
+int TABLESWITCH = 170; // visiTableSwitchInsn
+int LOOKUPSWITCH = 171; // visitLookupSwitch
+int IRETURN = 172; // visitInsn
+int LRETURN = 173; // -
+int FRETURN = 174; // -
+int DRETURN = 175; // -
+int ARETURN = 176; // -
+int RETURN = 177; // -
+int GETSTATIC = 178; // visitFieldInsn
+int PUTSTATIC = 179; // -
+int GETFIELD = 180; // -
+int PUTFIELD = 181; // -
+int INVOKEVIRTUAL = 182; // visitMethodInsn
+int INVOKESPECIAL = 183; // -
+int INVOKESTATIC = 184; // -
+int INVOKEINTERFACE = 185; // -
+// int UNUSED = 186; // NOT VISITED
+int NEW = 187; // visitTypeInsn
+int NEWARRAY = 188; // visitIntInsn
+int ANEWARRAY = 189; // visitTypeInsn
+int ARRAYLENGTH = 190; // visitInsn
+int ATHROW = 191; // -
+int CHECKCAST = 192; // visitTypeInsn
+int INSTANCEOF = 193; // -
+int MONITORENTER = 194; // visitInsn
+int MONITOREXIT = 195; // -
+// int WIDE = 196; // NOT VISITED
+int MULTIANEWARRAY = 197; // visitMultiANewArrayInsn
+int IFNULL = 198; // visitJumpInsn
+int IFNONNULL = 199; // -
+// int GOTO_W = 200; // -
+// int JSR_W = 201; // -
+}

data/src/jvm/clojure/asm/Type.java

@@ -0,0 +1,872 @@
+/***
+ * 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();
+}
+}