From 6c9cab65597897f41dbdc7d9e59e2cd9a4f7721f Mon Sep 17 00:00:00 2001
From: Mumfrey
Date: Wed, 24 Dec 2014 01:08:32 +0000
Subject: [PATCH] Initial injection support, lots directly copy/pasted from
LiteLoader
---
.../asm/mixin/MixinEnvironment.java | 4 +-
.../spongepowered/asm/mixin/injection/At.java | 47 +
.../asm/mixin/injection/Inject.java | 43 +
.../asm/mixin/injection/InjectionInfo.java | 227 +++++
.../asm/mixin/injection/InjectionPoint.java | 408 +++++++++
.../injection/InvalidInjectionException.java | 46 +
.../injection/callback/CallbackInfo.java | 135 +++
.../callback/CallbackInfoReturnable.java | 137 +++
.../injection/callback/CallbackInjector.java | 297 +++++++
.../mixin/injection/callback/Cancellable.java | 32 +
.../callback/CancellationException.java | 29 +
.../injection/points/BeforeFieldAccess.java | 36 +
.../mixin/injection/points/BeforeInvoke.java | 199 +++++
.../asm/mixin/injection/points/BeforeNew.java | 76 ++
.../mixin/injection/points/BeforeReturn.java | 64 ++
.../injection/points/BeforeStringInvoke.java | 80 ++
.../mixin/injection/points/JumpInsnPoint.java | 65 ++
.../mixin/injection/points/MethodHead.java | 36 +
.../injection/struct/InjectionPointData.java | 130 +++
.../mixin/injection/struct/MemberInfo.java | 188 ++++
.../injection/tree/ReadOnlyInsnList.java | 151 ++++
.../asm/mixin/transformer/MixinInfo.java | 2 +-
.../mixin/transformer/MixinTransformer.java | 35 +-
.../org/spongepowered/asm/util/ASMHelper.java | 21 +
.../asm/util/ByteCodeUtilities.java | 809 ++++++++++++++++++
25 files changed, 3291 insertions(+), 6 deletions(-)
create mode 100644 src/main/java/org/spongepowered/asm/mixin/injection/At.java
create mode 100644 src/main/java/org/spongepowered/asm/mixin/injection/Inject.java
create mode 100644 src/main/java/org/spongepowered/asm/mixin/injection/InjectionInfo.java
create mode 100644 src/main/java/org/spongepowered/asm/mixin/injection/InjectionPoint.java
create mode 100644 src/main/java/org/spongepowered/asm/mixin/injection/InvalidInjectionException.java
create mode 100644 src/main/java/org/spongepowered/asm/mixin/injection/callback/CallbackInfo.java
create mode 100644 src/main/java/org/spongepowered/asm/mixin/injection/callback/CallbackInfoReturnable.java
create mode 100644 src/main/java/org/spongepowered/asm/mixin/injection/callback/CallbackInjector.java
create mode 100644 src/main/java/org/spongepowered/asm/mixin/injection/callback/Cancellable.java
create mode 100644 src/main/java/org/spongepowered/asm/mixin/injection/callback/CancellationException.java
create mode 100644 src/main/java/org/spongepowered/asm/mixin/injection/points/BeforeFieldAccess.java
create mode 100644 src/main/java/org/spongepowered/asm/mixin/injection/points/BeforeInvoke.java
create mode 100644 src/main/java/org/spongepowered/asm/mixin/injection/points/BeforeNew.java
create mode 100644 src/main/java/org/spongepowered/asm/mixin/injection/points/BeforeReturn.java
create mode 100644 src/main/java/org/spongepowered/asm/mixin/injection/points/BeforeStringInvoke.java
create mode 100644 src/main/java/org/spongepowered/asm/mixin/injection/points/JumpInsnPoint.java
create mode 100644 src/main/java/org/spongepowered/asm/mixin/injection/points/MethodHead.java
create mode 100644 src/main/java/org/spongepowered/asm/mixin/injection/struct/InjectionPointData.java
create mode 100644 src/main/java/org/spongepowered/asm/mixin/injection/struct/MemberInfo.java
create mode 100644 src/main/java/org/spongepowered/asm/mixin/injection/tree/ReadOnlyInsnList.java
create mode 100644 src/main/java/org/spongepowered/asm/util/ByteCodeUtilities.java
diff --git a/src/main/java/org/spongepowered/asm/mixin/MixinEnvironment.java b/src/main/java/org/spongepowered/asm/mixin/MixinEnvironment.java
index 6a52b7ef..4c6d5ac0 100644
--- a/src/main/java/org/spongepowered/asm/mixin/MixinEnvironment.java
+++ b/src/main/java/org/spongepowered/asm/mixin/MixinEnvironment.java
@@ -67,9 +67,11 @@ public class MixinEnvironment {
/**
* Add a mixin configuration to the blackboard
+ * @return
*/
- public void addConfiguration(String config) {
+ public MixinEnvironment addConfiguration(String config) {
this.getMixinConfigs().add(config);
+ return this;
}
public Object getActiveTransformer() {
diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/At.java b/src/main/java/org/spongepowered/asm/mixin/injection/At.java
new file mode 100644
index 00000000..e7ccf466
--- /dev/null
+++ b/src/main/java/org/spongepowered/asm/mixin/injection/At.java
@@ -0,0 +1,47 @@
+/**
+ * This file is part of Sponge, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 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;
+
+public @interface At {
+ public enum Shift {
+ NONE,
+ BEFORE,
+ AFTER
+ }
+
+ public String value();
+
+ public String[] args() default {};
+
+ public String target() default "";
+
+ public Shift shift() default Shift.NONE;
+
+ public int ordinal() default -1;
+
+ public int opcode() default -1;
+}
+
+
diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/Inject.java b/src/main/java/org/spongepowered/asm/mixin/injection/Inject.java
new file mode 100644
index 00000000..21d4e3cc
--- /dev/null
+++ b/src/main/java/org/spongepowered/asm/mixin/injection/Inject.java
@@ -0,0 +1,43 @@
+/**
+ * This file is part of Sponge, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 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;
+
+@Target({ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Inject {
+
+ public String method();
+
+ public boolean cancellable() default false;
+
+// public boolean captureLocals() default false;
+
+ public At[] at();
+}
diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/InjectionInfo.java b/src/main/java/org/spongepowered/asm/mixin/injection/InjectionInfo.java
new file mode 100644
index 00000000..29b1e214
--- /dev/null
+++ b/src/main/java/org/spongepowered/asm/mixin/injection/InjectionInfo.java
@@ -0,0 +1,227 @@
+/**
+ * This file is part of Sponge, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 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.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Deque;
+import java.util.List;
+
+import org.objectweb.asm.tree.AnnotationNode;
+import org.objectweb.asm.tree.ClassNode;
+import org.objectweb.asm.tree.MethodNode;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInjector;
+import org.spongepowered.asm.mixin.injection.struct.MemberInfo;
+import org.spongepowered.asm.util.ASMHelper;
+
+
+/**
+ * Contructs information about an injection from an {@link Inject} annotation and allows the injection to be processed
+ *
+ * @author Adam Mummery-Smith
+ */
+public class InjectionInfo {
+
+ /**
+ * Class
+ */
+ private final ClassNode classNode;
+
+ /**
+ * Annotated method
+ */
+ private final MethodNode method;
+
+ /**
+ * Annotated method is static
+ */
+ private final boolean isStatic;
+
+ /**
+ * True if the injection should be cancellable
+ */
+ private boolean cancellable;
+
+ /**
+ * True if the injection should capture local variables
+ */
+ private boolean captureLocals;
+
+ /**
+ * Target method(s)
+ */
+ private final Deque targets = new ArrayDeque();
+
+ /**
+ * Injection points parsed from {@link At} annotations
+ */
+ private final List injectionPoints = new ArrayList();
+
+ /**
+ * Bytecode injector
+ */
+ private CallbackInjector injector;
+
+ /**
+ * ctor
+ *
+ * @param classNode Class
+ * @param method Method
+ * @param injectAnnotation Annotation to parse
+ */
+ public InjectionInfo(ClassNode classNode, MethodNode method, AnnotationNode injectAnnotation) {
+ this.classNode = classNode;
+ this.method = method;
+ this.isStatic = ASMHelper.methodIsStatic(method);
+ this.parse(injectAnnotation);
+ }
+
+ /**
+ * Parse the info from the supplied annotation
+ */
+ private void parse(AnnotationNode injectAnnotation) {
+ if (injectAnnotation == null) {
+ return;
+ }
+
+ String method = ASMHelper.getAnnotationValue(injectAnnotation, "method");
+ if (method == null) {
+ throw new InvalidInjectionException("@Inject annotation on " + this.method.name + " is missing method name");
+ }
+
+ List ats = ASMHelper.>getAnnotationValue(injectAnnotation, "at");
+ if (ats == null) {
+ throw new InvalidInjectionException("@Inject annotation on " + this.method.name + " is missing 'at' value(s)");
+ }
+
+ MemberInfo targetMember = MemberInfo.parse(method);
+
+ if (targetMember.owner != null) {
+ throw new InvalidInjectionException("@Inject annotation on " + this.method.name + " specifies a target class '" + targetMember.owner +
+ "', which is not supported");
+ }
+
+ this.findMethods(targetMember);
+
+ if (this.targets.size() == 0) {
+ throw new InvalidInjectionException("@Inject annotation on " + this.method.name + " could not find specified method '" + method + "'");
+ }
+
+ this.cancellable = ASMHelper.getAnnotationValue(injectAnnotation, "cancellable", false);
+ this.captureLocals = ASMHelper.getAnnotationValue(injectAnnotation, "captureLocals", false);
+
+ for (AnnotationNode at : ats) {
+ InjectionPoint injectionPoint = InjectionPoint.parse(at);
+ if (injectionPoint != null) {
+ this.injectionPoints.add(injectionPoint);
+ }
+ }
+ }
+
+ /**
+ * Get whether there is enough valid information in this info to actually perform an injection
+ */
+ public boolean isValid() {
+ return this.targets.size() > 0 && this.injectionPoints.size() > 0;
+ }
+
+ /**
+ * Perform the injection
+ */
+ public void inject() {
+ CallbackInjector injector = this.getInjector();
+ while (this.targets.size() > 0) {
+ injector.injectInto(this.targets.removeFirst(), this.injectionPoints);
+ }
+ }
+
+ /**
+ * Performs a full-body massage with scented oils
+ */
+ private CallbackInjector getInjector() {
+ if (this.injector == null) {
+ this.injector = new CallbackInjector(this);
+ }
+
+ return this.injector;
+ }
+
+ /**
+ * Get the class node for this injection
+ */
+ public ClassNode getClassNode() {
+ return this.classNode;
+ }
+
+ /**
+ * Get method being called
+ */
+ public MethodNode getMethod() {
+ return this.method;
+ }
+
+ /**
+ * Get methods being injected into
+ */
+ public Collection getTargets() {
+ return this.targets;
+ }
+
+ /**
+ * Get whether cancellable or not
+ */
+ public boolean getCancellable() {
+ return this.cancellable;
+ }
+
+ /**
+ * Get whether injection should capture locals
+ */
+ public boolean getCaptureLocals() {
+ return this.captureLocals;
+ }
+
+ /**
+ * Finds methods in the target class which match searchFor
+ *
+ * @param searchFor member info to search for
+ */
+ private void findMethods(MemberInfo searchFor) {
+ this.targets.clear();
+ int ordinal = 0;
+
+ for (MethodNode target : this.classNode.methods) {
+ if (searchFor.matches(target.name, target.desc, ordinal)) {
+ if (searchFor.matchAll && ASMHelper.methodIsStatic(target) != this.isStatic) {
+ continue;
+ }
+
+ this.targets.add(target);
+ ordinal++;
+ }
+ }
+ }
+}
diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/InjectionPoint.java b/src/main/java/org/spongepowered/asm/mixin/injection/InjectionPoint.java
new file mode 100644
index 00000000..0456dd00
--- /dev/null
+++ b/src/main/java/org/spongepowered/asm/mixin/injection/InjectionPoint.java
@@ -0,0 +1,408 @@
+package org.spongepowered.asm.mixin.injection;
+
+import java.lang.reflect.Constructor;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.AnnotationNode;
+import org.objectweb.asm.tree.InsnList;
+import org.spongepowered.asm.mixin.injection.points.BeforeFieldAccess;
+import org.spongepowered.asm.mixin.injection.points.BeforeInvoke;
+import org.spongepowered.asm.mixin.injection.points.BeforeNew;
+import org.spongepowered.asm.mixin.injection.points.BeforeReturn;
+import org.spongepowered.asm.mixin.injection.points.BeforeStringInvoke;
+import org.spongepowered.asm.mixin.injection.points.JumpInsnPoint;
+import org.spongepowered.asm.mixin.injection.points.MethodHead;
+import org.spongepowered.asm.mixin.injection.struct.InjectionPointData;
+import org.spongepowered.asm.util.ASMHelper;
+
+import com.google.common.base.Joiner;
+import com.google.common.collect.ImmutableList;
+
+/**
+ * Base class for injection point discovery classes. Each subclass describes a strategy for locating code injection
+ * points within a method, with the {@code find} method populating a collection with insn nodes from the method
+ * which satisfy its strategy.
+ *
+ * This base class also contains composite strategy factory methods such as {@code and} and {@code or} which allow
+ * strategies to be combined using intersection (and) or union (or) relationships to allow multiple strategies to
+ * be easily combined.
+ *
+ * You are free to create your own injection point subclasses, but take note that it is allowed for a single
+ * InjectionPoint instance to be used for multiple injections and thus implementing classes MUST NOT cache the insn
+ * list, event, or nodes instance passed to the {@code find} method, as each call to {@code find} must be considered
+ * a separate functional contract and the InjectionPoint's lifespan is not linked to the discovery lifespan, therefore
+ * it is important that the InjectionPoint implementation is fully STATELESS.
+ *
+ * @author Adam Mummery-Smith
+ */
+public abstract class InjectionPoint
+{
+ /**
+ * Capture locals as well as args
+ */
+ protected boolean captureLocals;
+
+ protected boolean logLocals;
+
+ /**
+ * Find injection points in the supplied insn list
+ *
+ * @param desc Method descriptor, supplied to allow return types and arguments etc. to be determined
+ * @param insns Insn list to search in, the strategy MUST ONLY add nodes from this list to the {@code nodes} collection
+ * @param nodes Collection of nodes to populate. Injectors should NOT make any assumptions about the state of this collection and should only call add()
+ * @param event Event being injected here, supplied to allow alteration of behaviour for specific event configurations (eg. cancellable)
+ * @return true if one or more injection points were found
+ */
+ public abstract boolean find(String desc, InsnList insns, Collection nodes); //, Event event);
+
+// /**
+// * Set whether this injection point should capture local variables as well as method arguments
+// *
+// * @param captureLocals
+// * @return this, for fluent interface
+// */
+// public InjectionPoint setCaptureLocals(boolean captureLocals)
+// {
+// this.captureLocals = captureLocals;
+// return this;
+// }
+//
+// /**
+// * Get whether capture locals is enabled
+// */
+// public boolean captureLocals()
+// {
+// return this.captureLocals;
+// }
+//
+// /**
+// * Since it's virtually impossible to know what locals are available at a given injection point by reading the source, this method causes the
+// * injection point to dump the locals to the debug log at injection time.
+// *
+// * @param logLocals
+// * @return this, for fluent interface
+// */
+// public InjectionPoint setLogLocals(boolean logLocals)
+// {
+// this.logLocals = logLocals;
+// return this;
+// }
+//
+// /**
+// * Get whether log locals is enabled
+// */
+// public boolean logLocals()
+// {
+// return this.logLocals;
+// }
+
+ @Override
+ public String toString()
+ {
+ return "InjectionPoint(" + this.getClass().getSimpleName() + ")";
+ }
+
+ /**
+ * Composite injection point
+ *
+ * @author Adam Mummery-Smith
+ */
+ static abstract class CompositeInjectionPoint extends InjectionPoint
+ {
+ protected final InjectionPoint[] components;
+
+ protected CompositeInjectionPoint(InjectionPoint... components)
+ {
+ if (components == null || components.length < 2)
+ {
+ throw new IllegalArgumentException("Must supply two or more component injection points for composite point!");
+ }
+
+ this.components = components;
+
+ for (InjectionPoint component : this.components)
+ {
+ this.captureLocals |= component.captureLocals;
+ this.logLocals |= component.logLocals;
+ }
+ }
+
+ @Override
+ public String toString()
+ {
+ return "CompositeInjectionPoint(" + this.getClass().getSimpleName() + ")[" + Joiner.on(',').join(this.components) + "]";
+ }
+ }
+
+ static final class Intersection extends InjectionPoint.CompositeInjectionPoint
+ {
+ public Intersection(InjectionPoint... points)
+ {
+ super(points);
+ }
+
+ @Override
+ public boolean find(String desc, InsnList insns, Collection nodes) //, Event event)
+ {
+ boolean found = false;
+
+ @SuppressWarnings("unchecked")
+ ArrayList[] allNodes = new ArrayList[this.components.length];
+
+ for (int i = 0; i < this.components.length; i++)
+ {
+ allNodes[i] = new ArrayList();
+ this.components[i].find(desc, insns, allNodes[i]); //, event);
+ }
+
+ ArrayList alpha = allNodes[0];
+ for (int nodeIndex = 0; nodeIndex < alpha.size(); nodeIndex++)
+ {
+ AbstractInsnNode node = alpha.get(nodeIndex);
+ boolean in = true;
+
+ for (int b = 1; b < allNodes.length; b++)
+ if (!allNodes[b].contains(node))
+ break;
+
+ if (!in) continue;
+
+ nodes.add(node);
+ found = true;
+ }
+
+ return found;
+ }
+ }
+
+ static final class Union extends InjectionPoint.CompositeInjectionPoint
+ {
+ public Union(InjectionPoint... points)
+ {
+ super(points);
+ }
+
+ @Override
+ public boolean find(String desc, InsnList insns, Collection nodes) //, Event event)
+ {
+ LinkedHashSet allNodes = new LinkedHashSet();
+
+ for (int i = 0; i < this.components.length; i++)
+ {
+ this.components[i].find(desc, insns, allNodes); //, event);
+ }
+
+ nodes.addAll(allNodes);
+
+ return allNodes.size() > 0;
+ }
+ }
+
+ static final class Shift extends InjectionPoint
+ {
+ private final InjectionPoint input;
+ private final int shift;
+
+ public Shift(InjectionPoint input, int shift)
+ {
+ if (input == null)
+ {
+ throw new IllegalArgumentException("Must supply an input injection point for SHIFT");
+ }
+
+ this.input = input;
+ this.shift = shift;
+ }
+
+// @Override
+// public InjectionPoint setCaptureLocals(boolean captureLocals)
+// {
+// return this.input.setCaptureLocals(captureLocals);
+// }
+//
+// @Override
+// public boolean captureLocals()
+// {
+// return this.input.captureLocals();
+// }
+//
+// @Override
+// public InjectionPoint setLogLocals(boolean logLocals)
+// {
+// return this.input.setLogLocals(logLocals);
+// }
+//
+// @Override
+// public boolean logLocals()
+// {
+// return this.input.logLocals();
+// }
+
+ @Override
+ public String toString()
+ {
+ return "InjectionPoint(" + this.getClass().getSimpleName() + ")[" + this.input + "]";
+ }
+
+ @Override
+ public boolean find(String desc, InsnList insns, Collection nodes) //, Event event)
+ {
+ List list = (nodes instanceof List) ? (List)nodes : new ArrayList(nodes);
+
+ this.input.find(desc, insns, nodes); //, event);
+
+ for (int i = 0; i < list.size(); i++)
+ {
+ list.set(i, insns.get(insns.indexOf(list.get(i)) + this.shift));
+ }
+
+ if (nodes != list)
+ {
+ nodes.clear();
+ nodes.addAll(list);
+ }
+
+ return nodes.size() > 0;
+ }
+ }
+
+ /**
+ * Returns a composite injection point which returns the intersection of nodes from all component
+ * injection points
+ *
+ * @param operands
+ */
+ public static InjectionPoint and(InjectionPoint... operands)
+ {
+ return new InjectionPoint.Intersection(operands);
+ }
+
+ /**
+ * Returns a composite injection point which returns the union of nodes from all component
+ * injection points
+ *
+ * @param operands
+ */
+ public static InjectionPoint or(InjectionPoint... operands)
+ {
+ return new InjectionPoint.Union(operands);
+ }
+
+ /**
+ * Returns an injection point which returns all insns immediately following insns from the supplied injection point
+ *
+ * @param point
+ */
+ public static InjectionPoint after(InjectionPoint point)
+ {
+ return new InjectionPoint.Shift(point, 1);
+ }
+
+ /**
+ * Returns an injection point which returns all insns immediately prior to insns from the supplied injection point
+ *
+ * @param point
+ */
+ public static InjectionPoint before(InjectionPoint point)
+ {
+ return new InjectionPoint.Shift(point, -1);
+ }
+
+ /**
+ * Returns an injection point which returns all insns offset by the specified "count" from insns from the supplied injection point
+ *
+ * @param point
+ */
+ public static InjectionPoint shift(InjectionPoint point, int count)
+ {
+ return new InjectionPoint.Shift(point, count);
+ }
+
+ public static InjectionPoint parse(At at)
+ {
+ return InjectionPoint.parse(at.value(), at.shift(), Arrays.asList(at.args()), at.target(), at.ordinal(), at.opcode());
+ }
+
+ public static InjectionPoint parse(AnnotationNode node)
+ {
+ String at = ASMHelper.getAnnotationValue(node, "value");
+ List args = ASMHelper.>getAnnotationValue(node, "args");
+ String target = ASMHelper.getAnnotationValue(node, "target", "");
+ At.Shift shift = ASMHelper.getAnnotationValue(node, "shift", At.Shift.NONE);
+ int ordinal = ASMHelper.getAnnotationValue(node, "ordinal", Integer.valueOf(-1));
+ int opcode = ASMHelper.getAnnotationValue(node, "opcode", Integer.valueOf(0));
+
+ if (args == null) args = ImmutableList.of();
+
+ return InjectionPoint.parse(at, shift, args, target, ordinal, opcode);
+ }
+
+ public static InjectionPoint parse(String at, At.Shift shift, List args, String target, int ordinal, int opcode)
+ {
+ InjectionPointData data = new InjectionPointData(args, target, ordinal, opcode);
+ InjectionPoint pt = null;
+
+ if (BeforeFieldAccess.CODE.equals(at))
+ {
+ pt = new BeforeFieldAccess(data);
+ }
+ else if (BeforeInvoke.CODE.equals(at))
+ {
+ pt = new BeforeInvoke(data);
+ }
+ else if (BeforeNew.CODE.equals(at))
+ {
+ pt = new BeforeNew(data);
+ }
+ else if (BeforeReturn.CODE.equals(at))
+ {
+ pt = new BeforeReturn(data);
+ }
+ else if (BeforeStringInvoke.CODE.equals(at))
+ {
+ pt = new BeforeStringInvoke(data);
+ }
+ else if (JumpInsnPoint.CODE.equals(at))
+ {
+ pt = new JumpInsnPoint(data);
+ }
+ else if (MethodHead.CODE.equals(at))
+ {
+ pt = new MethodHead(data);
+ }
+ else if (at.matches("^([A-Za-z_][A-Za-z0-9_]*\\.)+[A-Za-z_][A-Za-z0-9_]*$"))
+ {
+ try
+ {
+ @SuppressWarnings("unchecked")
+ Class extends InjectionPoint> cls = (Class extends InjectionPoint>)Class.forName(at);
+ Constructor extends InjectionPoint> ctor = cls.getDeclaredConstructor(InjectionPointData.class);
+ ctor.setAccessible(true);
+ pt = ctor.newInstance(data);
+ }
+ catch (Exception ex)
+ {
+ ex.printStackTrace();
+ }
+ }
+
+ if (pt != null)
+ {
+ if (shift == At.Shift.BEFORE)
+ {
+ return InjectionPoint.before(pt);
+ }
+ else if (shift == At.Shift.AFTER)
+ {
+ return InjectionPoint.after(pt);
+ }
+ }
+
+ return pt;
+ }
+}
diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/InvalidInjectionException.java b/src/main/java/org/spongepowered/asm/mixin/injection/InvalidInjectionException.java
new file mode 100644
index 00000000..88910518
--- /dev/null
+++ b/src/main/java/org/spongepowered/asm/mixin/injection/InvalidInjectionException.java
@@ -0,0 +1,46 @@
+/**
+ * This file is part of Sponge, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 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 org.spongepowered.asm.mixin.InvalidMixinException;
+
+
+public class InvalidInjectionException extends InvalidMixinException {
+
+ private static final long serialVersionUID = 1L;
+
+ public InvalidInjectionException(String message) {
+ super(message);
+ }
+
+ public InvalidInjectionException(Throwable cause) {
+ super(cause);
+ }
+
+ public InvalidInjectionException(String message, Throwable cause) {
+ super(message, cause);
+ }
+
+}
diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/callback/CallbackInfo.java b/src/main/java/org/spongepowered/asm/mixin/injection/callback/CallbackInfo.java
new file mode 100644
index 00000000..6a3befd1
--- /dev/null
+++ b/src/main/java/org/spongepowered/asm/mixin/injection/callback/CallbackInfo.java
@@ -0,0 +1,135 @@
+/**
+ * This file contributed from LiteLoader. Pending refactor. DO NOT ALTER THIS FILE.
+ */
+
+package org.spongepowered.asm.mixin.injection.callback;
+
+import org.objectweb.asm.Type;
+
+//import com.mumfrey.liteloader.core.event.Cancellable;
+//import com.mumfrey.liteloader.core.event.EventCancellationException;
+
+/**
+ * Contains information about an injected event, including the source object and whether the event
+ * is cancellable and/or cancelled.
+ *
+ * @author Adam Mummery-Smith
+ *
+ * @param Source object type. For non-static methods this will be the containing object instance.
+ */
+public class CallbackInfo implements Cancellable
+{
+ protected static final String STRING = "Ljava/lang/String;";
+ protected static final String OBJECT = "Ljava/lang/Object;";
+
+ private final String name;
+
+// private final S source;
+
+ private final boolean cancellable;
+
+ private boolean cancelled;
+
+ public CallbackInfo(String name, /*S source,*/ boolean cancellable)
+ {
+ this.name = name;
+// this.source = source;
+ this.cancellable = cancellable;
+ }
+
+// public S getSource()
+// {
+// return this.source;
+// }
+
+ public String getName()
+ {
+ return this.name;
+ }
+
+// protected String getSourceClass()
+// {
+// return this.source != null ? this.source.getClass().getSimpleName() : null;
+// }
+
+ @Override
+ public String toString()
+ {
+ return String.format("CallbackInfo[TYPE=%s,NAME=%s,CANCELLABLE=%s]", this.getClass().getSimpleName(), this.name, this.cancellable);
+ }
+
+ /* (non-Javadoc)
+ * @see com.mumfrey.liteloader.core.event.Cancellable#isCancellable()
+ */
+ @Override
+ public final boolean isCancellable()
+ {
+ return this.cancellable;
+ }
+
+ /* (non-Javadoc)
+ * @see com.mumfrey.liteloader.transformers.event.Cancellable#isCancelled()
+ */
+ @Override
+ public final boolean isCancelled()
+ {
+ return this.cancelled;
+ }
+
+ /* (non-Javadoc)
+ * @see com.mumfrey.liteloader.transformers.event.Cancellable#cancel()
+ */
+ @Override
+ public void cancel() throws CancellationException
+ {
+ if (!this.cancellable)
+ {
+ throw new CancellationException(String.format("The call %s is not cancellable.", this.name));
+ }
+
+ this.cancelled = true;
+ }
+
+ protected static String getCallInfoClassName()
+ {
+ return CallbackInfo.class.getName();
+ }
+
+ /**
+ * @param returnType
+ */
+ protected static String getCallInfoClassName(Type returnType)
+ {
+ return (returnType.equals(Type.VOID_TYPE) ? CallbackInfo.class.getName() : CallbackInfoReturnable.class.getName()).replace('.', '/');
+ }
+
+ public static String getConstructorDescriptor(Type returnType)
+ {
+ if (returnType.equals(Type.VOID_TYPE))
+ {
+ return CallbackInfo.getConstructorDescriptor();
+ }
+
+ if (returnType.getSort() == Type.OBJECT)
+ {
+ return String.format("(%sZ%s)V", CallbackInfo.STRING, CallbackInfo.OBJECT);
+ }
+
+ return String.format("(%sZ%s)V", CallbackInfo.STRING, returnType.getDescriptor());
+ }
+
+ public static String getConstructorDescriptor()
+ {
+ return String.format("(%sZ)V", CallbackInfo.STRING);
+ }
+
+ public static String getIsCancelledMethodName()
+ {
+ return "isCancelled";
+ }
+
+ public static String getIsCancelledMethodSig()
+ {
+ return "()Z";
+ }
+}
diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/callback/CallbackInfoReturnable.java b/src/main/java/org/spongepowered/asm/mixin/injection/callback/CallbackInfoReturnable.java
new file mode 100644
index 00000000..5b6376fe
--- /dev/null
+++ b/src/main/java/org/spongepowered/asm/mixin/injection/callback/CallbackInfoReturnable.java
@@ -0,0 +1,137 @@
+/**
+ * This file contributed from LiteLoader. Pending refactor. DO NOT ALTER THIS FILE.
+ */
+
+package org.spongepowered.asm.mixin.injection.callback;
+
+import org.objectweb.asm.Type;
+
+//import com.mumfrey.liteloader.core.event.EventCancellationException;
+
+/**
+ * EventInfo for events which have a return type
+ *
+ * @author Adam Mummery-Smith
+ *
+ * @param Source object type. For non-static methods this will be the containing object instance.
+ * @param Return type
+ */
+public class CallbackInfoReturnable extends CallbackInfo
+{
+ private R returnValue;
+
+ public CallbackInfoReturnable(String name, boolean cancellable)
+ {
+ super(name, cancellable);
+ this.returnValue = null;
+ }
+
+ public CallbackInfoReturnable(String name, boolean cancellable, R returnValue)
+ {
+ super(name, cancellable);
+ this.returnValue = returnValue;
+ }
+
+ @SuppressWarnings("unchecked")
+ public CallbackInfoReturnable(String name, boolean cancellable, byte returnValue)
+ {
+ super(name, cancellable);
+ this.returnValue = (R)Byte.valueOf(returnValue);
+ }
+
+ @SuppressWarnings("unchecked")
+ public CallbackInfoReturnable(String name, boolean cancellable, char returnValue)
+ {
+ super(name, cancellable);
+ this.returnValue = (R)Character.valueOf(returnValue);
+ }
+
+ @SuppressWarnings("unchecked")
+ public CallbackInfoReturnable(String name, boolean cancellable, double returnValue)
+ {
+ super(name, cancellable);
+ this.returnValue = (R)Double.valueOf(returnValue);
+ }
+
+ @SuppressWarnings("unchecked")
+ public CallbackInfoReturnable(String name, boolean cancellable, float returnValue)
+ {
+ super(name, cancellable);
+ this.returnValue = (R)Float.valueOf(returnValue);
+ }
+
+ @SuppressWarnings("unchecked")
+ public CallbackInfoReturnable(String name, boolean cancellable, int returnValue)
+ {
+ super(name, cancellable);
+ this.returnValue = (R)Integer.valueOf(returnValue);
+ }
+
+ @SuppressWarnings("unchecked")
+ public CallbackInfoReturnable(String name, boolean cancellable, long returnValue)
+ {
+ super(name, cancellable);
+ this.returnValue = (R)Long.valueOf(returnValue);
+ }
+
+ @SuppressWarnings("unchecked")
+ public CallbackInfoReturnable(String name, boolean cancellable, short returnValue)
+ {
+ super(name, cancellable);
+ this.returnValue = (R)Short.valueOf(returnValue);
+ }
+
+ @SuppressWarnings("unchecked")
+ public CallbackInfoReturnable(String name, boolean cancellable, boolean returnValue)
+ {
+ super(name, cancellable);
+ this.returnValue = (R)Boolean.valueOf(returnValue);
+ }
+
+ /**
+ * Sets a return value for this event and cancels the event (required in order to return the new value)
+ *
+ * @param returnValue
+ */
+ public void setReturnValue(R returnValue) throws CancellationException
+ {
+ super.cancel();
+
+ this.returnValue = returnValue;
+ }
+
+ public R getReturnValue()
+ {
+ return this.returnValue;
+ }
+
+ // All of the accessors below are to avoid having to generate unboxing conversions in bytecode
+ public byte getReturnValueB() { if (this.returnValue == null) return 0; return (Byte) this.returnValue; }
+ public char getReturnValueC() { if (this.returnValue == null) return 0; return (Character)this.returnValue; }
+ public double getReturnValueD() { if (this.returnValue == null) return 0.0; return (Double) this.returnValue; }
+ public float getReturnValueF() { if (this.returnValue == null) return 0.0F; return (Float) this.returnValue; }
+ public int getReturnValueI() { if (this.returnValue == null) return 0; return (Integer) this.returnValue; }
+ public long getReturnValueJ() { if (this.returnValue == null) return 0; return (Long) this.returnValue; }
+ public short getReturnValueS() { if (this.returnValue == null) return 0; return (Short) this.returnValue; }
+ public boolean getReturnValueZ() { if (this.returnValue == null) return false; return (Boolean) this.returnValue; }
+
+ public static String getReturnAccessor(Type returnType)
+ {
+ if (returnType.getSort() == Type.OBJECT)
+ {
+ return "getReturnValue";
+ }
+
+ return String.format("getReturnValue%s", returnType.getDescriptor());
+ }
+
+ public static String getReturnDescriptor(Type returnType)
+ {
+ if (returnType.getSort() == Type.OBJECT)
+ {
+ return String.format("()%s", CallbackInfo.OBJECT);
+ }
+
+ return String.format("()%s", returnType.getDescriptor());
+ }
+}
diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/callback/CallbackInjector.java b/src/main/java/org/spongepowered/asm/mixin/injection/callback/CallbackInjector.java
new file mode 100644
index 00000000..dff52f6e
--- /dev/null
+++ b/src/main/java/org/spongepowered/asm/mixin/injection/callback/CallbackInjector.java
@@ -0,0 +1,297 @@
+/**
+ * This file contributed from LiteLoader. Pending refactor. DO NOT ALTER THIS FILE.
+ */
+
+package org.spongepowered.asm.mixin.injection.callback;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+import org.objectweb.asm.tree.*;
+import org.spongepowered.asm.mixin.injection.InjectionInfo;
+import org.spongepowered.asm.mixin.injection.InjectionPoint;
+import org.spongepowered.asm.mixin.injection.InvalidInjectionException;
+import org.spongepowered.asm.mixin.injection.points.BeforeReturn;
+import org.spongepowered.asm.mixin.injection.tree.ReadOnlyInsnList;
+import org.spongepowered.asm.util.ASMHelper;
+import org.spongepowered.asm.util.ByteCodeUtilities;
+
+
+public class CallbackInjector {
+
+ private static final String CTOR = "";
+
+ class Target
+ {
+ final MethodNode method;
+ final Type returnType;
+ final int MAXS;
+
+ final String callbackDescriptor;
+ final String callInfoClass;
+
+ Target(MethodNode method)
+ {
+ this.method = method;
+ this.returnType = Type.getReturnType(method.desc);
+ this.MAXS = method.maxStack;
+ this.callInfoClass = CallbackInfo.getCallInfoClassName(this.returnType);
+ this.callbackDescriptor = String.format("(%sL%s;)V", method.desc.substring(1, method.desc.indexOf(')')), this.callInfoClass);
+ }
+
+ String getCallbackDescriptor(final boolean captureLocals, final Type[] locals, Type[] argumentTypes, int startIndex)
+ {
+ if (!captureLocals) return this.callbackDescriptor;
+
+ String descriptor = this.callbackDescriptor.substring(0, this.callbackDescriptor.indexOf(')'));
+ for (int l = startIndex; l < locals.length; l++)
+ {
+ if (locals[l] != null) descriptor += locals[l].getDescriptor();
+ }
+
+ return descriptor + ")V";
+ }
+ }
+
+ private final boolean isStatic;
+ private final ClassNode classNode;
+ private final MethodNode methodNode;
+ private final boolean cancellable;
+ private final boolean captureLocals;
+
+ public CallbackInjector(InjectionInfo info)
+ {
+ this(info.getClassNode(), info.getMethod(), info.getCancellable(), info.getCaptureLocals());
+ }
+
+ public CallbackInjector(ClassNode classNode, MethodNode methodNode, boolean cancellable, boolean captureLocals)
+ {
+ this.classNode = classNode;
+ this.methodNode = methodNode;
+ this.cancellable = cancellable;
+ this.captureLocals = captureLocals;
+ this.isStatic = ASMHelper.methodIsStatic(methodNode);
+ }
+
+ public void injectInto(MethodNode into, List injectionPoints)
+ {
+ this.sanityCheck(into, injectionPoints);
+
+ for (AbstractInsnNode targetNode : this.findTargetNodes(into, injectionPoints))
+ {
+ Type[] localTypes = null;
+
+ if (this.captureLocals)
+ {
+ LocalVariableNode[] locals = ByteCodeUtilities.getLocalsAt(this.classNode, into, targetNode);
+
+ if (locals != null)
+ {
+ localTypes = new Type[locals.length];
+ for (int l = 0; l < locals.length; l++)
+ {
+ if (locals[l] != null)
+ {
+ localTypes[l] = Type.getType(locals[l].desc);
+ }
+ }
+ }
+
+// if (injectionPoint.logLocals())
+// {
+// int startPos = ByteCodeUtilities.getFirstNonArgLocalIndex(into);
+//
+// LiteLoaderLogger.debug(ClassTransformer.HORIZONTAL_RULE);
+// LiteLoaderLogger.debug("Logging local variables for " + injectionPoint);
+// for (int i = startPos; i < locals.length; i++)
+// {
+// LocalVariableNode local = locals[i];
+// if (local != null)
+// {
+// LiteLoaderLogger.debug(" Local[%d] %s %s", i, ByteCodeUtilities.getTypeName(Type.getType(local.desc)), local.name);
+// }
+// }
+// LiteLoaderLogger.debug(ClassTransformer.HORIZONTAL_RULE);
+// }
+ }
+
+ Target target = new Target(into);
+ this.inject(target, targetNode, localTypes);
+ }
+ }
+
+ private Set findTargetNodes(MethodNode into, List injectionPoints) {
+ Set targetNodes = new HashSet();
+
+ // Defensive objects, so that injectionPoint instances can't modify our working copies
+ ReadOnlyInsnList insns = new ReadOnlyInsnList(into.instructions);
+ Collection nodes = new ArrayList(32);
+
+ for (InjectionPoint injectionPoint : injectionPoints)
+ {
+ nodes.clear();
+ if (injectionPoint.find(into.desc, insns, nodes))
+ {
+ targetNodes.addAll(nodes);
+ }
+ }
+ return targetNodes;
+ }
+
+ private void sanityCheck(MethodNode target, List injectionPoints)
+ {
+ if (ASMHelper.methodIsStatic(target) != this.isStatic)
+ {
+ throw new InvalidInjectionException("'static' modifier of callback method does not match target in " + this.methodNode.name);
+ }
+
+ if (CallbackInjector.CTOR.equals(target.name))
+ {
+ for (InjectionPoint injectionPoint : injectionPoints)
+ {
+ if (!injectionPoint.getClass().equals(BeforeReturn.class))
+ {
+ throw new InvalidInjectionException("Found injection point type " + injectionPoint.getClass().getSimpleName() + " targetting a ctor in " + this.classNode.name + ". Only RETURN allowed for a ctor target");
+ }
+ }
+ }
+ }
+
+ private void inject(Target target, final AbstractInsnNode targetNode, final Type[] locals)
+ {
+ Type[] arguments = Type.getArgumentTypes(target.method.desc);
+ int initialFrameSize = ByteCodeUtilities.getFirstNonArgLocalIndex(arguments, !this.isStatic);
+
+ boolean doCaptureLocals = this.captureLocals && locals != null && locals.length > initialFrameSize;
+ String callbackDescriptor = target.getCallbackDescriptor(doCaptureLocals, locals, arguments, initialFrameSize);
+ if (!callbackDescriptor.equals(this.methodNode.desc))
+ {
+ throw new InvalidInjectionException("Invalid descriptor on callback method, expected " + callbackDescriptor);
+ }
+
+ int ctorMAXS = 0, invokeMAXS = arguments.length + (doCaptureLocals ? locals.length - initialFrameSize : 0);
+
+ // Marshall var is the local where we marshall the utility references we need during invoke of the callback
+ int marshallVar = target.method.maxLocals++;
+
+ InsnList insns = new InsnList();
+
+ boolean pushReturnValue = false;
+
+ // If this is a ReturnEventInfo AND we are right before a RETURN opcode (so we can expect the *original* return
+ // value to be on the stack, then we dup the return value into a local var so we can push it later when we invoke
+ // the ReturnEventInfo ctor
+ if (targetNode instanceof InsnNode && targetNode.getOpcode() >= Opcodes.IRETURN && targetNode.getOpcode() < Opcodes.RETURN)
+ {
+ pushReturnValue = true;
+ insns.add(new InsnNode(Opcodes.DUP));
+ insns.add(new VarInsnNode(target.returnType.getOpcode(Opcodes.ISTORE), marshallVar));
+ }
+
+ // Instance the EventInfo for this event
+ insns.add(new TypeInsnNode(Opcodes.NEW, target.callInfoClass)); ctorMAXS++;
+ insns.add(new InsnNode(Opcodes.DUP)); ctorMAXS++; invokeMAXS++;
+ ctorMAXS += this.invokeCallbackInfoCtor(target, insns, this.cancellable, pushReturnValue, marshallVar);
+ insns.add(new VarInsnNode(Opcodes.ASTORE, marshallVar));
+
+ if (!this.isStatic)
+ {
+ insns.add(new VarInsnNode(Opcodes.ALOAD, 0));
+ }
+
+ // Call the event handler method in the proxy
+ ByteCodeUtilities.loadArgs(arguments, insns, this.isStatic ? 0 : 1);
+ insns.add(new VarInsnNode(Opcodes.ALOAD, marshallVar));
+ if (doCaptureLocals)
+ {
+ ByteCodeUtilities.loadLocals(locals, insns, initialFrameSize);
+ }
+ insns.add(new MethodInsnNode(this.isStatic ? Opcodes.INVOKESTATIC : Opcodes.INVOKESPECIAL, this.classNode.name, this.methodNode.name, this.methodNode.desc, false));
+
+ if (this.cancellable)
+ {
+ // Inject the if (e.isCancelled()) return e.getReturnValue();
+ this.injectCancellationCode(target, insns, targetNode, marshallVar);
+ }
+
+ // Inject our generated code into the method
+ target.method.instructions.insertBefore(targetNode, insns);
+ target.method.maxStack = Math.max(target.method.maxStack, Math.max(target.MAXS + ctorMAXS, target.MAXS + invokeMAXS));
+ }
+
+ protected int invokeCallbackInfoCtor(Target target, InsnList insns, boolean cancellable, boolean pushReturnValue, int marshallVar)
+ {
+ int ctorMAXS = 0;
+
+ insns.add(new LdcInsnNode(target.method.name)); ctorMAXS++;
+// insns.add(target.methodIsStatic ? new InsnNode(Opcodes.ACONST_NULL) : new VarInsnNode(Opcodes.ALOAD, 0)); ctorMAXS++;
+ insns.add(new InsnNode(cancellable ? Opcodes.ICONST_1 : Opcodes.ICONST_0)); ctorMAXS++;
+
+ if (pushReturnValue)
+ {
+ insns.add(new VarInsnNode(target.returnType.getOpcode(Opcodes.ILOAD), marshallVar));
+ insns.add(new MethodInsnNode(Opcodes.INVOKESPECIAL, target.callInfoClass, CallbackInjector.CTOR, CallbackInfo.getConstructorDescriptor(target.returnType), false));
+ }
+ else
+ {
+ insns.add(new MethodInsnNode(Opcodes.INVOKESPECIAL, target.callInfoClass, CallbackInjector.CTOR, CallbackInfo.getConstructorDescriptor(), false));
+ }
+
+ return ctorMAXS;
+ }
+
+ /**
+ * if (e.isCancelled()) return e.getReturnValue();
+ *
+ * @param insns
+ * @param targetNode
+ * @param marshallVar
+ */
+ protected void injectCancellationCode(Target target, final InsnList insns, final AbstractInsnNode targetNode, int marshallVar)
+ {
+ insns.add(new VarInsnNode(Opcodes.ALOAD, marshallVar));
+ insns.add(new MethodInsnNode(Opcodes.INVOKEVIRTUAL, target.callInfoClass, CallbackInfo.getIsCancelledMethodName(), CallbackInfo.getIsCancelledMethodSig(), false));
+
+ LabelNode notCancelled = new LabelNode();
+ insns.add(new JumpInsnNode(Opcodes.IFEQ, notCancelled));
+
+ // If this is a void method, just injects a RETURN opcode, otherwise we need to get the return value from the EventInfo
+ this.injectReturnCode(target, insns, targetNode, marshallVar);
+
+ insns.add(notCancelled);
+ }
+
+ /**
+ * Inject the appropriate return code for the method type
+ *
+ * @param insns
+ * @param targetNode
+ * @param marshallVar
+ */
+ protected void injectReturnCode(Target target, final InsnList insns, final AbstractInsnNode targetNode, int marshallVar)
+ {
+ if (target.returnType.equals(Type.VOID_TYPE))
+ {
+ // Void method, so just return void
+ insns.add(new InsnNode(Opcodes.RETURN));
+ }
+ else
+ {
+ // Non-void method, so work out which accessor to call to get the return value, and return it
+ insns.add(new VarInsnNode(Opcodes.ALOAD, marshallVar));
+ String accessor = CallbackInfoReturnable.getReturnAccessor(target.returnType);
+ String descriptor = CallbackInfoReturnable.getReturnDescriptor(target.returnType);
+ insns.add(new MethodInsnNode(Opcodes.INVOKEVIRTUAL, target.callInfoClass, accessor, descriptor, false));
+ if (target.returnType.getSort() == Type.OBJECT)
+ {
+ insns.add(new TypeInsnNode(Opcodes.CHECKCAST, target.returnType.getInternalName()));
+ }
+ insns.add(new InsnNode(target.returnType.getOpcode(Opcodes.IRETURN)));
+ }
+ }
+}
diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/callback/Cancellable.java b/src/main/java/org/spongepowered/asm/mixin/injection/callback/Cancellable.java
new file mode 100644
index 00000000..ac3917f8
--- /dev/null
+++ b/src/main/java/org/spongepowered/asm/mixin/injection/callback/Cancellable.java
@@ -0,0 +1,32 @@
+/**
+ * This file contributed from LiteLoader. Pending refactor. DO NOT ALTER THIS FILE.
+ */
+
+package org.spongepowered.asm.mixin.injection.callback;
+
+
+/**
+ * Interface for (potentially) cancellable things :)
+ *
+ * @author Adam Mummery-Smith
+ */
+public interface Cancellable
+{
+ /**
+ * Get whether this is actually cancellable
+ */
+ public abstract boolean isCancellable();
+
+ /**
+ * Get whether this is cancelled
+ */
+ public abstract boolean isCancelled();
+
+ /**
+ * If the object is cancellable, cancels the object, implementors may throw
+ * an EventCancellationException if the object is not actually cancellable.
+ *
+ * @throws CancellationException (optional) may be thrown if the object is not actually cancellable
+ */
+ public abstract void cancel() throws CancellationException;
+}
\ No newline at end of file
diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/callback/CancellationException.java b/src/main/java/org/spongepowered/asm/mixin/injection/callback/CancellationException.java
new file mode 100644
index 00000000..fd0c4452
--- /dev/null
+++ b/src/main/java/org/spongepowered/asm/mixin/injection/callback/CancellationException.java
@@ -0,0 +1,29 @@
+/**
+ * This file contributed from LiteLoader. Pending refactor. DO NOT ALTER THIS FILE.
+ */
+
+package org.spongepowered.asm.mixin.injection.callback;
+
+public class CancellationException extends RuntimeException
+{
+ private static final long serialVersionUID = 1L;
+
+ public CancellationException()
+ {
+ }
+
+ public CancellationException(String message)
+ {
+ super(message);
+ }
+
+ public CancellationException(Throwable cause)
+ {
+ super(cause);
+ }
+
+ public CancellationException(String message, Throwable cause)
+ {
+ super(message, cause);
+ }
+}
diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/points/BeforeFieldAccess.java b/src/main/java/org/spongepowered/asm/mixin/injection/points/BeforeFieldAccess.java
new file mode 100644
index 00000000..fdaddafb
--- /dev/null
+++ b/src/main/java/org/spongepowered/asm/mixin/injection/points/BeforeFieldAccess.java
@@ -0,0 +1,36 @@
+/**
+ * This file contributed from LiteLoader. Pending refactor. DO NOT ALTER THIS FILE.
+ */
+
+package org.spongepowered.asm.mixin.injection.points;
+
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.FieldInsnNode;
+import org.spongepowered.asm.mixin.injection.struct.InjectionPointData;
+
+/**
+ * An injection point which searches for GETFIELD and SETFIELD opcodes matching its arguments and returns a list of insns
+ * immediately prior to matching instructions. Only the field name is required, owners and signatures are optional and can
+ * be used to disambiguate between fields of the same name but with different types, or belonging to different classes.
+ *
+ * @author Adam Mummery-Smith
+ */
+public class BeforeFieldAccess extends BeforeInvoke
+{
+ @SuppressWarnings("hiding")
+ public static final String CODE = "FIELD";
+
+ private final int opcode;
+
+ public BeforeFieldAccess(InjectionPointData data)
+ {
+ super(data);
+ this.opcode = data.getOpcode();
+ }
+
+ @Override
+ protected boolean matchesInsn(AbstractInsnNode insn)
+ {
+ return insn instanceof FieldInsnNode && ((FieldInsnNode)insn).getOpcode() == this.opcode;
+ }
+}
diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/points/BeforeInvoke.java b/src/main/java/org/spongepowered/asm/mixin/injection/points/BeforeInvoke.java
new file mode 100644
index 00000000..22eee477
--- /dev/null
+++ b/src/main/java/org/spongepowered/asm/mixin/injection/points/BeforeInvoke.java
@@ -0,0 +1,199 @@
+/**
+ * This file contributed from LiteLoader. Pending refactor. DO NOT ALTER THIS FILE.
+ */
+
+package org.spongepowered.asm.mixin.injection.points;
+
+import java.util.Collection;
+import java.util.ListIterator;
+
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.FieldInsnNode;
+import org.objectweb.asm.tree.InsnList;
+import org.objectweb.asm.tree.MethodInsnNode;
+import org.spongepowered.asm.mixin.injection.InjectionPoint;
+import org.spongepowered.asm.mixin.injection.struct.InjectionPointData;
+import org.spongepowered.asm.mixin.injection.struct.MemberInfo;
+
+//import com.mumfrey.liteloader.transformers.ClassTransformer;
+//import com.mumfrey.liteloader.transformers.event.Event;
+//import com.mumfrey.liteloader.transformers.event.InjectionPoint;
+//import com.mumfrey.liteloader.transformers.event.MethodInfo;
+//import com.mumfrey.liteloader.util.log.LiteLoaderLogger;
+
+/**
+ * An injection point which searches for method invokations matching its arguments and returns a list of insns immediately
+ * prior to matching invokations. Only the method name is required, owners and signatures are optional and can be used to disambiguate
+ * between methods of the same name but with different args, or belonging to different classes.
+ *
+ * @author Adam Mummery-Smith
+ */
+public class BeforeInvoke extends InjectionPoint
+{
+ public static final String CODE = "INVOKE";
+
+ protected class InsnInfo
+ {
+ public final String owner;
+ public final String name;
+ public final String desc;
+
+ public InsnInfo(AbstractInsnNode insn)
+ {
+ if (insn instanceof MethodInsnNode)
+ {
+ MethodInsnNode methodNode = (MethodInsnNode)insn;
+ this.owner = methodNode.owner;
+ this.name = methodNode.name;
+ this.desc = methodNode.desc;
+ }
+ else if (insn instanceof FieldInsnNode)
+ {
+ FieldInsnNode fieldNode = (FieldInsnNode)insn;
+ this.owner = fieldNode.owner;
+ this.name = fieldNode.name;
+ this.desc = fieldNode.desc;
+ }
+ else
+ {
+ throw new IllegalArgumentException("insn must be an instance of MethodInsnNode or FieldInsnNode");
+ }
+ }
+ }
+
+ protected final MemberInfo target;
+
+ /**
+ * This strategy can be used to identify a particular invokation if the same method is invoked at multiple points, if this value is -1
+ * then the strategy returns ALL invokations of the method.
+ */
+ protected final int ordinal;
+
+ /**
+ * True to turn on strategy debugging to the console
+ */
+ protected boolean logging = false;
+
+ protected final String className;
+
+ public BeforeInvoke(InjectionPointData data)
+ {
+ this.target = data.getTarget();
+ this.ordinal = data.getOrdinal();
+ this.className = this.getClass().getSimpleName();
+
+// this.convertClassRefs();
+ }
+
+// private void convertClassRefs()
+// {
+// for (int i = 0; i < this.methodOwners.length; i++)
+// {
+// if (this.methodOwners[i] != null) this.methodOwners[i] = this.methodOwners[i].replace('.', '/');
+// }
+//
+// if (this.methodSignatures != null)
+// {
+// for (int i = 0; i < this.methodSignatures.length; i++)
+// {
+// if (this.methodSignatures[i] != null) this.methodSignatures[i] = this.methodSignatures[i].replace('.', '/');
+// }
+// }
+// }
+
+ public BeforeInvoke setLogging(boolean logging)
+ {
+ this.logging = logging;
+ return this;
+ }
+
+ /* (non-Javadoc)
+ * @see com.mumfrey.liteloader.transformers.event.InjectionStrategy#findInjectionPoint(java.lang.String, org.objectweb.asm.tree.InsnList, com.mumfrey.liteloader.transformers.event.Event, java.util.Collection)
+ */
+ @Override
+ public boolean find(String desc, InsnList insns, Collection nodes) //, Event event)
+ {
+ int ordinal = 0;
+ boolean found = false;
+
+ if (this.logging)
+ {
+// LiteLoaderLogger.debug(ClassTransformer.HORIZONTAL_RULE);
+// LiteLoaderLogger.debug(this.className + " is searching for an injection point in method with descriptor %s", desc);
+ }
+
+ ListIterator iter = insns.iterator();
+ while (iter.hasNext())
+ {
+ AbstractInsnNode insn = iter.next();
+
+ if (this.matchesInsn(insn))
+ {
+ InsnInfo nodeInfo = new InsnInfo(insn);
+
+// if (this.logging) LiteLoaderLogger.debug(this.className + " is considering insn NAME=%s DESC=%s OWNER=%s", nodeInfo.name, nodeInfo.desc, nodeInfo.owner);
+
+// int index = BeforeInvoke.arrayIndexOf(this.methodNames, nodeInfo.name, -1);
+// if (index > -1 && this.logging) LiteLoaderLogger.debug(this.className + " found a matching insn, checking owner/signature...");
+
+// int ownerIndex = BeforeInvoke.arrayIndexOf(this.methodOwners, nodeInfo.owner, index);
+// int descIndex = BeforeInvoke.arrayIndexOf(this.methodSignatures, nodeInfo.desc, index);
+ if (this.target.matches(nodeInfo.owner, nodeInfo.name, nodeInfo.desc))
+ {
+// if (this.logging) LiteLoaderLogger.debug(this.className + " found a matching insn, checking preconditions...");
+ if (this.matchesInsn(nodeInfo, ordinal))
+ {
+// if (this.logging) LiteLoaderLogger.debug(this.className + " found a matching insn at ordinal %d", ordinal);
+ nodes.add(insn);
+ found = true;
+
+ if (this.ordinal == ordinal)
+ break;
+ }
+
+ ordinal++;
+ }
+ }
+
+ this.inspectInsn(desc, insns, insn);
+ }
+
+// if (this.logging) LiteLoaderLogger.debug(ClassTransformer.HORIZONTAL_RULE);
+
+ return found;
+ }
+
+ protected boolean matchesInsn(AbstractInsnNode insn)
+ {
+ return insn instanceof MethodInsnNode;
+ }
+
+ protected void inspectInsn(String desc, InsnList insns, AbstractInsnNode insn)
+ {
+ // stub for subclasses
+ }
+
+ protected boolean matchesInsn(InsnInfo nodeInfo, int ordinal)
+ {
+// if (this.logging) LiteLoaderLogger.debug(this.className + " comparing target ordinal %d with current ordinal %d", this.ordinal, ordinal);
+ return this.ordinal == -1 || this.ordinal == ordinal;
+ }
+//
+// /**
+// * Special version of contains which returns TRUE if the haystack array is null, which is an odd behaviour we actually
+// * want here because null indicates that the value is not important
+// *
+// * @param haystack
+// * @param needle
+// */
+// private static int arrayIndexOf(String[] haystack, String needle, int pos)
+// {
+// if (haystack == null) return pos;
+// if (pos > -1 && pos < haystack.length && needle.equals(haystack[pos])) return pos;
+//
+// for (int index = 0; index < haystack.length; index++)
+// if (needle.equals(haystack[index])) return index;
+//
+// return -1;
+// }
+}
diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/points/BeforeNew.java b/src/main/java/org/spongepowered/asm/mixin/injection/points/BeforeNew.java
new file mode 100644
index 00000000..d7e55a61
--- /dev/null
+++ b/src/main/java/org/spongepowered/asm/mixin/injection/points/BeforeNew.java
@@ -0,0 +1,76 @@
+/**
+ * This file contributed from LiteLoader. Pending refactor. DO NOT ALTER THIS FILE.
+ */
+
+package org.spongepowered.asm.mixin.injection.points;
+
+import java.util.Collection;
+import java.util.ListIterator;
+
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.InsnList;
+import org.objectweb.asm.tree.TypeInsnNode;
+import org.spongepowered.asm.mixin.injection.InjectionPoint;
+import org.spongepowered.asm.mixin.injection.struct.InjectionPointData;
+
+//import com.mumfrey.liteloader.core.runtime.Obf;
+//import com.mumfrey.liteloader.transformers.event.Event;
+//import com.mumfrey.liteloader.transformers.event.InjectionPoint;
+
+public class BeforeNew extends InjectionPoint
+{
+ public static final String CODE = "NEW";
+
+ private final String className;
+
+ private final int ordinal;
+
+ public BeforeNew(InjectionPointData data)
+ {
+ this.ordinal = data.getOrdinal();
+ this.className = data.get("class", "").replace('.', '/');
+
+// for (int i = 0; i < this.classNames.length; i++)
+// {
+// this.classNames[i] = this.classNames[i].replace('.', '/');
+// }
+ }
+
+ @Override
+ public boolean find(String desc, InsnList insns, Collection nodes) //, Event event)
+ {
+ boolean found = false;
+ int ordinal = 0;
+
+ ListIterator iter = insns.iterator();
+ while (iter.hasNext())
+ {
+ AbstractInsnNode insn = iter.next();
+
+ if (insn instanceof TypeInsnNode && insn.getOpcode() == Opcodes.NEW && this.matchesOwner((TypeInsnNode)insn))
+ {
+ if (this.ordinal == -1 || this.ordinal == ordinal)
+ {
+ nodes.add(insn);
+ found = true;
+ }
+
+ ordinal++;
+ }
+ }
+
+ return found;
+ }
+
+ private boolean matchesOwner(TypeInsnNode insn)
+ {
+// for (String className : this.classNames)
+// {
+// if (className.equals(insn.desc)) return true;
+// }
+
+ return this.className.equals(insn.desc);
+ }
+
+}
diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/points/BeforeReturn.java b/src/main/java/org/spongepowered/asm/mixin/injection/points/BeforeReturn.java
new file mode 100644
index 00000000..b6911115
--- /dev/null
+++ b/src/main/java/org/spongepowered/asm/mixin/injection/points/BeforeReturn.java
@@ -0,0 +1,64 @@
+/**
+ * This file contributed from LiteLoader. Pending refactor. DO NOT ALTER THIS FILE.
+ */
+
+package org.spongepowered.asm.mixin.injection.points;
+
+import java.util.Collection;
+import java.util.ListIterator;
+
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.InsnList;
+import org.objectweb.asm.tree.InsnNode;
+import org.spongepowered.asm.mixin.injection.InjectionPoint;
+import org.spongepowered.asm.mixin.injection.struct.InjectionPointData;
+
+//import com.mumfrey.liteloader.transformers.event.Event;
+//import com.mumfrey.liteloader.transformers.event.InjectionPoint;
+
+/**
+ * An injection point which searches for RETURN opcodes in the supplied method and either finds all insns or
+ * the insn at the specified ordinal
+ *
+ * @author Adam Mummery-Smith
+ */
+public class BeforeReturn extends InjectionPoint
+{
+ public static final String CODE = "RETURN";
+
+ private final int ordinal;
+
+ public BeforeReturn(InjectionPointData data)
+ {
+ this.ordinal = data.getOrdinal();
+ }
+
+ @Override
+ public boolean find(String desc, InsnList insns, Collection nodes) //, Event event)
+ {
+ boolean found = false;
+ int returnOpcode = Type.getReturnType(desc).getOpcode(Opcodes.IRETURN);
+ int ordinal = 0;
+
+ ListIterator iter = insns.iterator();
+ while (iter.hasNext())
+ {
+ AbstractInsnNode insn = iter.next();
+
+ if (insn instanceof InsnNode && insn.getOpcode() == returnOpcode)
+ {
+ if (this.ordinal == -1 || this.ordinal == ordinal)
+ {
+ nodes.add(insn);
+ found = true;
+ }
+
+ ordinal++;
+ }
+ }
+
+ return found;
+ }
+}
diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/points/BeforeStringInvoke.java b/src/main/java/org/spongepowered/asm/mixin/injection/points/BeforeStringInvoke.java
new file mode 100644
index 00000000..7c59590d
--- /dev/null
+++ b/src/main/java/org/spongepowered/asm/mixin/injection/points/BeforeStringInvoke.java
@@ -0,0 +1,80 @@
+/**
+ * This file contributed from LiteLoader. Pending refactor. DO NOT ALTER THIS FILE.
+ */
+
+package org.spongepowered.asm.mixin.injection.points;
+
+import java.util.Collection;
+
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.InsnList;
+import org.objectweb.asm.tree.LdcInsnNode;
+import org.spongepowered.asm.mixin.injection.struct.InjectionPointData;
+
+//import com.mumfrey.liteloader.transformers.event.Event;
+//import com.mumfrey.liteloader.transformers.event.MethodInfo;
+//import com.mumfrey.liteloader.util.log.LiteLoaderLogger;
+
+/**
+ * An injection point which searches for a matching String LDC insn immediately prior to a qualifying invoke
+ *
+ * @author Adam Mummery-Smith
+ */
+public class BeforeStringInvoke extends BeforeInvoke
+{
+ @SuppressWarnings("hiding")
+ public static final String CODE = "INVOKE_STRING";
+
+// private static final String STRING_VOID_SIG = "(Ljava/lang/String;)V";
+
+ private final String ldcValue;
+
+ private boolean foundLdc;
+
+// public BeforeStringInvoke(String ldcValue, String[] methodNames, String[] methodOwners)
+// {
+// this(ldcValue, methodNames, methodOwners, -1);
+// }
+
+ public BeforeStringInvoke(InjectionPointData data)
+ {
+ super(data);
+ this.ldcValue = data.get("ldc", "");
+
+// for (int i = 0; i < this.methodSignatures.length; i++)
+// if (!STRING_VOID_SIG.equals(this.methodSignatures[i]))
+// throw new IllegalArgumentException("BeforeStringInvoke requires method with with signature " + STRING_VOID_SIG);
+ }
+
+ @Override
+ public boolean find(String desc, InsnList insns, Collection nodes) //, Event event)
+ {
+ this.foundLdc = false;
+
+ return super.find(desc, insns, nodes); //, event);
+ }
+
+ @Override
+ protected void inspectInsn(String desc, InsnList insns, AbstractInsnNode insn)
+ {
+ if (insn instanceof LdcInsnNode)
+ {
+ LdcInsnNode node = (LdcInsnNode)insn;
+ if (node.cst instanceof String && this.ldcValue.equals(node.cst))
+ {
+// if (this.logging) LiteLoaderLogger.info("BeforeInvoke found a matching LDC with value %s", node.cst);
+ this.foundLdc = true;
+ return;
+ }
+ }
+
+ this.foundLdc = false;
+ }
+
+ @Override
+ protected boolean matchesInsn(InsnInfo nodeInfo, int ordinal)
+ {
+// if (this.logging) LiteLoaderLogger.debug("BeforeInvoke foundLdc \"%s\" = %s", this.ldcValue, this.foundLdc);
+ return this.foundLdc && super.matchesInsn(nodeInfo, ordinal);
+ }
+}
diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/points/JumpInsnPoint.java b/src/main/java/org/spongepowered/asm/mixin/injection/points/JumpInsnPoint.java
new file mode 100644
index 00000000..aaecf4fe
--- /dev/null
+++ b/src/main/java/org/spongepowered/asm/mixin/injection/points/JumpInsnPoint.java
@@ -0,0 +1,65 @@
+/**
+ * This file contributed from LiteLoader. Pending refactor. DO NOT ALTER THIS FILE.
+ */
+
+package org.spongepowered.asm.mixin.injection.points;
+
+import java.util.Collection;
+import java.util.ListIterator;
+
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.InsnList;
+import org.objectweb.asm.tree.JumpInsnNode;
+import org.spongepowered.asm.mixin.injection.InjectionPoint;
+import org.spongepowered.asm.mixin.injection.struct.InjectionPointData;
+
+//import com.mumfrey.liteloader.transformers.event.Event;
+//import com.mumfrey.liteloader.transformers.event.InjectionPoint;
+
+/**
+ * An injection point which searches for JUMP opcodes (if, try/catch, continue, break, conditional assignment, etc.)
+ * with either a particular opcode or at a particular ordinal in the method body (eg. "the Nth JUMP insn" where N is the
+ * ordinal of the instruction). By default it returns all JUMP instructions in a method body.
+ *
+ * @author Adam Mummery-Smith
+ */
+public class JumpInsnPoint extends InjectionPoint
+{
+ public static final String CODE = "JUMP";
+
+ private final int opCode;
+
+ private final int ordinal;
+
+ public JumpInsnPoint(InjectionPointData data)
+ {
+ this.opCode = data.getOpcode();
+ this.ordinal = data.getOrdinal();
+ }
+
+ @Override
+ public boolean find(String desc, InsnList insns, Collection nodes) //, Event event)
+ {
+ boolean found = false;
+ int ordinal = 0;
+
+ ListIterator iter = insns.iterator();
+ while (iter.hasNext())
+ {
+ AbstractInsnNode insn = iter.next();
+
+ if (insn instanceof JumpInsnNode && (this.opCode == -1 || insn.getOpcode() == this.opCode))
+ {
+ if (this.ordinal == -1 || this.ordinal == ordinal)
+ {
+ nodes.add(insn);
+ found = true;
+ }
+
+ ordinal++;
+ }
+ }
+
+ return found;
+ }
+}
diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/points/MethodHead.java b/src/main/java/org/spongepowered/asm/mixin/injection/points/MethodHead.java
new file mode 100644
index 00000000..c7f16b55
--- /dev/null
+++ b/src/main/java/org/spongepowered/asm/mixin/injection/points/MethodHead.java
@@ -0,0 +1,36 @@
+/**
+ * This file contributed from LiteLoader. Pending refactor. DO NOT ALTER THIS FILE.
+ */
+
+package org.spongepowered.asm.mixin.injection.points;
+
+import java.util.Collection;
+
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.InsnList;
+import org.spongepowered.asm.mixin.injection.InjectionPoint;
+import org.spongepowered.asm.mixin.injection.struct.InjectionPointData;
+
+//import com.mumfrey.liteloader.transformers.event.Event;
+//import com.mumfrey.liteloader.transformers.event.InjectionPoint;
+
+/**
+ * An injection point which locates the first instruction in a method body
+ *
+ * @author Adam Mummery-Smith
+ */
+public class MethodHead extends InjectionPoint
+{
+ public static final String CODE = "HEAD";
+
+ public MethodHead(InjectionPointData data)
+ {
+ }
+
+ @Override
+ public boolean find(String desc, InsnList insns, Collection nodes) //, Event event)
+ {
+ nodes.add(insns.getFirst());
+ return true;
+ }
+}
diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/struct/InjectionPointData.java b/src/main/java/org/spongepowered/asm/mixin/injection/struct/InjectionPointData.java
new file mode 100644
index 00000000..7d52e98d
--- /dev/null
+++ b/src/main/java/org/spongepowered/asm/mixin/injection/struct/InjectionPointData.java
@@ -0,0 +1,130 @@
+/**
+ * This file is part of Sponge, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 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 java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.spongepowered.asm.mixin.injection.At;
+
+
+/**
+ * Data read from an {@link At} annotation and passed into an InjectionPoint ctor
+ *
+ * @author Adam Mummery-Smith
+ */
+public class InjectionPointData {
+
+ /**
+ * K/V arguments parsed from the "args" node in the {@link At} annotation
+ */
+ private final Map args = new HashMap();
+
+ /**
+ * Target
+ */
+ private final String target;
+
+ /**
+ * Ordinal
+ */
+ private final int ordinal;
+
+ /**
+ * Opcode
+ */
+ private final int opcode;
+
+ public InjectionPointData(List args, String target, int ordinal, int opcode) {
+ this.target = target;
+ this.ordinal = Math.max(-1, ordinal);
+ this.opcode = opcode;
+
+ this.parseArgs(args);
+
+ this.args.put("target", target);
+ this.args.put("ordinal", String.valueOf(ordinal));
+ this.args.put("opcode", String.valueOf(opcode));
+ }
+
+ private void parseArgs(List args) {
+ for (String arg : args) {
+ if (arg != null) {
+ int eqPos = arg.indexOf('=');
+ if (eqPos > -1) {
+ this.args.put(arg.substring(0, eqPos), arg.substring(eqPos + 1));
+ } else {
+ this.args.put(arg, "");
+ }
+ }
+ }
+ }
+
+ public String get(String key, String defaultValue) {
+ String value = this.args.get(key);
+ return value != null ? value : defaultValue;
+ }
+
+ public int get(String key, int defaultValue) {
+ return this.parseInt(this.get(key, String.valueOf(defaultValue)), defaultValue);
+ }
+
+ public boolean get(String key, boolean defaultValue) {
+ return this.parseBoolean(this.get(key, String.valueOf(defaultValue)), defaultValue);
+ }
+
+ public MemberInfo get(String key) {
+ return MemberInfo.parse(this.get(key, ""));
+ }
+
+ private int parseInt(String string, int defaultValue) {
+ try {
+ return Integer.parseInt(string);
+ } catch (Exception ex) {
+ return defaultValue;
+ }
+ }
+
+ private boolean parseBoolean(String string, boolean defaultValue) {
+ try {
+ return Boolean.parseBoolean(string);
+ } catch (Exception ex) {
+ return defaultValue;
+ }
+ }
+
+ public MemberInfo getTarget() {
+ return MemberInfo.parse(this.target);
+ }
+
+ public int getOrdinal() {
+ return this.ordinal;
+ }
+
+ public int getOpcode() {
+ return this.opcode;
+ }
+}
diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/struct/MemberInfo.java b/src/main/java/org/spongepowered/asm/mixin/injection/struct/MemberInfo.java
new file mode 100644
index 00000000..5e14c80e
--- /dev/null
+++ b/src/main/java/org/spongepowered/asm/mixin/injection/struct/MemberInfo.java
@@ -0,0 +1,188 @@
+/**
+ * This file is part of Sponge, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 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;
+
+
+/**
+ * Information bundle about a member (method or field) parsed from a String token in another annotation, this is used where target members need to
+ * be specified as Strings in order to parse the String representation to something useful.
+ *
+ * Some examples:
+ * // references a method called func_1234_a, if there are multiple methods with the same signature, matches the first occurrence
+ * func_1234_a
+ *
+ * // references a method called func_1234_a, if there are multiple methods with the same signature, matches all occurrences
+ * func_1234_a*
+ *
+ * // references a method called func_1234_a which takes 3 ints and returns a bool
+ * func_1234_a(III)Z
+ *
+ * // references a ctor which takes a single String argument
+ * (Ljava/lang/String;)V
+ *
+ * // references a method called func_1234_a in class foo.bar.Baz
+ * Lfoo/bar/Baz;func_1234_a
+ *
+ * // references a method called func_1234_a in class foo.bar.Baz which takes 3 doubles and returns void
+ * Lfoo/bar/Baz;func_1234_a(DDD)V
+ *
+ * // alternate syntax for the same
+ * foo.bar.Baz.func_1234_a(DDD)V
+ *
+ *
+ * @author Adam Mummery-Smith
+ */
+public class MemberInfo {
+
+ /**
+ * Member owner in internal form but without L;, can be null
+ */
+ public final String owner;
+
+ /**
+ * Member name, can be null to match any member
+ */
+ public final String name;
+
+ /**
+ * Member descriptor, can be null
+ */
+ public final String desc;
+
+ /**
+ * True to match all matching members, not just the first
+ */
+ public final boolean matchAll;
+
+ /**
+ * @param name Member name, must not be null
+ */
+ public MemberInfo(String name, boolean matchAll) {
+ this(name, null, null, matchAll);
+ }
+
+ /**
+ * @param name Member name, must not be null
+ * @param owner Member owner, can be null otherwise must be in internal form without L;
+ */
+ public MemberInfo(String name, String owner, boolean matchAll) {
+ this(name, owner, null, matchAll);
+ }
+
+ /**
+ * @param name Member name, must not be null
+ * @param owner Member owner, can be null otherwise must be in internal form without L;
+ * @param desc Member descriptor, can be null
+ * @param matchAll True to match all matching members, not just the first
+ */
+ public MemberInfo(String name, String owner, String desc, boolean matchAll) {
+ if (owner != null && owner.contains(".")) {
+ throw new IllegalArgumentException("Attempt to instance a MemberInfo with an invalid owner format");
+ }
+
+ this.owner = owner;
+ this.name = name;
+ this.desc = desc;
+ this.matchAll = matchAll;
+ }
+
+ /* (non-Javadoc)
+ * @see java.lang.Object#toString()
+ */
+ @Override
+ public String toString() {
+ return String.format("MemberInfo[OWNER=%s,NAME=%s,DESC=%s,ALL=%s]", this.owner, this.name, this.desc, this.matchAll);
+ }
+
+ /**
+ * Test whether this MemberInfo matches the supplied values. Null values are ignored.
+ */
+ public boolean matches(String owner, String name, String desc) {
+ return this.matches(owner, name, desc, 0);
+ }
+
+ /**
+ * Test whether this MemberInfo matches the supplied values at the specified ordinal. Null values are ignored.
+ */
+ public boolean matches(String owner, String name, String desc, int ordinal) {
+ if (this.desc != null && desc != null && !this.desc.equals(desc)) {
+ return false;
+ }
+ if (this.name != null && name != null && !this.name.equals(name)) {
+ return false;
+ }
+ if (this.owner != null && owner != null && !this.owner.equals(owner)) {
+ return false;
+ }
+ return ordinal == 0 || this.matchAll;
+ }
+
+ /**
+ * Test whether this MemberInfo matches the supplied values. Null values are ignored.
+ */
+ public boolean matches(String name, String desc) {
+ return this.matches(name, desc, 0);
+ }
+
+ /**
+ * Test whether this MemberInfo matches the supplied values at the specified ordinal. Null values are ignored.
+ */
+ public boolean matches(String name, String desc, int ordinal) {
+ return (this.name == null || this.name.equals(name))
+ && (this.desc == null || (desc != null && desc.equals(this.desc)))
+ && (ordinal == 0 || this.matchAll);
+ }
+
+ /**
+ * Parse a MemberInfo from a string
+ */
+ public static MemberInfo parse(String name) {
+ String desc = null;
+ String owner = null;
+
+ int lastDotPos = name.lastIndexOf('.');
+ int semiColonPos = name.indexOf(';');
+ if (lastDotPos > -1) {
+ owner = name.substring(0, lastDotPos).replace('.', '/');
+ name = name.substring(lastDotPos + 1);
+ } else if (semiColonPos > -1 && name.startsWith("L")) {
+ owner = name.substring(1, semiColonPos).replace('.', '/');
+ name = name.substring(semiColonPos + 1);
+ }
+
+ int parenPos = name.indexOf('(');
+ if (parenPos > -1) {
+ desc = name.substring(parenPos);
+ name = name.substring(0, parenPos);
+ }
+
+ boolean matchAll = name.endsWith("*");
+ if (matchAll) name = name.substring(0, name.length() - 1);
+
+ if (name.isEmpty()) name = null;
+
+ return new MemberInfo(name, owner, desc, matchAll);
+ }
+}
diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/tree/ReadOnlyInsnList.java b/src/main/java/org/spongepowered/asm/mixin/injection/tree/ReadOnlyInsnList.java
new file mode 100644
index 00000000..ed378ac3
--- /dev/null
+++ b/src/main/java/org/spongepowered/asm/mixin/injection/tree/ReadOnlyInsnList.java
@@ -0,0 +1,151 @@
+/**
+ * This file contributed from LiteLoader. Pending refactor. DO NOT ALTER THIS FILE.
+ */
+
+package org.spongepowered.asm.mixin.injection.tree;
+
+import java.util.ListIterator;
+
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.InsnList;
+
+/**
+ * Read-only wrapper for InsnList
+ *
+ * @author Adam Mummery-Smith
+ */
+public class ReadOnlyInsnList extends InsnList
+{
+ private InsnList insnList;
+
+ public ReadOnlyInsnList(InsnList insns)
+ {
+ this.insnList = insns;
+ }
+
+ void dispose()
+ {
+ this.insnList = null;
+ }
+
+ @Override
+ public void set(AbstractInsnNode location, AbstractInsnNode insn)
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void add(AbstractInsnNode insn)
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void add(InsnList insns)
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void insert(AbstractInsnNode insn)
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void insert(InsnList insns)
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void insert(AbstractInsnNode location, AbstractInsnNode insn)
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void insert(AbstractInsnNode location, InsnList insns)
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void insertBefore(AbstractInsnNode location, AbstractInsnNode insn)
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void insertBefore(AbstractInsnNode location, InsnList insns)
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void remove(AbstractInsnNode insn)
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public AbstractInsnNode[] toArray()
+ {
+// throw new UnsupportedOperationException();
+ return this.insnList.toArray();
+ }
+
+ @Override
+ public int size()
+ {
+ return this.insnList.size();
+ }
+
+ @Override
+ public AbstractInsnNode getFirst()
+ {
+ return this.insnList.getFirst();
+ }
+
+ @Override
+ public AbstractInsnNode getLast()
+ {
+ return this.insnList.getLast();
+ }
+
+ @Override
+ public AbstractInsnNode get(int index)
+ {
+ return this.insnList.get(index);
+ }
+
+ @Override
+ public boolean contains(AbstractInsnNode insn)
+ {
+ return this.insnList.contains(insn);
+ }
+
+ @Override
+ public int indexOf(AbstractInsnNode insn)
+ {
+ return this.insnList.indexOf(insn);
+ }
+
+ @Override
+ public ListIterator iterator()
+ {
+ return this.insnList.iterator();
+ }
+
+ @Override
+ public ListIterator iterator(int index)
+ {
+ return this.insnList.iterator(index);
+ }
+
+ @Override
+ public void resetLabels()
+ {
+ this.insnList.resetLabels();
+ }
+}
diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinInfo.java b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinInfo.java
index 9c54b580..c7787bf8 100644
--- a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinInfo.java
+++ b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinInfo.java
@@ -55,7 +55,7 @@ class MixinInfo implements Comparable {
/**
* Logger
*/
- private final transient Logger logger = LogManager.getLogger("sponge");
+ private final transient Logger logger = LogManager.getLogger("mixin");
/**
* Parent configuration which declares this mixin
diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinTransformer.java b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinTransformer.java
index e3823c52..6525153a 100644
--- a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinTransformer.java
+++ b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinTransformer.java
@@ -32,7 +32,6 @@ import java.util.Iterator;
import java.util.List;
import net.minecraft.launchwrapper.IClassTransformer;
-import net.minecraft.launchwrapper.Launch;
import org.apache.commons.io.FileUtils;
import org.apache.logging.log4j.LogManager;
@@ -41,6 +40,7 @@ import org.apache.logging.log4j.core.helpers.Booleans;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.AnnotationNode;
import org.objectweb.asm.tree.ClassNode;
import org.objectweb.asm.tree.FieldInsnNode;
import org.objectweb.asm.tree.FieldNode;
@@ -51,6 +51,8 @@ import org.spongepowered.asm.mixin.InvalidMixinException;
import org.spongepowered.asm.mixin.MixinEnvironment;
import org.spongepowered.asm.mixin.Overwrite;
import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.InjectionInfo;
import org.spongepowered.asm.transformers.TreeTransformer;
import org.spongepowered.asm.util.ASMHelper;
@@ -59,12 +61,14 @@ import org.spongepowered.asm.util.ASMHelper;
*/
public class MixinTransformer extends TreeTransformer {
+ private static final String CLINIT = "";
+
private static final boolean DEBUG_EXPORT = Booleans.parseBoolean(System.getProperty("mixin.debug.export"), false);
/**
* Log all the things
*/
- private final Logger logger = LogManager.getLogger("sponge");
+ private final Logger logger = LogManager.getLogger("mixin");
/**
* Mixin configuration bundle
@@ -182,6 +186,7 @@ public class MixinTransformer extends TreeTransformer {
this.applyMixinAttributes(targetClass, mixin);
this.applyMixinFields(targetClass, mixin);
this.applyMixinMethods(targetClass, mixin);
+ this.applyInjections(targetClass, mixin);
} catch (Exception ex) {
throw new InvalidMixinException("Unexpecteded error whilst applying the mixin class", ex);
}
@@ -296,7 +301,7 @@ public class MixinTransformer extends TreeTransformer {
throw new InvalidMixinException(String.format("Overwrite target %s was not located in the target class", mixinMethod.name));
}
targetClass.methods.add(mixinMethod);
- } else if ("".equals(mixinMethod.name)) {
+ } else if (MixinTransformer.CLINIT.equals(mixinMethod.name)) {
// Class initialiser insns get appended
this.appendInsns(targetClass, mixinMethod.name, mixinMethod);
}
@@ -371,6 +376,28 @@ public class MixinTransformer extends TreeTransformer {
}
}
+ /**
+ * Process {@link Inject} annotations and inject callbacks to annotated methods
+ *
+ * @param targetClass
+ * @param mixin
+ */
+ private void applyInjections(ClassNode targetClass, MixinData mixin) {
+ for (MethodNode method : targetClass.methods) {
+ AnnotationNode injectAnnotation = ASMHelper.getVisibleAnnotation(method, Inject.class);
+ if (injectAnnotation == null) {
+ continue;
+ }
+
+ InjectionInfo injectInfo = new InjectionInfo(targetClass, method, injectAnnotation);
+ if (injectInfo.isValid()) {
+ injectInfo.inject();
+ }
+
+ method.visibleAnnotations.remove(injectAnnotation);
+ }
+ }
+
/**
* Finds a method in the target class
*
@@ -384,7 +411,7 @@ public class MixinTransformer extends TreeTransformer {
return target;
}
}
-
+
return null;
}
diff --git a/src/main/java/org/spongepowered/asm/util/ASMHelper.java b/src/main/java/org/spongepowered/asm/util/ASMHelper.java
index 84a03563..fbbe7efb 100644
--- a/src/main/java/org/spongepowered/asm/util/ASMHelper.java
+++ b/src/main/java/org/spongepowered/asm/util/ASMHelper.java
@@ -442,6 +442,19 @@ public class ASMHelper {
return ASMHelper.getAnnotationValue(annotation, "value");
}
+ /**
+ * Get the value of an annotation node and do pseudo-duck-typing via Java's crappy generics
+ *
+ * @param annotation Annotation node to query
+ * @param key Key to search for
+ * @param defaultValue Value to return if the specified key is not found or is null
+ * @return duck-typed annotation value, null if missing, or inevitable ClassCastException if your duck is actually a rooster
+ */
+ public static T getAnnotationValue(AnnotationNode annotation, String key, T defaultValue) {
+ T returnValue = ASMHelper.getAnnotationValue(annotation, key);
+ return returnValue != null ? returnValue : defaultValue;
+ }
+
/**
* Get the value of an annotation node and do pseudo-duck-typing via Java's crappy generics
*
@@ -469,4 +482,12 @@ public class ASMHelper {
return null;
}
+
+ public static boolean methodIsStatic(MethodNode method) {
+ return (method.access & Opcodes.ACC_STATIC) == Opcodes.ACC_STATIC;
+ }
+
+ public static boolean fieldIsStatic(FieldNode field) {
+ return (field.access & Opcodes.ACC_STATIC) == Opcodes.ACC_STATIC;
+ }
}
diff --git a/src/main/java/org/spongepowered/asm/util/ByteCodeUtilities.java b/src/main/java/org/spongepowered/asm/util/ByteCodeUtilities.java
new file mode 100644
index 00000000..a5fc67b5
--- /dev/null
+++ b/src/main/java/org/spongepowered/asm/util/ByteCodeUtilities.java
@@ -0,0 +1,809 @@
+/**
+ * This file contributed from LiteLoader. Pending merge into ASMHelper. DO NOT ALTER THIS FILE.
+ */
+
+package org.spongepowered.asm.util;
+
+import java.io.IOException;
+import java.lang.annotation.Annotation;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import net.minecraft.launchwrapper.IClassTransformer;
+import net.minecraft.launchwrapper.Launch;
+
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+import org.objectweb.asm.tree.*;
+import org.objectweb.asm.tree.analysis.Analyzer;
+import org.objectweb.asm.tree.analysis.AnalyzerException;
+import org.objectweb.asm.tree.analysis.BasicValue;
+import org.objectweb.asm.tree.analysis.Frame;
+import org.objectweb.asm.tree.analysis.SimpleVerifier;
+
+//import com.mumfrey.liteloader.core.runtime.Obf;
+
+/**
+ * Utility methods for working with bytecode using ASM
+ *
+ * @author Adam Mummery-Smith
+ */
+public abstract class ByteCodeUtilities
+{
+ private static Map> calculatedLocalVariables = new HashMap>();
+
+ private ByteCodeUtilities() {}
+
+// /**
+// * Replace all constructor invokations for the target class in the supplied classNode with invokations of the replacement class
+// *
+// * @param classNode Class to search in
+// * @param target Target type
+// * @param replacement Replacement type
+// */
+// public static void replaceConstructors(ClassNode classNode, Obf target, Obf replacement)
+// {
+// for (MethodNode method : classNode.methods)
+// {
+// ByteCodeUtilities.replaceConstructors(method, target, replacement);
+// }
+// }
+
+// /**
+// * Replace all constructor invokations for the target class in the supplied method with invokations of the replacement class
+// *
+// * @param method Method to look in
+// * @param target Target type
+// * @param replacement Replacement type
+// */
+// public static void replaceConstructors(MethodNode method, Obf target, Obf replacement)
+// {
+// Iterator iter = method.instructions.iterator();
+// while (iter.hasNext())
+// {
+// AbstractInsnNode insn = iter.next();
+// if (insn.getOpcode() == Opcodes.NEW)
+// {
+// TypeInsnNode typeInsn = (TypeInsnNode)insn;
+// if (target.obf.equals(typeInsn.desc) || target.ref.equals(typeInsn.desc))
+// {
+// typeInsn.desc = replacement.ref;
+// }
+// }
+// else if (insn instanceof MethodInsnNode && insn.getOpcode() == Opcodes.INVOKESPECIAL)
+// {
+// MethodInsnNode methodInsn = (MethodInsnNode)insn;
+// if ((target.obf.equals(methodInsn.owner) || target.ref.equals(methodInsn.owner)) && "".equals(methodInsn.name))
+// {
+// methodInsn.owner = replacement.ref;
+// }
+// }
+// }
+// }
+
+ /**
+ * Injects appropriate LOAD opcodes into the supplied InsnList appropriate for each entry in the args array starting at pos
+ *
+ * @param args Argument types
+ * @param insns Instruction List to inject into
+ * @param pos Start position
+ */
+ public static void loadArgs(Type[] args, InsnList insns, int pos)
+ {
+ ByteCodeUtilities.loadArgs(args, insns, pos, -1);
+ }
+
+ /**
+ * Injects appropriate LOAD opcodes into the supplied InsnList appropriate for each entry in the args array starting at start and ending at end
+ *
+ * @param args Argument types
+ * @param insns Instruction List to inject into
+ * @param start Start position
+ * @param end End position
+ */
+ public static void loadArgs(Type[] args, InsnList insns, int start, int end)
+ {
+ int pos = start;
+
+ for (Type type : args)
+ {
+ insns.add(new VarInsnNode(type.getOpcode(Opcodes.ILOAD), pos));
+ pos += type.getSize();
+ if (end >= start && pos >= end) return;
+ }
+ }
+
+ /**
+ * Injects appropriate LOAD opcodes into the supplied InsnList for each entry in the supplied locals array starting at pos
+ *
+ * @param locals Local types (can contain nulls for uninitialised, TOP, or RETURN values in locals)
+ * @param insns Instruction List to inject into
+ * @param pos Start position
+ */
+ public static void loadLocals(Type[] locals, InsnList insns, int pos)
+ {
+ for (; pos < locals.length; pos++)
+ {
+ if (locals[pos] != null)
+ {
+ insns.add(new VarInsnNode(locals[pos].getOpcode(Opcodes.ILOAD), pos));
+ }
+ }
+ }
+
+ /**
+ * Get the first variable index in the supplied method which is not an argument or "this" reference, this corresponds
+ * to the size of the arguments passed in to the method plus an extra spot for "this" if the method is non-static
+ *
+ * @param method MethodNode to inspect
+ * @return first available local index which is NOT used by a method argument or "this"
+ */
+ public static int getFirstNonArgLocalIndex(MethodNode method)
+ {
+ return ByteCodeUtilities.getFirstNonArgLocalIndex(Type.getArgumentTypes(method.desc), (method.access & Opcodes.ACC_STATIC) == 0);
+ }
+
+ /**
+ * Get the first non-arg variable index based on the supplied arg array and whether to include the "this" reference,
+ * this corresponds to the size of the arguments passed in to the method plus an extra spot for "this" is specified
+
+ * @param args Method arguments
+ * @param includeThis Whether to include a slot for "this" (generally true for all non-static methods)
+ * @return first available local index which is NOT used by a method argument or "this"
+ */
+ public static int getFirstNonArgLocalIndex(Type[] args, boolean includeThis)
+ {
+ return ByteCodeUtilities.getArgsSize(args) + (includeThis ? 1 : 0);
+ }
+
+ /**
+ * Get the size of the specified args array in local variable terms (eg. doubles and longs take two spaces)
+ *
+ * @param args Method argument types as array
+ * @return size of the specified arguments array in terms of stack slots
+ */
+ public static int getArgsSize(Type[] args)
+ {
+ int size = 0;
+
+ for (Type type : args)
+ {
+ size += type.getSize();
+ }
+
+ return size;
+ }
+
+ /**
+ * Attempts to identify available locals at an arbitrary point in the bytecode specified by node.
+ *
+ * This method builds an approximate view of the locals available at an arbitrary point in the bytecode by examining the following
+ * features in the bytecode:
+ *
+ * * Any available stack map frames
+ * * STORE opcodes
+ * * The local variable table
+ *
+ * Inference proceeds by walking the bytecode from the start of the method looking for stack frames and STORE opcodes. When either
+ * of these is encountered, an attempt is made to cross-reference the values in the stack map or STORE opcode with the value in the
+ * local variable table which covers the code range. Stack map frames overwrite the entire simulated local variable table with their
+ * own value types, STORE opcodes overwrite only the local slot to which they pertain. Values in the simulated locals array are spaced
+ * according to their size (unlike the representation in FrameNode) and this TOP, NULL and UNINTITIALIZED_THIS opcodes will be
+ * represented as null values in the simulated frame.
+ *
+ * This code does not currently simulate the prescribed JVM behaviour where overwriting the second slot of a DOUBLE or LONG actually
+ * invalidates the DOUBLE or LONG stored in the previous location, so we have to hope (for now) that this behaviour isn't emitted by
+ * the compiler or any upstream transformers. I may have to re-think this strategy if this situation is encountered in the wild.
+ *
+ * @param classNode ClassNode containing the method, used to initialise the implicit "this" reference in simple methods with no stack frames
+ * @param method MethodNode to explore
+ * @param node Node indicating the position at which to determine the locals state. The locals will be enumerated UP TO the specified
+ * node, so bear in mind that if the specified node is itself a STORE opcode, then we will be looking at the state of the locals
+ * PRIOR to its invokation
+ * @return A sparse array containing a view (hopefully) of the locals at the specified location
+ */
+ public static LocalVariableNode[] getLocalsAt(ClassNode classNode, MethodNode method, AbstractInsnNode node)
+ {
+ LocalVariableNode[] frame = new LocalVariableNode[method.maxLocals];
+
+ // Initialise implicit "this" reference in non-static methods
+ if ((method.access & Opcodes.ACC_STATIC) == 0)
+ {
+ frame[0] = new LocalVariableNode("this", classNode.name, null, null, null, 0);
+ }
+
+ for (Iterator iter = method.instructions.iterator(); iter.hasNext();)
+ {
+ AbstractInsnNode insn = iter.next();
+ if (insn instanceof FrameNode)
+ {
+ FrameNode frameNode = (FrameNode)insn;
+
+ // localPos tracks the location in the frame node's locals list, which doesn't leave space for TOP entries
+ for (int localPos = 0, framePos = 0; framePos < frame.length; framePos++, localPos++)
+ {
+ // Get the local at the current position in the FrameNode's locals list
+ final Object localType = (localPos < frameNode.local.size()) ? frameNode.local.get(localPos) : null;
+
+ if (localType instanceof String) // String refers to a reference type
+ {
+ frame[framePos] = ByteCodeUtilities.getLocalVariableAt(classNode, method, node, framePos);
+ }
+ else if (localType instanceof Integer) // Integer refers to a primitive type or other marker
+ {
+ boolean isMarkerType = localType == Opcodes.UNINITIALIZED_THIS || localType == Opcodes.TOP || localType == Opcodes.NULL;
+ boolean is32bitValue = localType == Opcodes.INTEGER || localType == Opcodes.FLOAT;
+ boolean is64bitValue = localType == Opcodes.DOUBLE || localType == Opcodes.LONG;
+ if (isMarkerType)
+ {
+ frame[framePos] = null;
+ }
+ else if (is32bitValue || is64bitValue)
+ {
+ frame[framePos] = ByteCodeUtilities.getLocalVariableAt(classNode, method, node, framePos);
+
+ if (is64bitValue)
+ {
+ framePos++;
+ frame[framePos] = null; // TOP
+ }
+ }
+ else
+ {
+ throw new RuntimeException("Unrecognised locals opcode " + localType + " in locals array at position " + localPos + " in " + classNode.name + "." + method.name + method.desc);
+ }
+ }
+ else if (localType == null)
+ {
+ frame[framePos] = null;
+ }
+ else
+ {
+ throw new RuntimeException("Invalid value " + localType + " in locals array at position " + localPos + " in " + classNode.name + "." + method.name + method.desc);
+ }
+ }
+ }
+ else if (insn instanceof VarInsnNode)
+ {
+ VarInsnNode varNode = (VarInsnNode)insn;
+ frame[varNode.var] = ByteCodeUtilities.getLocalVariableAt(classNode, method, node, varNode.var);
+ }
+ else if (insn == node)
+ {
+ break;
+ }
+ }
+
+ return frame;
+ }
+
+ /**
+ * Attempts to locate the appropriate entry in the local variable table for the specified local variable index at the location
+ * specified by node.
+ *
+ * @param classNode Containing class
+ * @param method Method
+ * @param node Instruction defining the location to get the local variable table at
+ * @param var Local variable index
+ * @return a LocalVariableNode containing information about the local variable at the specified location in the specified local slot
+ */
+ public static LocalVariableNode getLocalVariableAt(ClassNode classNode, MethodNode method, AbstractInsnNode node, int var)
+ {
+ LocalVariableNode localVariableNode = null;
+
+ int pos = method.instructions.indexOf(node);
+
+ List localVariables = ByteCodeUtilities.getLocalVariableTable(classNode, method);
+ for (LocalVariableNode local : localVariables)
+ {
+ if (local.index != var) continue;
+ int start = method.instructions.indexOf(local.start);
+ int end = method.instructions.indexOf(local.end);
+ if (localVariableNode == null || start < pos && end > pos)
+ {
+ localVariableNode = local;
+ }
+ }
+
+ return localVariableNode;
+ }
+
+ /**
+ * Fetches or generates the local variable table for the specified method. Since Mojang strip the local variable table
+ * as part of the obfuscation process, we need to generate the local variable table when running obfuscated. We cache
+ * the generated tables so that we only need to do the relatively expensive calculation once per method we encounter.
+ *
+ * @param classNode Containing class
+ * @param method Method
+ */
+ public static List getLocalVariableTable(ClassNode classNode, MethodNode method)
+ {
+ if (method.localVariables.isEmpty())
+ {
+ String signature = String.format("%s.%s%s", classNode.name, method.name, method.desc);
+
+ List localVars = ByteCodeUtilities.calculatedLocalVariables.get(signature);
+ if (localVars != null)
+ {
+ return localVars;
+ }
+
+ localVars = ByteCodeUtilities.generateLocalVariableTable(classNode, method);
+ ByteCodeUtilities.calculatedLocalVariables.put(signature, localVars);
+ return localVars;
+ }
+
+ return method.localVariables;
+ }
+
+ /**
+ * Use ASM Analyzer to generate the local variable table for the specified method
+ *
+ * @param classNode Containing class
+ * @param method Method
+ */
+ public static List generateLocalVariableTable(ClassNode classNode, MethodNode method)
+ {
+ List interfaces = null;
+ if (classNode.interfaces != null)
+ {
+ interfaces = new ArrayList();
+ for (String iface : classNode.interfaces)
+ {
+ interfaces.add(Type.getObjectType(iface));
+ }
+ }
+
+ Type objectType = null;
+ if (classNode.superName != null)
+ {
+ objectType = Type.getObjectType(classNode.superName);
+ }
+
+ // Use Analyzer to generate the bytecode frames
+ Analyzer analyzer = new Analyzer(new SimpleVerifier(Type.getObjectType(classNode.name), objectType, interfaces, false));
+ try
+ {
+ analyzer.analyze(classNode.name, method);
+ }
+ catch (AnalyzerException ex)
+ {
+ ex.printStackTrace();
+ }
+
+ // Get frames from the Analyzer
+ Frame[] frames = analyzer.getFrames();
+
+ // Record the original size of hte method
+ int methodSize = method.instructions.size();
+
+ // List of LocalVariableNodes to return
+ List localVariables = new ArrayList();
+
+ LocalVariableNode[] localNodes = new LocalVariableNode[method.maxLocals]; // LocalVariableNodes for current frame
+ BasicValue[] locals = new BasicValue[method.maxLocals]; // locals in previous frame, used to work out what changes between frames
+ LabelNode[] labels = new LabelNode[methodSize]; // Labels to add to the method, for the markers
+
+ // Traverse the frames and work out when locals begin and end
+ for (int i = 0; i < methodSize; i++)
+ {
+ Frame f = frames[i];
+ if (f == null) continue;
+ LabelNode label = null;
+
+ for (int j = 0; j < f.getLocals(); j++)
+ {
+ BasicValue local = f.getLocal(j);
+ if (local == null && locals[j] == null) continue;
+ if (local != null && local.equals(locals[j])) continue;
+
+ if (label == null)
+ {
+ label = new LabelNode();
+ labels[i] = label;
+ }
+
+ if (local == null && locals[j] != null)
+ {
+ localVariables.add(localNodes[j]);
+ localNodes[j].end = label;
+ localNodes[j] = null;
+ }
+ else if (local != null)
+ {
+ if (locals[j] != null)
+ {
+ localVariables.add(localNodes[j]);
+ localNodes[j].end = label;
+ localNodes[j] = null;
+ }
+
+ String desc = (local.getType() != null) ? local.getType().getDescriptor() : null;
+ localNodes[j] = new LocalVariableNode("var" + j, desc, null, label, null, j);
+ }
+
+ locals[j] = local;
+ }
+ }
+
+ // Reached the end of the method so flush all current locals and mark the end
+ LabelNode label = null;
+ for (int k = 0; k < localNodes.length; k++)
+ {
+ if (localNodes[k] != null)
+ {
+ if (label == null)
+ {
+ label = new LabelNode();
+ method.instructions.add(label);
+ }
+
+ localNodes[k].end = label;
+ localVariables.add(localNodes[k]);
+ }
+ }
+
+ // Insert generated labels into the method body
+ for (int n = methodSize - 1; n >= 0; n--)
+ {
+ if (labels[n] != null)
+ {
+ method.instructions.insert(method.instructions.get(n), labels[n]);
+ }
+ }
+
+ return localVariables;
+ }
+
+ /**
+ * Get the source code name for the specified type
+ *
+ * @param type Type to generate a friendly name for
+ * @return String representation of the specified type, eg "int" for an integer primitive or "String" for java.lang.String
+ */
+ public static String getTypeName(Type type)
+ {
+ switch (type.getSort())
+ {
+ case Type.BOOLEAN: return "boolean";
+ case Type.CHAR: return "char";
+ case Type.BYTE: return "byte";
+ case Type.SHORT: return "short";
+ case Type.INT: return "int";
+ case Type.FLOAT: return "float";
+ case Type.LONG: return "long";
+ case Type.DOUBLE: return "double";
+ case Type.ARRAY: return ByteCodeUtilities.getTypeName(type.getElementType()) + "[]";
+ case Type.OBJECT:
+ String typeName = type.getClassName();
+ typeName = typeName.substring(typeName.lastIndexOf('.') + 1);
+ return typeName;
+ }
+
+ return "Object";
+ }
+
+// /**
+// * Finds a method in the target class, uses names specified in the {@link Obfuscated} annotation if present
+// *
+// * @param targetClass Class to search in
+// * @param searchFor Method to search for
+// */
+// public static MethodNode findTargetMethod(ClassNode targetClass, MethodNode searchFor)
+// {
+// for (MethodNode target : targetClass.methods)
+// {
+// if (target.name.equals(searchFor.name) && target.desc.equals(searchFor.desc))
+// return target;
+// }
+//
+// AnnotationNode obfuscatedAnnotation = ByteCodeUtilities.getVisibleAnnotation(searchFor, Obfuscated.class);
+// if (obfuscatedAnnotation != null)
+// {
+// for (String obfuscatedName : ByteCodeUtilities.>getAnnotationValue(obfuscatedAnnotation))
+// {
+// for (MethodNode target : targetClass.methods)
+// {
+// if (target.name.equals(obfuscatedName) && target.desc.equals(searchFor.desc))
+// return target;
+// }
+// }
+// }
+//
+// return null;
+// }
+
+// /**
+// * Finds a field in the target class, uses names specified in the {@link Obfuscated} annotation if present
+// *
+// * @param targetClass Class to search in
+// * @param searchFor Field to search for
+// */
+// public static FieldNode findTargetField(ClassNode targetClass, FieldNode searchFor)
+// {
+// for (FieldNode target : targetClass.fields)
+// {
+// if (target.name.equals(searchFor.name))
+// return target;
+// }
+//
+// AnnotationNode obfuscatedAnnotation = ByteCodeUtilities.getVisibleAnnotation(searchFor, Obfuscated.class);
+// if (obfuscatedAnnotation != null)
+// {
+// for (String obfuscatedName : ByteCodeUtilities.>getAnnotationValue(obfuscatedAnnotation))
+// {
+// for (FieldNode target : targetClass.fields)
+// {
+// if (target.name.equals(obfuscatedName))
+// return target;
+// }
+// }
+// }
+//
+// return null;
+// }
+
+// /**
+// * Find a method in the target class which matches the specified method name and descriptor
+// *
+// * @param classNode
+// * @param searchFor
+// * @param desc
+// */
+// public static MethodNode findMethod(ClassNode classNode, Obf searchFor, String desc)
+// {
+// int ordinal = 0;
+//
+// for (MethodNode method : classNode.methods)
+// {
+// if (searchFor.matches(method.name, ordinal++) && method.desc.equals(desc))
+// return method;
+// }
+//
+// return null;
+// }
+
+// /**
+// * Find a field in the target class which matches the specified field name
+// *
+// * @param classNode
+// * @param searchFor
+// */
+// public static FieldNode findField(ClassNode classNode, Obf searchFor)
+// {
+// int ordinal = 0;
+//
+// for (FieldNode field : classNode.fields)
+// {
+// if (searchFor.matches(field.name, ordinal++))
+// return field;
+// }
+//
+// return null;
+// }
+
+ public static ClassNode loadClass(String className) throws IOException
+ {
+ return ByteCodeUtilities.loadClass(className, true, null);
+ }
+
+ public static ClassNode loadClass(String className, boolean runTransformers) throws IOException
+ {
+ return ByteCodeUtilities.loadClass(className, runTransformers, null);
+ }
+
+ public static ClassNode loadClass(String className, IClassTransformer source) throws IOException
+ {
+ return ByteCodeUtilities.loadClass(className, source != null, source);
+ }
+
+ public static ClassNode loadClass(String className, boolean runTransformers, IClassTransformer source) throws IOException
+ {
+ byte[] bytes = Launch.classLoader.getClassBytes(className);
+
+ if (runTransformers)
+ {
+ bytes = ByteCodeUtilities.applyTransformers(className, bytes, source);
+ }
+
+ return ByteCodeUtilities.readClass(bytes);
+ }
+
+ public static ClassNode readClass(byte[] basicClass)
+ {
+ ClassReader classReader = new ClassReader(basicClass);
+ ClassNode classNode = new ClassNode();
+ classReader.accept(classNode, ClassReader.EXPAND_FRAMES);
+ return classNode;
+ }
+
+ public static byte[] applyTransformers(String className, byte[] basicClass)
+ {
+ return ByteCodeUtilities.applyTransformers(className, basicClass, null);
+ }
+
+ public static byte[] applyTransformers(String className, byte[] basicClass, IClassTransformer source)
+ {
+ final List transformers = Launch.classLoader.getTransformers();
+
+ for (final IClassTransformer transformer : transformers)
+ {
+ if (transformer != source)
+ {
+ basicClass = transformer.transform(className, className, basicClass);
+ }
+ }
+
+ return basicClass;
+ }
+
+ /**
+ * Get an annotation of the specified class from the supplied field node
+ */
+ public static AnnotationNode getVisibleAnnotation(FieldNode field, Class extends Annotation> annotationClass)
+ {
+ return ByteCodeUtilities.getAnnotation(field.visibleAnnotations, Type.getDescriptor(annotationClass));
+ }
+
+ /**
+ * Get an annotation of the specified class from the supplied field node
+ */
+ public static AnnotationNode getInvisibleAnnotation(FieldNode field, Class extends Annotation> annotationClass)
+ {
+ return ByteCodeUtilities.getAnnotation(field.invisibleAnnotations, Type.getDescriptor(annotationClass));
+ }
+
+ /**
+ * Get an annotation of the specified class from the supplied method node
+ */
+ public static AnnotationNode getVisibleAnnotation(MethodNode method, Class extends Annotation> annotationClass)
+ {
+ return ByteCodeUtilities.getAnnotation(method.visibleAnnotations, Type.getDescriptor(annotationClass));
+ }
+
+ /**
+ * Get an annotation of the specified class from the supplied method node
+ */
+ public static AnnotationNode getInvisibleAnnotation(MethodNode method, Class extends Annotation> annotationClass)
+ {
+ return ByteCodeUtilities.getAnnotation(method.invisibleAnnotations, Type.getDescriptor(annotationClass));
+ }
+
+ /**
+ * Get an annotation of the specified class from the supplied class node
+ */
+ public static AnnotationNode getVisibleAnnotation(ClassNode classNode, Class extends Annotation> annotationClass)
+ {
+ return ByteCodeUtilities.getAnnotation(classNode.visibleAnnotations, Type.getDescriptor(annotationClass));
+ }
+
+ /**
+ * Get an annotation of the specified class from the supplied class node
+ */
+ public static AnnotationNode getInvisibleAnnotation(ClassNode classNode, Class extends Annotation> annotationClass)
+ {
+ return ByteCodeUtilities.getAnnotation(classNode.invisibleAnnotations, Type.getDescriptor(annotationClass));
+ }
+
+ /**
+ * Get an annotation of the specified class from the supplied list of annotations, returns null if no matching annotation was found
+ */
+ public static AnnotationNode getAnnotation(List annotations, String annotationType)
+ {
+ if (annotations != null)
+ {
+ for (AnnotationNode annotation : annotations)
+ {
+ if (annotationType.equals(annotation.desc))
+ return annotation;
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * Get the value of an annotation node (the value at key "value")
+ *
+ * @param annotation Annotation node to inspect
+ */
+ public static T getAnnotationValue(AnnotationNode annotation)
+ {
+ return ByteCodeUtilities.getAnnotationValue(annotation, "value");
+ }
+
+ /**
+ * Get the value of an annotation node
+ *
+ * @param annotation
+ * @param key
+ */
+ @SuppressWarnings("unchecked")
+ public static T getAnnotationValue(AnnotationNode annotation, String key)
+ {
+ if (annotation == null || annotation.values == null)
+ return null;
+
+ boolean getNextValue = false;
+ for (Object value : annotation.values)
+ {
+ if (getNextValue) return (T)value;
+ if (value.equals(key)) getNextValue = true;
+ }
+ return null;
+ }
+
+// /**
+// * @param returnType
+// * @param args
+// */
+// public static String generateDescriptor(Type returnType, Object... args)
+// {
+// return ByteCodeUtilities.generateDescriptor(Obf.MCP, returnType, args);
+// }
+//
+// /**
+// * @param returnType
+// * @param args
+// */
+// public static String generateDescriptor(Obf returnType, Object... args)
+// {
+// return ByteCodeUtilities.generateDescriptor(Obf.MCP, returnType, args);
+// }
+//
+// /**
+// * @param returnType
+// * @param args
+// */
+// public static String generateDescriptor(String returnType, Object... args)
+// {
+// return ByteCodeUtilities.generateDescriptor(Obf.MCP, returnType, args);
+// }
+
+// /**
+// * @param obfType
+// * @param returnType
+// * @param args
+// */
+// public static String generateDescriptor(int obfType, Object returnType, Object... args)
+// {
+// StringBuilder sb = new StringBuilder().append('(');;
+//
+// for (Object arg : args)
+// {
+// sb.append(ByteCodeUtilities.toDescriptor(obfType, arg));
+// }
+//
+// return sb.append(')').append(returnType != null ? ByteCodeUtilities.toDescriptor(obfType, returnType) : "V").toString();
+// }
+
+// /**
+// * @param obfType
+// * @param arg
+// */
+// private static String toDescriptor(int obfType, Object arg)
+// {
+// if (arg instanceof Obf)
+// {
+// return ((Obf)arg).getDescriptor(obfType);
+// }
+// else if (arg instanceof String)
+// {
+// return (String)arg;
+// }
+// else if (arg instanceof Type)
+// {
+// return arg.toString();
+// }
+// else if (arg instanceof Class)
+// {
+// return Type.getDescriptor((Class>)arg).toString();
+// }
+//
+// return arg == null ? "" : arg.toString();
+// }
+}