clojure 1.0.0

data/src/jvm/clojure/asm/commons/LocalVariablesSorter.java

@@ -0,0 +1,330 @@
+/***
+ * 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.commons;
+
+import clojure.asm.Label;
+import clojure.asm.MethodAdapter;
+import clojure.asm.MethodVisitor;
+import clojure.asm.Opcodes;
+import clojure.asm.Type;
+
+/**
+ * A {@link MethodAdapter} that renumbers local variables in their order of
+ * appearance. This adapter allows one to easily add new local variables to a
+ * method. It may be used by inheriting from this class, but the preferred way
+ * of using it is via delegation: the next visitor in the chain can indeed add
+ * new locals when needed by calling {@link #newLocal} on this adapter (this
+ * requires a reference back to this {@link LocalVariablesSorter}).
+ *
+ * @author Chris Nokleberg
+ * @author Eugene Kuleshov
+ * @author Eric Bruneton
+ */
+public class LocalVariablesSorter extends MethodAdapter{
+
+private final static Type OBJECT_TYPE = Type.getObjectType("java/lang/Object");
+
+/**
+ * Mapping from old to new local variable indexes. A local variable at index
+ * i of size 1 is remapped to 'mapping[2*i]', while a local variable at
+ * index i of size 2 is remapped to 'mapping[2*i+1]'.
+ */
+private int[] mapping = new int[40];
+
+/**
+ * Array used to store stack map local variable types after remapping.
+ */
+private Object[] newLocals = new Object[20];
+
+/**
+ * Index of the first local variable, after formal parameters.
+ */
+protected final int firstLocal;
+
+/**
+ * Index of the next local variable to be created by {@link #newLocal}.
+ */
+protected int nextLocal;
+
+/**
+ * Indicates if at least one local variable has moved due to remapping.
+ */
+private boolean changed;
+
+/**
+ * Creates a new {@link LocalVariablesSorter}.
+ *
+ * @param access access flags of the adapted method.
+ * @param desc   the method's descriptor (see {@link Type Type}).
+ * @param mv     the method visitor to which this adapter delegates calls.
+ */
+public LocalVariablesSorter(
+		final int access,
+		final String desc,
+		final MethodVisitor mv){
+	super(mv);
+	Type[] args = Type.getArgumentTypes(desc);
+	nextLocal = (Opcodes.ACC_STATIC & access) != 0 ? 0 : 1;
+	for(int i = 0; i < args.length; i++)
+		{
+		nextLocal += args[i].getSize();
+		}
+	firstLocal = nextLocal;
+}
+
+public void visitVarInsn(final int opcode, final int var){
+	Type type;
+	switch(opcode)
+		{
+		case Opcodes.LLOAD:
+		case Opcodes.LSTORE:
+			type = Type.LONG_TYPE;
+			break;
+
+		case Opcodes.DLOAD:
+		case Opcodes.DSTORE:
+			type = Type.DOUBLE_TYPE;
+			break;
+
+		case Opcodes.FLOAD:
+		case Opcodes.FSTORE:
+			type = Type.FLOAT_TYPE;
+			break;
+
+		case Opcodes.ILOAD:
+		case Opcodes.ISTORE:
+			type = Type.INT_TYPE;
+			break;
+
+		case Opcodes.ALOAD:
+		case Opcodes.ASTORE:
+			type = OBJECT_TYPE;
+			break;
+
+			// case RET:
+		default:
+			type = Type.VOID_TYPE;
+		}
+	mv.visitVarInsn(opcode, remap(var, type));
+}
+
+public void visitIincInsn(final int var, final int increment){
+	mv.visitIincInsn(remap(var, Type.INT_TYPE), increment);
+}
+
+public void visitMaxs(final int maxStack, final int maxLocals){
+	mv.visitMaxs(maxStack, nextLocal);
+}
+
+public void visitLocalVariable(
+		final String name,
+		final String desc,
+		final String signature,
+		final Label start,
+		final Label end,
+		final int index){
+	int size = "J".equals(desc) || "D".equals(desc) ? 2 : 1;
+	int newIndex = remap(index, size);
+	mv.visitLocalVariable(name, desc, signature, start, end, newIndex);
+}
+
+public void visitFrame(
+		final int type,
+		final int nLocal,
+		final Object[] local,
+		final int nStack,
+		final Object[] stack){
+	if(type != Opcodes.F_NEW)
+		{ // uncompressed frame
+		throw new IllegalStateException("ClassReader.accept() should be called with EXPAND_FRAMES flag");
+		}
+
+	if(!changed)
+		{ // optimization for the case where mapping = identity
+		mv.visitFrame(type, nLocal, local, nStack, stack);
+		return;
+		}
+
+	// creates a copy of newLocals
+	Object[] oldLocals = new Object[newLocals.length];
+	System.arraycopy(newLocals, 0, oldLocals, 0, oldLocals.length);
+
+	// copies types from 'local' to 'newLocals'
+	// 'newLocals' already contains the variables added with 'newLocal'
+
+	int index = 0; // old local variable index
+	int number = 0; // old local variable number
+	for(; number < nLocal; ++number)
+		{
+		Object t = local[number];
+		int size = t == Opcodes.LONG || t == Opcodes.DOUBLE ? 2 : 1;
+		if(t != Opcodes.TOP)
+			{
+			setFrameLocal(remap(index, size), t);
+			}
+		index += size;
+		}
+
+	// removes TOP after long and double types as well as trailing TOPs
+
+	index = 0;
+	number = 0;
+	for(int i = 0; index < newLocals.length; ++i)
+		{
+		Object t = newLocals[index++];
+		if(t != null && t != Opcodes.TOP)
+			{
+			newLocals[i] = t;
+			number = i + 1;
+			if(t == Opcodes.LONG || t == Opcodes.DOUBLE)
+				{
+				index += 1;
+				}
+			}
+		else
+			{
+			newLocals[i] = Opcodes.TOP;
+			}
+		}
+
+	// visits remapped frame
+	mv.visitFrame(type, number, newLocals, nStack, stack);
+
+	// restores original value of 'newLocals'
+	newLocals = oldLocals;
+}
+
+// -------------
+
+/**
+ * Creates a new local variable of the given type.
+ *
+ * @param type the type of the local variable to be created.
+ * @return the identifier of the newly created local variable.
+ */
+public int newLocal(final Type type){
+	Object t;
+	switch(type.getSort())
+		{
+		case Type.BOOLEAN:
+		case Type.CHAR:
+		case Type.BYTE:
+		case Type.SHORT:
+		case Type.INT:
+			t = Opcodes.INTEGER;
+			break;
+		case Type.FLOAT:
+			t = Opcodes.FLOAT;
+			break;
+		case Type.LONG:
+			t = Opcodes.LONG;
+			break;
+		case Type.DOUBLE:
+			t = Opcodes.DOUBLE;
+			break;
+		case Type.ARRAY:
+			t = type.getDescriptor();
+			break;
+			// case Type.OBJECT:
+		default:
+			t = type.getInternalName();
+			break;
+		}
+	int local = nextLocal;
+	setLocalType(local, type);
+	setFrameLocal(local, t);
+	nextLocal += type.getSize();
+	return local;
+}
+
+/**
+ * Sets the current type of the given local variable. The default
+ * implementation of this method does nothing.
+ *
+ * @param local a local variable identifier, as returned by {@link #newLocal
+ *              newLocal()}.
+ * @param type  the type of the value being stored in the local variable
+ */
+protected void setLocalType(final int local, final Type type){
+}
+
+private void setFrameLocal(final int local, final Object type){
+	int l = newLocals.length;
+	if(local >= l)
+		{
+		Object[] a = new Object[Math.max(2 * l, local + 1)];
+		System.arraycopy(newLocals, 0, a, 0, l);
+		newLocals = a;
+		}
+	newLocals[local] = type;
+}
+
+private int remap(final int var, final Type type){
+	if(var < firstLocal)
+		{
+		return var;
+		}
+	int key = 2 * var + type.getSize() - 1;
+	int size = mapping.length;
+	if(key >= size)
+		{
+		int[] newMapping = new int[Math.max(2 * size, key + 1)];
+		System.arraycopy(mapping, 0, newMapping, 0, size);
+		mapping = newMapping;
+		}
+	int value = mapping[key];
+	if(value == 0)
+		{
+		value = nextLocal + 1;
+		mapping[key] = value;
+		setLocalType(nextLocal, type);
+		nextLocal += type.getSize();
+		}
+	if(value - 1 != var)
+		{
+		changed = true;
+		}
+	return value - 1;
+}
+
+private int remap(final int var, final int size){
+	if(var < firstLocal || !changed)
+		{
+		return var;
+		}
+	int key = 2 * var + size - 1;
+	int value = key < mapping.length ? mapping[key] : 0;
+	if(value == 0)
+		{
+		throw new IllegalStateException("Unknown local variable " + var);
+		}
+	return value - 1;
+}
+}

