Add ModifyArgs injector for modifying multiple args, closes #162

This commit is contained in:
Mumfrey committed 2017-06-27 13:23:15 +01:00
1 parent 114fbc99d7
commit 48c8ab7c5a
18 files changed
+1282 -20

No files matched your search

@@ -0,0 +1,166 @@
/*
* This file is part of Mixin, licensed under the MIT License (MIT).
*
* Copyright (c) SpongePowered <https://www.spongepowered.org>
* Copyright (c) contributors
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.spongepowered.asm.mixin.injection;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.spongepowered.asm.mixin.MixinEnvironment.Option;
import org.spongepowered.asm.mixin.injection.invoke.arg.Args;
import org.spongepowered.asm.mixin.injection.throwables.InjectionError;
import org.spongepowered.asm.mixin.injection.throwables.InvalidInjectionException;
import org.spongepowered.asm.util.ConstraintParser.Constraint;
/**
* Specifies that this mixin method should inject an multi-argument modifier
* callback to itself in the target method(s) identified by {@link #method}.
* This type of injector provides a powerful but inefficient method for
* modifying multiple arguments of a method at once without making use of a
* {@link Redirect} injector. In general it is better to use redirectors where
* possible, however this type of injector can also function where {@link
* Redirect} cannot, such as modifying arguments of a super-constructor call. To
* modify a single method argument, use {@link ModifyArg} instead.
*
* <p>This injector works by creating an <em>argument bundle</em> in the form of
* {@link Args} which is passed to your handler method. You can manipulate the
* method arguments via the bundle in your handler method. The bundle is then
* unpacked and the original method is called with the modified arguments.</p>
*
* <p>Since the argument bundle is created for every invocation of the target
* method, and primitive types must undergo boxing and unboxing, this injector
* is intrinsically less efficient than other methods. However for certain uses
* this injector is more powerful:</p>
*
* <ul>
* <li>For modifying arguments of a superconstructor call, it would normally
* be necessary to employ multiple {@link ModifyArg} callbacks (one for each
* argument you wish to modify). However access to the enclosing scope is
* not provided by {@link ModifyArg}, which can be problematic.</li>
* <li>This injector can be used to target multiple methods with differing
* argument types and counts.</li>
* </ul>
*
* <p>Methods decorated with this injector should return <tt>void</tt> and
* return either:</p>
*
* <ul>
* <li>A single argument of type {@link Args}</li>
* <li>A single {@link Args} argument followed by the arguments of the
* enclosing target method.</li>
* </ul>
*/
@Target({ ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
public @interface ModifyArgs {
/**
* String representation of a
* {@link org.spongepowered.asm.mixin.injection.struct.MemberInfo
* MemberInfo} which identifies the target method.
*
* @return target method
*/
public String method();
/**
* A {@link Slice} annotation which describes the method bisection used in
* the {@link #at} query for this injector.
*
* @return slice
*/
public Slice slice() default @Slice;
/**
* An {@link At} annotation which describes the {@link InjectionPoint} in
* the target method. The specified {@link InjectionPoint} <i>must only</i>
* return {@link org.spongepowered.asm.lib.tree.MethodInsnNode} instances
* and an exception will be thrown if this is not the case.
*
* @return {@link At} which identifies the target method invocation
*/
public At at();
/**
* By default, the annotation processor will attempt to locate an
* obfuscation mapping for all {@link ModifyArgs} methods since it is
* anticipated that in general the target of a {@link ModifyArgs} annotation
* will be an obfuscated method in the target class. However since it is
* possible to also apply mixins to non-obfuscated targets (or non-
* obfuscated methods in obfuscated targets, such as methods added by Forge)
* it may be necessary to suppress the compiler error which would otherwise
* be generated. Setting this value to <em>false</em> will cause the
* annotation processor to skip this annotation when attempting to build the
* obfuscation table for the mixin.
*
* @return True to instruct the annotation processor to search for
* obfuscation mappings for this annotation
*/
public boolean remap() default true;
/**
* In general, injectors are intended to "fail soft" in that a failure to
* locate the injection point in the target method is not considered an
* error condition. Another transformer may have changed the method
* structure or any number of reasons may cause an injection to fail. This
* also makes it possible to define several injections to achieve the same
* task given <em>expected</em> mutation of the target class and the
* injectors which fail are simply ignored.
*
* <p>However, this behaviour is not always desirable. For example, if your
* application depends on a particular injection succeeding you may wish to
* detect the injection failure as an error condition. This argument is thus
* provided to allow you to stipulate a <b>minimum</b> number of successful
* injections for this callback handler. If the number of injections
* specified is not achieved then an {@link InjectionError} is thrown at
* application time. Use this option with care.</p>
*
* @return Minimum required number of injected callbacks, default specified
* by the containing config
*/
public int require() default -1;
/**
* Like {@link #require()} but only enabled if the
* {@link Option#DEBUG_INJECTORS mixin.debug.countInjections} option is set
* to <tt>true</tt> and defaults to 1. Use this option during debugging to
* perform simple checking of your injectors. Causes the injector to throw
* a {@link InvalidInjectionException} if the expected number of injections
* is not realised.
*
* @return Minimum number of <em>expected</em> callbacks, default 1
*/
public int expect() default 1;
/**
* Returns constraints which must be validated for this injector to
* succeed. See {@link Constraint} for details of constraint formats.
*
* @return Constraints for this annotation
*/
public String constraints() default "";
}
@@ -52,8 +52,6 @@ import org.spongepowered.asm.mixin.injection.struct.Target;
import org.spongepowered.asm.mixin.injection.throwables.InvalidInjectionException;
import org.spongepowered.asm.util.Bytecode;
import com.google.common.base.Joiner;
/**
* Base class for bytecode injectors
*/
@@ -272,10 +270,6 @@ public abstract class Injector {
insns.add(new InsnNode(Opcodes.ATHROW));
}
protected static String printArgs(Type[] args) {
return "(" + Joiner.on("").join(args) + ")";
}
/**
* Returns whether the <tt>from</tt> type can be coerced to the <tt>to</tt>
* type.
@@ -30,12 +30,12 @@ import java.util.List;
import org.spongepowered.asm.lib.Type;
import org.spongepowered.asm.lib.tree.InsnList;
import org.spongepowered.asm.lib.tree.MethodInsnNode;
import org.spongepowered.asm.mixin.injection.InjectionPoint;
import org.spongepowered.asm.mixin.injection.InjectionNodes.InjectionNode;
import org.spongepowered.asm.mixin.injection.code.Injector;
import org.spongepowered.asm.mixin.injection.InjectionPoint;
import org.spongepowered.asm.mixin.injection.struct.InjectionInfo;
import org.spongepowered.asm.mixin.injection.struct.Target;
import org.spongepowered.asm.mixin.injection.throwables.InvalidInjectionException;
import org.spongepowered.asm.util.Bytecode;
/**
* A bytecode injector which allows a single argument of a chosen method call to
@@ -132,7 +132,7 @@ public class ModifyArgInjector extends InvokeInjector {
private int injectMultiArgHandler(Target target, Type[] args, int argIndex, InsnList insns) {
if (!Arrays.equals(args, this.methodArgs)) {
throw new InvalidInjectionException(this.info, "@ModifyArg method " + this + " targets a method with an invalid signature "
+ Injector.printArgs(args) + ", expected " + Injector.printArgs(this.methodArgs));
+ Bytecode.getDescriptor(args) + ", expected " + Bytecode.getDescriptor(this.methodArgs));
}
int[] argMap = this.storeArgs(target, args, insns, 0);
@@ -146,7 +146,7 @@ public class ModifyArgInjector extends InvokeInjector {
if (this.index > -1) {
if (this.index >= args.length || !args[this.index].equals(this.returnType)) {
throw new InvalidInjectionException(this.info, "Specified index " + this.index + " for @ModifyArg is invalid for args "
+ Injector.printArgs(args) + ", expected " + this.returnType + " on " + this);
+ Bytecode.getDescriptor(args) + ", expected " + this.returnType + " on " + this);
}
return this.index;
}
@@ -0,0 +1,129 @@
/*
* This file is part of Mixin, licensed under the MIT License (MIT).
*
* Copyright (c) SpongePowered <https://www.spongepowered.org>
* Copyright (c) contributors
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.spongepowered.asm.mixin.injection.invoke;
import org.spongepowered.asm.lib.Opcodes;
import org.spongepowered.asm.lib.Type;
import org.spongepowered.asm.lib.tree.InsnList;
import org.spongepowered.asm.lib.tree.InsnNode;
import org.spongepowered.asm.lib.tree.MethodInsnNode;
import org.spongepowered.asm.lib.tree.VarInsnNode;
import org.spongepowered.asm.mixin.injection.InjectionNodes.InjectionNode;
import org.spongepowered.asm.mixin.injection.invoke.arg.ArgsClassGenerator;
import org.spongepowered.asm.mixin.injection.struct.InjectionInfo;
import org.spongepowered.asm.mixin.injection.struct.Target;
import org.spongepowered.asm.mixin.injection.throwables.InvalidInjectionException;
import org.spongepowered.asm.util.Bytecode;
/**
* A bytecode injector which allows a single argument of a chosen method call to
* be altered.
*/
public class ModifyArgsInjector extends InvokeInjector {
/**
* @param info Injection info
* @param index target arg index
*/
public ModifyArgsInjector(InjectionInfo info) {
super(info, "@ModifyArgs");
}
/* (non-Javadoc)
* @see org.spongepowered.asm.mixin.injection.invoke.InvokeInjector
* #checkTarget(org.spongepowered.asm.mixin.injection.struct.Target)
*/
@Override
protected void checkTarget(Target target) {
if (!this.isStatic && target.isStatic) {
throw new InvalidInjectionException(this.info, "non-static callback method " + this + " targets a static method which is not supported");
}
}
/**
* Do the injection
*/
@Override
protected void injectAtInvoke(Target target, InjectionNode node) {
MethodInsnNode targetMethod = (MethodInsnNode)node.getCurrentTarget();
Type[] args = Type.getArgumentTypes(targetMethod.desc);
if (args.length == 0) {
throw new InvalidInjectionException(this.info, "@ModifyArgs injector " + this + " targets a method invocation "
+ targetMethod.name + targetMethod.desc + " with no arguments!");
}
String argClass = ArgsClassGenerator.getInstance().getClassRef(targetMethod.desc);
boolean withArgs = false;
String shortDesc = String.format("(L%s;)V", ArgsClassGenerator.CREF_ARGS);
if (!this.methodNode.desc.equals(shortDesc)) {
String targetDesc = Bytecode.changeDescriptorReturnType(target.method.desc, "V");
String longDesc = String.format("(L%s;%s", ArgsClassGenerator.CREF_ARGS, targetDesc.substring(1));
if (this.methodNode.desc.equals(longDesc)) {
withArgs = true;
} else {
throw new InvalidInjectionException(this.info, "@ModifyArgs injector " + this + " has an invalid signature "
+ this.methodNode.desc + ", expected " + shortDesc + " or " + longDesc);
}
}
InsnList insns = new InsnList();
target.addToStack(1);
String factoryDesc = Bytecode.changeDescriptorReturnType(targetMethod.desc, "L" + argClass + ";");
insns.add(new MethodInsnNode(Opcodes.INVOKESTATIC, argClass, "of", factoryDesc, false));
insns.add(new InsnNode(Opcodes.DUP));
if (!this.isStatic) {
insns.add(new VarInsnNode(Opcodes.ALOAD, 0));
insns.add(new InsnNode(Opcodes.SWAP));
}
if (withArgs) {
target.addToStack(Bytecode.getArgsSize(target.arguments));
Bytecode.loadArgs(target.arguments, insns, target.isStatic ? 0 : 1);
}
this.invokeHandler(insns);
for (int i = 0; i < args.length; i++) {
if (i < args.length - 1) {
insns.add(new InsnNode(Opcodes.DUP));
}
insns.add(new MethodInsnNode(Opcodes.INVOKEVIRTUAL, argClass, ArgsClassGenerator.GETTER + i, "()" + args[i].getDescriptor(), false));
if (i < args.length - 1) {
if (args[i].getSize() == 1) {
insns.add(new InsnNode(Opcodes.SWAP));
} else {
insns.add(new InsnNode(Opcodes.DUP2_X1));
insns.add(new InsnNode(Opcodes.POP2));
}
}
}
target.insns.insertBefore(targetMethod, insns);
}
}
@@ -309,9 +309,9 @@ public class RedirectInjector extends InvokeInjector {
final Type[] stackVars = targetIsStatic ? args : ObjectArrays.concat(ownerType, args);
boolean injectTargetParams = false;
String desc = Injector.printArgs(stackVars) + returnType;
String desc = Bytecode.getDescriptor(stackVars, returnType);
if (!desc.equals(this.methodNode.desc)) {
String alternateDesc = Injector.printArgs(ObjectArrays.concat(stackVars, target.arguments, Type.class)) + returnType;
String alternateDesc = Bytecode.getDescriptor(ObjectArrays.concat(stackVars, target.arguments, Type.class), returnType);
if (alternateDesc.equals(this.methodNode.desc)) {
injectTargetParams = true;
} else {
@@ -0,0 +1,102 @@
/*
* This file is part of Mixin, licensed under the MIT License (MIT).
*
* Copyright (c) SpongePowered <https://www.spongepowered.org>
* Copyright (c) contributors
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.spongepowered.asm.mixin.injection.invoke.arg;
import org.spongepowered.asm.mixin.injection.ModifyArgs;
/**
* Argument bundle class used in {@link ModifyArgs} callbacks. See the
* documentation for {@link ModifyArgs} for details. Synthetic subclasses are
* generated at runtime for specific injectors.
*/
public abstract class Args {
/**
* Argument values
*/
protected final Object[] values;
/**
* Ctor.
*
* @param values argument values
*/
protected Args(Object[] values) {
this.values = values;
}
/**
* Return the argument list size.
*
* @return number of arguments available
*/
public int size() {
return this.values.length;
}
/**
* Retrieve the argument value at the specified index
*
* @param index argument index to retrieve
* @param <T> the argument type
* @return the argument value
* @throws ArrayIndexOutOfBoundsException if a value outside the range of
* available arguments is accessed
*/
@SuppressWarnings("unchecked")
public <T> T get(int index) {
return (T)this.values[index];
}
/**
* Set (modify) the specified argument value. Internal verification is
* performed upon supplied values and the following requirements are
* enforced:
*
* <ul>
* <li>Reference types must be assignable to the object type, or can be
* <tt>null</tt>.
* <li>Primitive types must match the target types exactly and <b>cannot
* </b> be <tt>null</tt>.
* </ul>
*
* @param index Argument index to set
* @param value Argument value
* @param <T> Argument type
* @throws ArgumentIndexOutOfBoundsException if the specified argument index
* is outside the range of available arguments
*/
public abstract <T> void set(int index, T value);
/**
* Set (modify) all argument values. The number and type of arguments
* supplied to this method must precisely match the argument types in the
* bundle. See {@link #set(int, Object)} for details.
*
* @param values Argument values to set
*/
public abstract void setAll(Object... values);
}
@@ -0,0 +1,515 @@
/*
* This file is part of Mixin, licensed under the MIT License (MIT).
*
* Copyright (c) SpongePowered <https://www.spongepowered.org>
* Copyright (c) contributors
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.spongepowered.asm.mixin.injection.invoke.arg;
import java.util.HashMap;
import java.util.Map;
import org.spongepowered.asm.lib.ClassVisitor;
import org.spongepowered.asm.lib.ClassWriter;
import org.spongepowered.asm.lib.Label;
import org.spongepowered.asm.lib.MethodVisitor;
import org.spongepowered.asm.lib.Opcodes;
import org.spongepowered.asm.lib.Type;
import org.spongepowered.asm.lib.util.CheckClassAdapter;
import org.spongepowered.asm.mixin.MixinEnvironment;
import org.spongepowered.asm.mixin.MixinEnvironment.Option;
import org.spongepowered.asm.mixin.injection.ModifyArgs;
import org.spongepowered.asm.mixin.transformer.IClassGenerator;
import org.spongepowered.asm.util.Bytecode;
import org.spongepowered.asm.util.Constants;
import org.spongepowered.asm.util.SignaturePrinter;
import org.spongepowered.asm.util.visitor.MethodVisitorEx;
import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;
/**
* Class generator which creates subclasses of {@link Args} to be used by the
* {@link ModifyArgs} injector. The subclasses contain getter and setter logic
* to provide access to a particular configuration of arguments and classes are
* only generated for each unique argument combination.
*/
public final class ArgsClassGenerator implements IClassGenerator {
public static final String CLASS_NAME_BASE = "org.spongepowered.asm.synthetic.Args$";
public static final String GETTER = "$";
private static final String OBJECT = "java/lang/Object";
private static final String OBJECT_ARRAY = "[L" + ArgsClassGenerator.OBJECT + ";";
public static final String CNAME_ARGS = Args.class.getName();
public static final String CREF_ARGS = ArgsClassGenerator.CNAME_ARGS.replace('.', '/');
private static final String CTOR_DESC = "(" + ArgsClassGenerator.OBJECT_ARRAY + ")V";
private static final String VALUES_FIELD = "values";
private static final String NPE = "java/lang/NullPointerException";
private static final String AIOOBE = "org/spongepowered/asm/mixin/injection/invoke/arg/ArgumentIndexOutOfBoundsException";
private static final String ACE = "org/spongepowered/asm/mixin/injection/invoke/arg/ArgumentCountException";
/**
* Singleton instance
*/
private static ArgsClassGenerator instance;
/**
* The next subclass number, classes generated in sequence eg.
* <tt>Args$1</tt>, <tt>Args$2</tt>, etc.
*/
private int nextIndex = 1;
/**
* Map of descriptors to generated class names
*/
private final BiMap<String, String> classNames = HashBiMap.<String, String>create();
/**
* Generated bytes. Technically a generator shouldn't have to return class
* bytes for a class more than once, but this saves the class being
* regenerated if anything causes a second invocation of {@link #generate}
* for the same class
*/
private final Map<String, byte[]> classBytes = new HashMap<String, byte[]>();
private ArgsClassGenerator() {
// singleton (for now)
}
/**
* Get (or generate) the class name for the specified descriptor. The class
* will not be generated until it is used. Calling this method simply
* allocates a name for the specified descriptor.
*
* @param desc Descriptor of the <em>target</em> method, with the return
* type changed to void (V)
* @return name of the Args subclass to use
*/
public String getClassName(String desc) {
if (!desc.endsWith(")V")) {
throw new IllegalArgumentException("Invalid @ModifyArgs method descriptor");
}
String name = this.classNames.get(desc);
if (name == null) {
name = String.format("%s%d", ArgsClassGenerator.CLASS_NAME_BASE, this.nextIndex++);
this.classNames.put(desc, name);
}
return name;
}
/**
* Get (or generate) the class name for the specified descriptor in internal
* format (reference). The class will not be generated until it is used.
* Calling this method simply allocates a name for the specified descriptor.
*
* @param desc Descriptor of the <em>target</em> method, with the return
* type changed to void (V)
* @return reference of the Args subclass to use
*/
public String getClassRef(String desc) {
return this.getClassName(desc).replace('.', '/');
}
/* (non-Javadoc)
* @see org.spongepowered.asm.mixin.transformer.IClassGenerator#generate
* (java.lang.String)
*/
@Override
public byte[] generate(String name) {
return this.getBytes(name);
}
/**
* Fetch or generate class bytes for the specified class name. Returns null
* if this generator does not have bytes for the specified class.
*
* @param name Class name
* @return class bytes or null
*/
public byte[] getBytes(String name) {
byte[] bytes = this.classBytes.get(name);
if (bytes == null) {
String desc = this.classNames.inverse().get(name);
if (desc == null) {
return null;
}
bytes = this.generateClass(name, desc);
this.classBytes.put(name, bytes);
}
return bytes;
}
/**
* Generate an {@link Args} subclass
*
* @param name Class name to generate
* @param desc Argument descriptor (return type ignored)
* @return generated class
*/
private byte[] generateClass(String name, String desc) {
String ref = name.replace('.', '/');
Type[] args = Type.getArgumentTypes(desc);
ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
ClassVisitor visitor = writer;
if (MixinEnvironment.getCurrentEnvironment().getOption(Option.DEBUG_VERIFY)) {
visitor = new CheckClassAdapter(writer);
}
visitor.visit(Opcodes.V1_6, Opcodes.ACC_PUBLIC | Opcodes.ACC_SUPER, ref, null, ArgsClassGenerator.CREF_ARGS, null);
visitor.visitSource(name.substring(name.lastIndexOf('.') + 1) + ".java", null);
this.generateCtor(ref, desc, args, visitor);
this.generateFactory(ref, desc, args, visitor);
this.generateSetters(ref, desc, args, visitor);
this.generateGetters(ref, desc, args, visitor);
visitor.visitEnd();
return writer.toByteArray();
}
/**
* Generate the constructor for the subclass, the ctor simply calls the
* superclass ctor and does nothing else besides
*
* @param ref Class ref being generated
* @param desc Argument descriptor
* @param args Parsed argument list from descriptor
* @param writer Class writer
*/
private void generateCtor(String ref, String desc, Type[] args, ClassVisitor writer) {
MethodVisitor ctor = writer.visitMethod(Opcodes.ACC_PRIVATE, Constants.CTOR, ArgsClassGenerator.CTOR_DESC, null, null);
ctor.visitCode();
ctor.visitVarInsn(Opcodes.ALOAD, 0);
ctor.visitVarInsn(Opcodes.ALOAD, 1);
ctor.visitMethodInsn(Opcodes.INVOKESPECIAL, ArgsClassGenerator.CREF_ARGS, Constants.CTOR, ArgsClassGenerator.CTOR_DESC, false);
ctor.visitInsn(Opcodes.RETURN);
ctor.visitMaxs(2, 2);
ctor.visitEnd();
}
/**
* Generate the factory method (<tt>of</tt>) for the subclass, the factory
* method takes the arguments which would have been passed to the target
* method, marshals them into an <tt>Object[]</tt> array, and then calls the
* constructor.
*
* @param ref Class ref being generated
* @param desc Argument descriptor
* @param args Parsed argument list from descriptor
* @param writer Class writer
*/
private void generateFactory(String ref, String desc, Type[] args, ClassVisitor writer) {
String factoryDesc = Bytecode.changeDescriptorReturnType(desc, "L" + ref + ";");
MethodVisitorEx of = new MethodVisitorEx(writer.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "of", factoryDesc, null, null));
of.visitCode();
// Create args subclass
of.visitTypeInsn(Opcodes.NEW, ref);
of.visitInsn(Opcodes.DUP);
// Create Object[] array to contain args
of.visitConstant((byte)args.length);
of.visitTypeInsn(Opcodes.ANEWARRAY, ArgsClassGenerator.OBJECT);
// Iterate over args and stuff them into the array
byte argIndex = 0;
for (Type arg : args) {
of.visitInsn(Opcodes.DUP);
of.visitConstant(argIndex);
of.visitVarInsn(arg.getOpcode(Opcodes.ILOAD), argIndex++);
ArgsClassGenerator.box(of, arg);
of.visitInsn(Opcodes.AASTORE);
}
// Call the constructor passing in the generated array
of.visitMethodInsn(Opcodes.INVOKESPECIAL, ref, Constants.CTOR, ArgsClassGenerator.CTOR_DESC, false);
// Return the new object
of.visitInsn(Opcodes.ARETURN);
of.visitMaxs(6, Bytecode.getArgsSize(args));
of.visitEnd();
}
/**
* Generate the getter method for each arguments. These getters are not
* available from consumer code, but instead are called by the injector to
* retrieve each argument in turn for passing to the method invocation being
* modified.
*
* @param ref Class ref being generated
* @param desc Argument descriptor
* @param args Parsed argument list from descriptor
* @param writer Class writer
*/
private void generateGetters(String ref, String desc, Type[] args, ClassVisitor writer) {
byte argIndex = 0;
for (Type arg : args) {
String name = ArgsClassGenerator.GETTER + argIndex;
String sig = "()" + arg.getDescriptor();
MethodVisitorEx get = new MethodVisitorEx(writer.visitMethod(Opcodes.ACC_PUBLIC, name, sig, null, null));
get.visitCode();
// Read the value from the values field
get.visitVarInsn(Opcodes.ALOAD, 0);
get.visitFieldInsn(Opcodes.GETFIELD, ref, ArgsClassGenerator.VALUES_FIELD, ArgsClassGenerator.OBJECT_ARRAY);
get.visitConstant(argIndex);
get.visitInsn(Opcodes.AALOAD);
// Unbox (if primitive) or cast down the value
ArgsClassGenerator.unbox(get, arg);
// Return the value
get.visitInsn(arg.getOpcode(Opcodes.IRETURN));
get.visitMaxs(2, 1);
get.visitEnd();
argIndex++;
}
}
/**
* Generate the <tt>set</tt> method body. The <tt>set</tt> method performs a
* <tt>CHECKCAST</tt> on all incoming arguments, checks that the argument
* index is not out of bounds, and also ensures that primitive types are not
* assigned <tt>null</tt> by the consumer code.
*
* @param ref Class ref being generated
* @param desc Argument descriptor
* @param args Parsed argument list from descriptor
* @param writer Class writer
*/
private void generateSetters(String ref, String desc, Type[] args, ClassVisitor writer) {
this.generateIndexedSetter(ref, desc, args, writer);
this.generateMultiSetter(ref, desc, args, writer);
}
/**
* Generate the <tt>set</tt> method body. The <tt>set</tt> method performs a
* <tt>CHECKCAST</tt> on all incoming arguments, checks that the argument
* index is not out of bounds, and also ensures that primitive types are not
* assigned <tt>null</tt> by the consumer code.
*
* @param ref Class ref being generated
* @param desc Argument descriptor
* @param args Parsed argument list from descriptor
* @param writer Class writer
*/
private void generateIndexedSetter(String ref, String desc, Type[] args, ClassVisitor writer) {
MethodVisitorEx set = new MethodVisitorEx(writer.visitMethod(Opcodes.ACC_PUBLIC, "set", "(ILjava/lang/Object;)V", null, null));
set.visitCode();
Label store = new Label(), checkNull = new Label();
Label[] labels = new Label[args.length];
for (int label = 0; label < labels.length; label++) {
labels[label] = new Label();
}
// Put the values array on the stack to begin with
set.visitVarInsn(Opcodes.ALOAD, 0);
set.visitFieldInsn(Opcodes.GETFIELD, ref, ArgsClassGenerator.VALUES_FIELD, ArgsClassGenerator.OBJECT_ARRAY);
// Each argument index will jump to its own label
for (byte index = 0; index < args.length; index++) {
set.visitVarInsn(Opcodes.ILOAD, 1);
set.visitConstant(index);
set.visitJumpInsn(Opcodes.IF_ICMPEQ, labels[index]);
}
// No argument was matched, so we throw an out of bounds exception
ArgsClassGenerator.throwAIOOBE(set, 1);
// For each arg we do a CHECKCAST to ensure the supplied type is
// assignable to the arg type, we leave the index and value on the stack
// and jump to the next stage
for (int index = 0; index < args.length; index++) {
String boxingType = Bytecode.getBoxingType(args[index]);
set.visitLabel(labels[index]);
set.visitVarInsn(Opcodes.ILOAD, 1);
set.visitVarInsn(Opcodes.ALOAD, 2);
set.visitTypeInsn(Opcodes.CHECKCAST, boxingType != null ? boxingType : args[index].getInternalName());
set.visitJumpInsn(Opcodes.GOTO, boxingType != null ? checkNull : store);
}
// For primitive types, we check that the supplied value is not null
set.visitLabel(checkNull);
set.visitInsn(Opcodes.DUP);
set.visitJumpInsn(Opcodes.IFNONNULL, store);
// If the arg type is primitive but the user supplied NULL, throw an exception
ArgsClassGenerator.throwNPE(set, "Argument with primitive type cannot be set to NULL");
// Everything above succeeded, so we just assign the value into the array
set.visitLabel(store);
set.visitInsn(Opcodes.AASTORE);
set.visitInsn(Opcodes.RETURN);
set.visitMaxs(6, 3);
set.visitEnd();
}
/**
* Generate the varargs <tt>set</tt> method body. The <tt>set</tt> method
* performs a <tt>CHECKCAST</tt> on all incoming arguments, and also ensures
* that primitive types are not assigned <tt>null</tt> by the consumer code.
*
* @param ref Class ref being generated
* @param desc Argument descriptor
* @param args Parsed argument list from descriptor
* @param writer Class writer
*/
private void generateMultiSetter(String ref, String desc, Type[] args, ClassVisitor writer) {
MethodVisitorEx set = new MethodVisitorEx(writer.visitMethod(Opcodes.ACC_PUBLIC, "setAll", "([Ljava/lang/Object;)V", null, null));
set.visitCode();
Label lengthOk = new Label(), nullPrimitive = new Label();
int maxStack = 6;
// Compare the length of the varargs array to the expected argument count
set.visitVarInsn(Opcodes.ALOAD, 1);
set.visitInsn(Opcodes.ARRAYLENGTH);
set.visitInsn(Opcodes.DUP);
set.visitConstant((byte)args.length);
// If the lengths are the same, proceed with assignment
set.visitJumpInsn(Opcodes.IF_ICMPEQ, lengthOk);
set.visitTypeInsn(Opcodes.NEW, ArgsClassGenerator.ACE);
set.visitInsn(Opcodes.DUP);
set.visitInsn(Opcodes.DUP2_X1);
set.visitInsn(Opcodes.POP2);
set.visitConstant((byte)args.length);
set.visitLdcInsn(new SignaturePrinter("", null, args).setFullyQualified(true).getFormattedArgs());
set.visitMethodInsn(Opcodes.INVOKESPECIAL, ArgsClassGenerator.ACE, Constants.CTOR, "(IILjava/lang/String;)V", false);
set.visitInsn(Opcodes.ATHROW);
set.visitLabel(lengthOk);
set.visitInsn(Opcodes.POP); // Pop the remaining length value
// Put the values array on the stack to begin with
set.visitVarInsn(Opcodes.ALOAD, 0);
set.visitFieldInsn(Opcodes.GETFIELD, ref, ArgsClassGenerator.VALUES_FIELD, ArgsClassGenerator.OBJECT_ARRAY);
for (byte index = 0; index < args.length; index++) {
// Dup the member array reference and target index
set.visitInsn(Opcodes.DUP);
set.visitConstant(index);
// Read the value from the varargs array
set.visitVarInsn(Opcodes.ALOAD, 1);
set.visitConstant(index);
set.visitInsn(Opcodes.AALOAD);
// Check the argument type
String boxingType = Bytecode.getBoxingType(args[index]);
set.visitTypeInsn(Opcodes.CHECKCAST, boxingType != null ? boxingType : args[index].getInternalName());
// For primitives, check the value is not null
if (boxingType != null) {
set.visitInsn(Opcodes.DUP);
set.visitJumpInsn(Opcodes.IFNULL, nullPrimitive);
maxStack = 7;
}
// Everything succeeded, assign the value
set.visitInsn(Opcodes.AASTORE);
}
set.visitInsn(Opcodes.RETURN);
set.visitLabel(nullPrimitive);
ArgsClassGenerator.throwNPE(set, "Argument with primitive type cannot be set to NULL");
set.visitInsn(Opcodes.RETURN);
set.visitMaxs(maxStack, 2);
set.visitEnd();
}
private static void throwNPE(MethodVisitorEx method, String message) {
method.visitTypeInsn(Opcodes.NEW, ArgsClassGenerator.NPE);
method.visitInsn(Opcodes.DUP);
method.visitLdcInsn(message);
method.visitMethodInsn(Opcodes.INVOKESPECIAL, ArgsClassGenerator.NPE, Constants.CTOR, "(Ljava/lang/String;)V", false);
method.visitInsn(Opcodes.ATHROW);
}
private static void throwAIOOBE(MethodVisitorEx method, int arg) {
method.visitTypeInsn(Opcodes.NEW, ArgsClassGenerator.AIOOBE);
method.visitInsn(Opcodes.DUP);
method.visitVarInsn(Opcodes.ILOAD, arg);
method.visitMethodInsn(Opcodes.INVOKESPECIAL, ArgsClassGenerator.AIOOBE, Constants.CTOR, "(I)V", false);
method.visitInsn(Opcodes.ATHROW);
}
/**
* Box (if necessary) the supplied primitive type. Does not affect
* reference types.
*
* @param method method visitor
* @param var type to box
*/
private static void box(MethodVisitor method, Type var) {
String boxingType = Bytecode.getBoxingType(var);
if (boxingType != null) {
String desc = String.format("(%s)L%s;", var.getDescriptor(), boxingType);
method.visitMethodInsn(Opcodes.INVOKESTATIC, boxingType, "valueOf", desc, false);
}
}
/**
* Unbox (if necessary, otherwise just <tt>CHECKCAST</tt>) the supplied type
*
* @param method method visitor
* @param var type to unbox
*/
private static void unbox(MethodVisitor method, Type var) {
String boxingType = Bytecode.getBoxingType(var);
if (boxingType != null) {
String unboxingMethod = Bytecode.getUnboxingMethod(var);
String desc = "()" + var.getDescriptor();
method.visitTypeInsn(Opcodes.CHECKCAST, boxingType);
method.visitMethodInsn(Opcodes.INVOKEVIRTUAL, boxingType, unboxingMethod, desc, false);
} else {
method.visitTypeInsn(Opcodes.CHECKCAST, var.getInternalName());
}
}
/**
* Get the singleton instance
*
* @return the singleton instance
*/
public static ArgsClassGenerator getInstance() {
if (ArgsClassGenerator.instance == null) {
ArgsClassGenerator.instance = new ArgsClassGenerator();
}
return ArgsClassGenerator.instance;
}
}
@@ -0,0 +1,39 @@
/*
* This file is part of Mixin, licensed under the MIT License (MIT).
*
* Copyright (c) SpongePowered <https://www.spongepowered.org>
* Copyright (c) contributors
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.spongepowered.asm.mixin.injection.invoke.arg;
/**
* Exception thrown when varargs array passed into {@link Args#setAll}
* is of a different length than the args
*/
public class ArgumentCountException extends IllegalArgumentException {
private static final long serialVersionUID = 1L;
public ArgumentCountException(int received, int expected, String desc) {
super("Invalid number of arguments for setAll, received " + received + " but expected " + expected + ": " + desc);
}
}
@@ -0,0 +1,39 @@
/*
* This file is part of Mixin, licensed under the MIT License (MIT).
*
* Copyright (c) SpongePowered <https://www.spongepowered.org>
* Copyright (c) contributors
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.spongepowered.asm.mixin.injection.invoke.arg;
/**
* Exception thrown when attempting to set an argument (via) {@link Args} which
* is out of bounds
*/
public class ArgumentIndexOutOfBoundsException extends IndexOutOfBoundsException {
private static final long serialVersionUID = 1L;
public ArgumentIndexOutOfBoundsException(int index) {
super("Argument index is out of bounds: " + index);
}
}
@@ -45,6 +45,7 @@ import org.spongepowered.asm.mixin.injection.InjectionNodes.InjectionNode;
import org.spongepowered.asm.mixin.injection.InjectionPoint;
import org.spongepowered.asm.mixin.injection.InjectorGroupInfo;
import org.spongepowered.asm.mixin.injection.ModifyArg;
import org.spongepowered.asm.mixin.injection.ModifyArgs;
import org.spongepowered.asm.mixin.injection.ModifyConstant;
import org.spongepowered.asm.mixin.injection.ModifyVariable;
import org.spongepowered.asm.mixin.injection.Redirect;
@@ -60,8 +61,8 @@ import org.spongepowered.asm.mixin.struct.SpecialMethodInfo;
import org.spongepowered.asm.mixin.transformer.MixinTargetContext;
import org.spongepowered.asm.mixin.transformer.meta.MixinMerged;
import org.spongepowered.asm.mixin.transformer.throwables.InvalidMixinException;
import org.spongepowered.asm.util.Bytecode;
import org.spongepowered.asm.util.Annotations;
import org.spongepowered.asm.util.Bytecode;
/**
* Contructs information about an injection from an {@link Inject} annotation
@@ -408,6 +409,8 @@ public abstract class InjectionInfo extends SpecialMethodInfo implements ISliceC
return new CallbackInjectionInfo(mixin, method, annotation);
} else if (annotation.desc.endsWith(ModifyArg.class.getSimpleName() + ";")) {
return new ModifyArgInjectionInfo(mixin, method, annotation);
} else if (annotation.desc.endsWith(ModifyArgs.class.getSimpleName() + ";")) {
return new ModifyArgsInjectionInfo(mixin, method, annotation);
} else if (annotation.desc.endsWith(Redirect.class.getSimpleName() + ";")) {
return new RedirectInjectionInfo(mixin, method, annotation);
} else if (annotation.desc.endsWith(ModifyVariable.class.getSimpleName() + ";")) {
@@ -435,6 +438,7 @@ public abstract class InjectionInfo extends SpecialMethodInfo implements ISliceC
annotation = Annotations.getSingleVisible(method,
Inject.class,
ModifyArg.class,
ModifyArgs.class,
Redirect.class,
ModifyVariable.class,
ModifyConstant.class
@@ -456,6 +460,8 @@ public abstract class InjectionInfo extends SpecialMethodInfo implements ISliceC
if (annotation != null) {
if (annotation.desc.endsWith(ModifyArg.class.getSimpleName() + ";")) {
return "modify";
} else if (annotation.desc.endsWith(ModifyArgs.class.getSimpleName() + ";")) {
return "args";
} else if (annotation.desc.endsWith(Redirect.class.getSimpleName() + ";")) {
return "redirect";
} else if (annotation.desc.endsWith(ModifyVariable.class.getSimpleName() + ";")) {
@@ -0,0 +1,53 @@
/*
* This file is part of Mixin, licensed under the MIT License (MIT).
*
* Copyright (c) SpongePowered <https://www.spongepowered.org>
* Copyright (c) contributors
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.spongepowered.asm.mixin.injection.struct;
import org.spongepowered.asm.lib.tree.AnnotationNode;
import org.spongepowered.asm.lib.tree.MethodNode;
import org.spongepowered.asm.mixin.injection.ModifyArgs;
import org.spongepowered.asm.mixin.injection.code.Injector;
import org.spongepowered.asm.mixin.injection.invoke.ModifyArgsInjector;
import org.spongepowered.asm.mixin.transformer.MixinTargetContext;
/**
* Information about a {@link ModifyArgs} injector
*/
public class ModifyArgsInjectionInfo extends InjectionInfo {
public ModifyArgsInjectionInfo(MixinTargetContext mixin, MethodNode method, AnnotationNode annotation) {
super(mixin, method, annotation);
}
@Override
protected Injector parseInjector(AnnotationNode injectAnnotation) {
return new ModifyArgsInjector(this);
}
@Override
protected String getDescription() {
return "Multi-argument modifier method";
}
}
@@ -0,0 +1,43 @@
/*
* This file is part of Mixin, licensed under the MIT License (MIT).
*
* Copyright (c) SpongePowered <https://www.spongepowered.org>
* Copyright (c) contributors
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.spongepowered.asm.mixin.transformer;
/**
* Base interface for class generators
*/
public interface IClassGenerator {
/**
* Generate (if possible) the specified class name. The generator should
* return <tt>null</tt> if it cannot generate the specified class, in order
* that the next generator in the chain can process the request. The first
* generator to return a value will halt further processing of the request.
*
* @param name Class name to generate
* @return Class bytecode or null
*/
public abstract byte[] generate(String name);
}
@@ -51,6 +51,7 @@ import org.spongepowered.asm.mixin.MixinEnvironment.Option;
import org.spongepowered.asm.mixin.Overwrite;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.ModifyArg;
import org.spongepowered.asm.mixin.injection.ModifyArgs;
import org.spongepowered.asm.mixin.injection.ModifyConstant;
import org.spongepowered.asm.mixin.injection.ModifyVariable;
import org.spongepowered.asm.mixin.injection.Redirect;
@@ -58,8 +59,8 @@ import org.spongepowered.asm.mixin.transformer.ClassInfo.Field;
import org.spongepowered.asm.mixin.transformer.meta.MixinMerged;
import org.spongepowered.asm.mixin.transformer.meta.MixinRenamed;
import org.spongepowered.asm.mixin.transformer.throwables.InvalidMixinException;
import org.spongepowered.asm.util.Bytecode;
import org.spongepowered.asm.util.Annotations;
import org.spongepowered.asm.util.Bytecode;
import org.spongepowered.asm.util.Constants;
import org.spongepowered.asm.util.ConstraintParser;
import org.spongepowered.asm.util.ConstraintParser.Constraint;
@@ -80,6 +81,7 @@ class MixinApplicatorStandard {
Overwrite.class,
Inject.class,
ModifyArg.class,
ModifyArgs.class,
Redirect.class,
ModifyVariable.class,
ModifyConstant.class
@@ -53,6 +53,7 @@ import org.spongepowered.asm.mixin.extensibility.IMixinConfigPlugin;
import org.spongepowered.asm.mixin.extensibility.IMixinErrorHandler;
import org.spongepowered.asm.mixin.extensibility.IMixinErrorHandler.ErrorAction;
import org.spongepowered.asm.mixin.extensibility.IMixinInfo;
import org.spongepowered.asm.mixin.injection.invoke.arg.ArgsClassGenerator;
import org.spongepowered.asm.mixin.throwables.ClassAlreadyLoadedException;
import org.spongepowered.asm.mixin.throwables.MixinApplyError;
import org.spongepowered.asm.mixin.throwables.MixinException;
@@ -403,6 +404,11 @@ public class MixinTransformer extends TreeTransformer {
*/
private final List<IMixinTransformerModule> modules = new ArrayList<IMixinTransformerModule>();
/**
* Modules which generate synthetic classes required by mixins
*/
private final List<IClassGenerator> generators = new ArrayList<IClassGenerator>();
/**
* Re-entrance detector
*/
@@ -469,6 +475,8 @@ public class MixinTransformer extends TreeTransformer {
this.exporter = new Exporter();
this.hotSwapper = this.initHotSwapper();
this.postProcessor = new MixinPostProcessor();
this.generators.add(ArgsClassGenerator.getInstance());
}
private IHotSwap initHotSwapper() {
@@ -526,7 +534,17 @@ public class MixinTransformer extends TreeTransformer {
*/
@Override
public synchronized byte[] transform(String name, String transformedName, byte[] basicClass) {
if (basicClass == null || transformedName == null || this.errorState) {
if (transformedName == null || this.errorState) {
return basicClass;
}
if (basicClass == null) {
for (IClassGenerator generator : this.generators) {
if ((basicClass = generator.generate(transformedName)) != null) {
this.exporter.export(transformedName.replace('.', '/'), true, basicClass);
return basicClass;
}
}
return basicClass;
}
@@ -42,6 +42,7 @@ import org.spongepowered.asm.lib.tree.*;
import org.spongepowered.asm.lib.util.CheckClassAdapter;
import org.spongepowered.asm.lib.util.TraceClassVisitor;
import com.google.common.base.Joiner;
import com.google.common.primitives.Ints;
/**
@@ -144,6 +145,42 @@ public final class Bytecode {
"I", //"S"
};
/**
* Mapping of {@link Type#getSort()} return values to boxing types
*/
private static final String[] BOXING_TYPES = {
null,
"java/lang/Boolean",
"java/lang/Character",
"java/lang/Byte",
"java/lang/Short",
"java/lang/Integer",
"java/lang/Float",
"java/lang/Long",
"java/lang/Double",
null,
null,
null
};
/**
* Mapping of {@link Type#getSort()} return values to boxing types
*/
private static final String[] UNBOXING_METHODS = {
null,
"booleanValue",
"charValue",
"byteValue",
"shortValue",
"intValue",
"floatValue",
"longValue",
"doubleValue",
null,
null,
null
};
private Bytecode() {
// utility class
}
@@ -541,6 +578,44 @@ public final class Bytecode {
}
return arg == null ? "" : arg.toString();
}
/**
* Generate a method descriptor without return type for the supplied args
* array
*
* @param args argument types
* @return method descriptor without return type
*/
public static String getDescriptor(Type[] args) {
return "(" + Joiner.on("").join(args) + ")";
}
/**
* Generate a method descriptor with the specified types
*
* @param args argument types
* @param returnType return type
* @return generated method descriptor
*/
public static String getDescriptor(Type[] args, Type returnType) {
return Bytecode.getDescriptor(args) + returnType.toString();
}
/**
* Changes the return type of a method descriptor to the specified symbol
*
* @param desc descriptor to modify
* @param returnType new return type
* @return modified descriptor;
*/
public static String changeDescriptorReturnType(String desc, String returnType) {
if (desc == null) {
return null;
} else if (returnType == null) {
return desc;
}
return desc.substring(0, desc.lastIndexOf(')') + 1) + returnType;
}
/**
* Returns the simple name of an annotation, mainly used for printing
@@ -787,4 +862,28 @@ public final class Bytecode {
return Math.max(min, max + pad);
}
/**
* Get the boxing type name for the specified type, if it is a primitive.
* For non-primitive types, <tt>null</tt> is returned
*
* @param type type to box
* @return boxing type or null
*/
public static String getBoxingType(Type type) {
return type == null ? null : Bytecode.BOXING_TYPES[type.getSort()];
}
/**
* Get the unboxing method name for the specified primitive type's
* corresponding reference type. For example, if the type passed in is
* <tt>int</tt>, then the return value will be <tt>intValue</tt>. Returns
* <tt>null</tt> for non-primitive types.
*
* @param type primitive type to get unboxing method for
* @return unboxing method name or <tt>null</tt>
*/
public static String getUnboxingMethod(Type type) {
return type == null ? null : Bytecode.UNBOXING_METHODS[type.getSort()];
}
}
@@ -127,7 +127,7 @@ public class SignaturePrinter {
* Return only the arguments portion of this signature as a Java-style block
*/
public String getFormattedArgs() {
return this.appendArgs(new StringBuilder(), true).toString();
return this.appendArgs(new StringBuilder(), true, true).toString();
}
/**
@@ -193,25 +193,25 @@ public class SignaturePrinter {
*/
@Override
public String toString() {
return this.appendArgs(new StringBuilder().append(this.modifiers).append(" ").append(this.name), false).toString();
return this.appendArgs(new StringBuilder().append(this.modifiers).append(" ").append(this.name), false, true).toString();
}
/**
* Return this signature in descriptor format (return type after args)
*/
public String toDescriptor() {
StringBuilder args = this.appendArgs(new StringBuilder(), true);
StringBuilder args = this.appendArgs(new StringBuilder(), true, false);
return args.append(SignaturePrinter.getTypeName(this.returnType, false, this.fullyQualified)).toString();
}
private StringBuilder appendArgs(StringBuilder sb, boolean typesOnly) {
private StringBuilder appendArgs(StringBuilder sb, boolean typesOnly, boolean pretty) {
sb.append('(');
for (int var = 0; var < this.argTypes.length; var++) {
if (this.argTypes[var] == null) {
continue;
} else if (var > 0) {
sb.append(',');
if (!typesOnly) {
if (pretty) {
sb.append(' ');
}
}
@@ -0,0 +1,54 @@
/*
* This file is part of Mixin, licensed under the MIT License (MIT).
*
* Copyright (c) SpongePowered <https://www.spongepowered.org>
* Copyright (c) contributors
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.spongepowered.asm.util.visitor;
import org.spongepowered.asm.lib.MethodVisitor;
import org.spongepowered.asm.lib.Opcodes;
import org.spongepowered.asm.util.Bytecode;
/**
* MethodVisitor with some extra convenience functionality
*/
public class MethodVisitorEx extends MethodVisitor {
public MethodVisitorEx(MethodVisitor mv) {
super(Opcodes.ASM5, mv);
}
/**
* Visit a byte constant instruction. The most specific constant instruction
* will be used where possible
*
* @param constant constant value to visit
*/
public void visitConstant(byte constant) {
if (constant > -2 && constant < 6) {
this.visitInsn(Bytecode.CONSTANTS_INT[constant + 1]);
return;
}
this.visitIntInsn(Opcodes.BIPUSH, constant);
}
}