data/src/jvm/clojure/asm/commons/Method.java

@@ -0,0 +1,267 @@
+/***
+ * 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.commons;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import clojure.asm.Type;
+
+/**
+ * A named method descriptor.
+ *
+ * @author Juozas Baliuka
+ * @author Chris Nokleberg
+ * @author Eric Bruneton
+ */
+public class Method{
+
+/**
+ * The method name.
+ */
+private final String name;
+
+/**
+ * The method descriptor.
+ */
+private final String desc;
+
+/**
+ * Maps primitive Java type names to their descriptors.
+ */
+private final static Map DESCRIPTORS;
+
+static
+	{
+	DESCRIPTORS = new HashMap();
+	DESCRIPTORS.put("void", "V");
+	DESCRIPTORS.put("byte", "B");
+	DESCRIPTORS.put("char", "C");
+	DESCRIPTORS.put("double", "D");
+	DESCRIPTORS.put("float", "F");
+	DESCRIPTORS.put("int", "I");
+	DESCRIPTORS.put("long", "J");
+	DESCRIPTORS.put("short", "S");
+	DESCRIPTORS.put("boolean", "Z");
+	}
+
+/**
+ * Creates a new {@link Method}.
+ *
+ * @param name the method's name.
+ * @param desc the method's descriptor.
+ */
+public Method(final String name, final String desc){
+	this.name = name;
+	this.desc = desc;
+}
+
+/**
+ * Creates a new {@link Method}.
+ *
+ * @param name          the method's name.
+ * @param returnType    the method's return type.
+ * @param argumentTypes the method's argument types.
+ */
+public Method(
+		final String name,
+		final Type returnType,
+		final Type[] argumentTypes){
+	this(name, Type.getMethodDescriptor(returnType, argumentTypes));
+}
+
+/**
+ * Returns a {@link Method} corresponding to the given Java method
+ * declaration.
+ *
+ * @param method a Java method declaration, without argument names, of the
+ *               form "returnType name (argumentType1, ... argumentTypeN)", where
+ *               the types are in plain Java (e.g. "int", "float",
+ *               "java.util.List", ...). Classes of the java.lang package can be
+ *               specified by their unqualified name; all other classes names must
+ *               be fully qualified.
+ * @return a {@link Method} corresponding to the given Java method
+ *         declaration.
+ * @throws IllegalArgumentException if <code>method</code> could not get
+ *                                  parsed.
+ */
+public static Method getMethod(final String method)
+		throws IllegalArgumentException{
+	return getMethod(method, false);
+}
+
+/**
+ * Returns a {@link Method} corresponding to the given Java method
+ * declaration.
+ *
+ * @param method         a Java method declaration, without argument names, of the
+ *                       form "returnType name (argumentType1, ... argumentTypeN)", where
+ *                       the types are in plain Java (e.g. "int", "float",
+ *                       "java.util.List", ...). Classes of the java.lang package may be
+ *                       specified by their unqualified name, depending on the
+ *                       defaultPackage argument; all other classes names must be fully
+ *                       qualified.
+ * @param defaultPackage true if unqualified class names belong to the
+ *                       default package, or false if they correspond to java.lang classes.
+ *                       For instance "Object" means "Object" if this option is true, or
+ *                       "java.lang.Object" otherwise.
+ * @return a {@link Method} corresponding to the given Java method
+ *         declaration.
+ * @throws IllegalArgumentException if <code>method</code> could not get
+ *                                  parsed.
+ */
+public static Method getMethod(
+		final String method,
+		final boolean defaultPackage) throws IllegalArgumentException{
+	int space = method.indexOf(' ');
+	int start = method.indexOf('(', space) + 1;
+	int end = method.indexOf(')', start);
+	if(space == -1 || start == -1 || end == -1)
+		{
+		throw new IllegalArgumentException();
+		}
+	// TODO: Check validity of returnType, methodName and arguments.
+	String returnType = method.substring(0, space);
+	String methodName = method.substring(space + 1, start - 1).trim();
+	StringBuffer sb = new StringBuffer();
+	sb.append('(');
+	int p;
+	do
+		{
+		String s;
+		p = method.indexOf(',', start);
+		if(p == -1)
+			{
+			s = map(method.substring(start, end).trim(), defaultPackage);
+			}
+		else
+			{
+			s = map(method.substring(start, p).trim(), defaultPackage);
+			start = p + 1;
+			}
+		sb.append(s);
+		} while(p != -1);
+	sb.append(')');
+	sb.append(map(returnType, defaultPackage));
+	return new Method(methodName, sb.toString());
+}
+
+private static String map(final String type, final boolean defaultPackage){
+	if(type.equals(""))
+		{
+		return type;
+		}
+
+	StringBuffer sb = new StringBuffer();
+	int index = 0;
+	while((index = type.indexOf("[]", index) + 1) > 0)
+		{
+		sb.append('[');
+		}
+
+	String t = type.substring(0, type.length() - sb.length() * 2);
+	String desc = (String) DESCRIPTORS.get(t);
+	if(desc != null)
+		{
+		sb.append(desc);
+		}
+	else
+		{
+		sb.append('L');
+		if(t.indexOf('.') < 0)
+			{
+			if(!defaultPackage)
+				{
+				sb.append("java/lang/");
+				}
+			sb.append(t);
+			}
+		else
+			{
+			sb.append(t.replace('.', '/'));
+			}
+		sb.append(';');
+		}
+	return sb.toString();
+}
+
+/**
+ * Returns the name of the method described by this object.
+ *
+ * @return the name of the method described by this object.
+ */
+public String getName(){
+	return name;
+}
+
+/**
+ * Returns the descriptor of the method described by this object.
+ *
+ * @return the descriptor of the method described by this object.
+ */
+public String getDescriptor(){
+	return desc;
+}
+
+/**
+ * Returns the return type of the method described by this object.
+ *
+ * @return the return type of the method described by this object.
+ */
+public Type getReturnType(){
+	return Type.getReturnType(desc);
+}
+
+/**
+ * Returns the argument types of the method described by this object.
+ *
+ * @return the argument types of the method described by this object.
+ */
+public Type[] getArgumentTypes(){
+	return Type.getArgumentTypes(desc);
+}
+
+public String toString(){
+	return name + desc;
+}
+
+public boolean equals(final Object o){
+	if(!(o instanceof Method))
+		{
+		return false;
+		}
+	Method other = (Method) o;
+	return name.equals(other.name) && desc.equals(other.desc);
+}
+
+public int hashCode(){
+	return name.hashCode() ^ desc.hashCode();
+}
+}