mirror of
https://github.com/LegacyModdingMC/UniMix.git
synced 2026-11-21 04:32:33 +00:00
Fixing code style from LiteLoader, fix checkstyle, complete javadoc
This commit is contained in:
1 parent
6c9cab6559
commit
fc1742a54e
27 files changed
+2102
-2123
No files matched your search
@@ -67,7 +67,6 @@ public class MixinEnvironment {
|
||||
|
||||
/**
|
||||
* Add a mixin configuration to the blackboard
|
||||
* @return
|
||||
*/
|
||||
public MixinEnvironment addConfiguration(String config) {
|
||||
this.getMixinConfigs().add(config);
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
/**
|
||||
/*
|
||||
* This file is part of Sponge, licensed under the MIT License (MIT).
|
||||
*
|
||||
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
|
||||
@@ -24,23 +24,78 @@
|
||||
*/
|
||||
package org.spongepowered.asm.mixin.injection;
|
||||
|
||||
import java.lang.annotation.Retention;
|
||||
import java.lang.annotation.RetentionPolicy;
|
||||
|
||||
/**
|
||||
* Annotation for specifying the type of {@link InjectionPoint} to use to perform an {@link Inject} process. This annotation allows the
|
||||
* {@link InjectionPoint} class to be specified, as well as arguments to be passed to the {@link InjectionPoint} instance to configure it. The data
|
||||
* contained in the annotation are wrapped into a {@link org.spongepowered.asm.mixin.injection.struct.InjectionInfo InjectionInfo} object before
|
||||
* being passed to the {@link InjectionPoint} for parsing. All values are optional apart from {@link #value}, which specifies the type of
|
||||
* {@link InjectionPoint} to use. All other parameters depend on the InjectionPoint chosen, and the javadoc for each {@link InjectionPoint} class
|
||||
* should be consulted for the meaning of the argument to that particular class. A general description of each parameter is provided below.
|
||||
*/
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
public @interface At {
|
||||
/**
|
||||
* <b>Shift</b> is used to shift resulting opcodes
|
||||
*/
|
||||
public enum Shift {
|
||||
NONE,
|
||||
BEFORE,
|
||||
AFTER
|
||||
AFTER,
|
||||
BY
|
||||
}
|
||||
|
||||
/**
|
||||
* <p>Type of {@link InjectionPoint} to use. Can be a built-in class or the fully-qualified name of a custom class which extends
|
||||
* {@link InjectionPoint}.</p>
|
||||
*
|
||||
* <p>Built-in types are {@link org.spongepowered.asm.mixin.injection.points.MethodHead HEAD},
|
||||
* {@link org.spongepowered.asm.mixin.injection.points.BeforeReturn RETURN},
|
||||
* {@link org.spongepowered.asm.mixin.injection.points.BeforeInvoke INVOKE},
|
||||
* {@link org.spongepowered.asm.mixin.injection.points.BeforeFieldAccess FIELD},
|
||||
* {@link org.spongepowered.asm.mixin.injection.points.BeforeNew NEW},
|
||||
* {@link org.spongepowered.asm.mixin.injection.points.BeforeStringInvoke INVOKE_STRING} and
|
||||
* {@link org.spongepowered.asm.mixin.injection.points.JumpInsnPoint JUMP}. See the javadoc for each type for more details on the scheme used by
|
||||
* each injection point.</p>
|
||||
*/
|
||||
public String value();
|
||||
|
||||
public String[] args() default {};
|
||||
|
||||
public String target() default "";
|
||||
|
||||
/**
|
||||
* Shift type for returned opcodes. For example use {@link At.Shift#AFTER AFTER} with an INVOKE InjectionPoint to move the returned opcodes to
|
||||
* <i>after</i> the invoation. Use {@link At.Shift#BY BY} in conjunction with the {@link #by} parameter to shift by an arbitrary number of
|
||||
* opcodes.
|
||||
*/
|
||||
public Shift shift() default Shift.NONE;
|
||||
|
||||
/**
|
||||
* If {@link #shift} is specified as {@link At.Shift#BY BY}, specifies the number of opcodes to shift by (negative numbers are allowed).
|
||||
*/
|
||||
public int by() default 0;
|
||||
|
||||
/**
|
||||
* <p>The <b>named arguments</b> list is used to expand the scope of the annotation beyond the fixed values below in order to accommodate the
|
||||
* needs of custom injection point classes.
|
||||
*/
|
||||
public String[] args() default { };
|
||||
|
||||
/**
|
||||
* Target member used by INVOKE, INVOKE_STRING and FIELD
|
||||
*/
|
||||
public String target() default "";
|
||||
|
||||
/**
|
||||
* Ordinal offset. Many InjectionPoints will return every opcode matching their criteria, specifying <em>ordinal</em> allows a particular opcode
|
||||
* to be identified from the returned list. The default value of -1 does not alter the behaviour and returns all matching opcodes. Specifying a
|
||||
* value of 0 or higher returns <em>only</em> the requested opcode (if one exists: for example specifying an ordinal of 4 when only 2 opcodes are
|
||||
* matched by the InjectionPoint is not going to work particularly well!)
|
||||
*/
|
||||
public int ordinal() default -1;
|
||||
|
||||
/**
|
||||
* Target opcode for FIELD and JUMP InjectionPoints. See the javadoc for the relevant injection point for more details.
|
||||
*/
|
||||
public int opcode() default -1;
|
||||
}
|
||||
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
/**
|
||||
/*
|
||||
* This file is part of Sponge, licensed under the MIT License (MIT).
|
||||
*
|
||||
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
|
||||
@@ -29,15 +29,33 @@ import java.lang.annotation.Retention;
|
||||
import java.lang.annotation.RetentionPolicy;
|
||||
import java.lang.annotation.Target;
|
||||
|
||||
/**
|
||||
* Specifies that this mixin method should inject a callback (or callback<b>s</b>) to itself in the target method(s) identified by {@link #method}.
|
||||
*/
|
||||
@Target({ElementType.METHOD})
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
public @interface Inject {
|
||||
|
||||
/**
|
||||
* String representation of a {@link org.spongepowered.asm.mixin.injection.struct.MemberInfo MemberInfo} which identifies the target method.
|
||||
*/
|
||||
public String method();
|
||||
|
||||
/**
|
||||
* Array of {@link At} annotations which describe the {@link InjectionPoint}s in the target method. Allows one or more callbacks to be injected in
|
||||
* the target method
|
||||
*/
|
||||
public At[] at();
|
||||
|
||||
/**
|
||||
* Setting an injected callback to <em>cancellable</em> allows the injected callback to inject optional RETURN opcodes into the target method, the
|
||||
* return behaviour can then be controlled from within the callback by interacting with the supplied
|
||||
* {@link org.spongepowered.asm.mixin.injection.callback.CallbackInfo} object.
|
||||
*/
|
||||
public boolean cancellable() default false;
|
||||
|
||||
/**
|
||||
* Set to true to allow local variables to be captured from the target method as well as method parameters.
|
||||
*/
|
||||
// public boolean captureLocals() default false;
|
||||
|
||||
public At[] at();
|
||||
}
|
||||
@@ -1,3 +1,27 @@
|
||||
/*
|
||||
* This file is part of Sponge, licensed under the MIT License (MIT).
|
||||
*
|
||||
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
|
||||
* Copyright (c) contributors
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
package org.spongepowered.asm.mixin.injection;
|
||||
|
||||
import java.lang.reflect.Constructor;
|
||||
@@ -24,385 +48,287 @@ 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.
|
||||
* <p>Base class for injection point discovery classes. Each subclass describes a strategy for locating code injection points within a method, with
|
||||
* the {@link #find} method populating a collection with insn nodes from the method which satisfy its strategy.</p>
|
||||
*
|
||||
* 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.
|
||||
* <p>This base class also contains composite strategy factory methods such as {@link #and} and {@link #or} which allow strategies to be combined
|
||||
* using intersection (and) or union (or) relationships to allow multiple strategies to be easily combined.</p>
|
||||
*
|
||||
* 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
|
||||
* <p>You are free to create your own injection point subclasses, but take note that it <b>is allowed</b> 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 {@link #find}
|
||||
* method, as each call to {@link #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 <b>stateless</b>.</p>
|
||||
*/
|
||||
public abstract class InjectionPoint
|
||||
{
|
||||
/**
|
||||
* Capture locals as well as args
|
||||
*/
|
||||
protected boolean captureLocals;
|
||||
|
||||
protected boolean logLocals;
|
||||
public abstract class InjectionPoint {
|
||||
|
||||
/**
|
||||
* 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<AbstractInsnNode> 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;
|
||||
// }
|
||||
/**
|
||||
* 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
|
||||
* the <b>add()</b> method
|
||||
* @return true if one or more injection points were found
|
||||
*/
|
||||
public abstract boolean find(String desc, InsnList insns, Collection<AbstractInsnNode> nodes);
|
||||
|
||||
@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<AbstractInsnNode> nodes) //, Event event)
|
||||
{
|
||||
boolean found = false;
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
ArrayList<AbstractInsnNode>[] allNodes = new ArrayList[this.components.length];
|
||||
|
||||
for (int i = 0; i < this.components.length; i++)
|
||||
{
|
||||
allNodes[i] = new ArrayList<AbstractInsnNode>();
|
||||
this.components[i].find(desc, insns, allNodes[i]); //, event);
|
||||
}
|
||||
|
||||
ArrayList<AbstractInsnNode> 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<AbstractInsnNode> nodes) //, Event event)
|
||||
{
|
||||
LinkedHashSet<AbstractInsnNode> allNodes = new LinkedHashSet<AbstractInsnNode>();
|
||||
|
||||
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<AbstractInsnNode> nodes) //, Event event)
|
||||
{
|
||||
List<AbstractInsnNode> list = (nodes instanceof List) ? (List<AbstractInsnNode>)nodes : new ArrayList<AbstractInsnNode>(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());
|
||||
/* (non-Javadoc)
|
||||
* @see java.lang.Object#toString()
|
||||
*/
|
||||
@Override
|
||||
public String toString() {
|
||||
return "InjectionPoint(" + this.getClass().getSimpleName() + ")";
|
||||
}
|
||||
|
||||
public static InjectionPoint parse(AnnotationNode node)
|
||||
{
|
||||
|
||||
/**
|
||||
* Composite injection point
|
||||
*/
|
||||
abstract static 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;
|
||||
}
|
||||
|
||||
/* (non-Javadoc)
|
||||
* @see org.spongepowered.asm.mixin.injection.InjectionPoint#toString()
|
||||
*/
|
||||
@Override
|
||||
public String toString() {
|
||||
return "CompositeInjectionPoint(" + this.getClass().getSimpleName() + ")[" + Joiner.on(',').join(this.components) + "]";
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Intersection of several injection points, returns common nodes that appear in all children
|
||||
*/
|
||||
static final class Intersection extends InjectionPoint.CompositeInjectionPoint {
|
||||
|
||||
public Intersection(InjectionPoint... points) {
|
||||
super(points);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean find(String desc, InsnList insns, Collection<AbstractInsnNode> nodes) {
|
||||
boolean found = false;
|
||||
|
||||
@SuppressWarnings("unchecked") ArrayList<AbstractInsnNode>[] allNodes = new ArrayList[this.components.length];
|
||||
|
||||
for (int i = 0; i < this.components.length; i++) {
|
||||
allNodes[i] = new ArrayList<AbstractInsnNode>();
|
||||
this.components[i].find(desc, insns, allNodes[i]);
|
||||
}
|
||||
|
||||
ArrayList<AbstractInsnNode> 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;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Union of several injection points, returns all insns returned from all injections
|
||||
*/
|
||||
static final class Union extends InjectionPoint.CompositeInjectionPoint {
|
||||
|
||||
public Union(InjectionPoint... points) {
|
||||
super(points);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean find(String desc, InsnList insns, Collection<AbstractInsnNode> nodes) {
|
||||
LinkedHashSet<AbstractInsnNode> allNodes = new LinkedHashSet<AbstractInsnNode>();
|
||||
|
||||
for (int i = 0; i < this.components.length; i++) {
|
||||
this.components[i].find(desc, insns, allNodes);
|
||||
}
|
||||
|
||||
nodes.addAll(allNodes);
|
||||
|
||||
return allNodes.size() > 0;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Shift injection point, takes an input injection point and shifts all returned nodes by a fixed amount
|
||||
*/
|
||||
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;
|
||||
}
|
||||
|
||||
/* (non-Javadoc)
|
||||
* @see org.spongepowered.asm.mixin.injection.InjectionPoint#toString()
|
||||
*/
|
||||
@Override
|
||||
public String toString() {
|
||||
return "InjectionPoint(" + this.getClass().getSimpleName() + ")[" + this.input + "]";
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean find(String desc, InsnList insns, Collection<AbstractInsnNode> nodes) {
|
||||
List<AbstractInsnNode> list = (nodes instanceof List) ? (List<AbstractInsnNode>) nodes : new ArrayList<AbstractInsnNode>(nodes);
|
||||
|
||||
this.input.find(desc, insns, nodes);
|
||||
|
||||
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 injection points to perform intersection
|
||||
*/
|
||||
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 injection points to perform union
|
||||
*/
|
||||
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 injection points to perform shift
|
||||
*/
|
||||
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 injection points to perform shift
|
||||
*/
|
||||
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 injection points to perform shift
|
||||
*/
|
||||
public static InjectionPoint shift(InjectionPoint point, int count) {
|
||||
return new InjectionPoint.Shift(point, count);
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse an InjectionPoint from the supplied {@link At} annotation
|
||||
*/
|
||||
public static InjectionPoint parse(At at) {
|
||||
return InjectionPoint.parse(at.value(), at.shift(), at.by(), Arrays.asList(at.args()), at.target(), at.ordinal(), at.opcode());
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse an InjectionPoint from the supplied {@link At} annotation supplied as an AnnotationNode instance
|
||||
*/
|
||||
public static InjectionPoint parse(AnnotationNode node) {
|
||||
String at = ASMHelper.<String>getAnnotationValue(node, "value");
|
||||
List<String> args = ASMHelper.<List<String>>getAnnotationValue(node, "args");
|
||||
String target = ASMHelper.<String>getAnnotationValue(node, "target", "");
|
||||
At.Shift shift = ASMHelper.<At.Shift>getAnnotationValue(node, "shift", At.Shift.NONE);
|
||||
int by = ASMHelper.<Integer>getAnnotationValue(node, "by", Integer.valueOf(0));
|
||||
int ordinal = ASMHelper.<Integer>getAnnotationValue(node, "ordinal", Integer.valueOf(-1));
|
||||
int opcode = ASMHelper.<Integer>getAnnotationValue(node, "opcode", Integer.valueOf(0));
|
||||
|
||||
if (args == null) args = ImmutableList.<String>of();
|
||||
|
||||
return InjectionPoint.parse(at, shift, args, target, ordinal, opcode);
|
||||
}
|
||||
|
||||
public static InjectionPoint parse(String at, At.Shift shift, List<String> 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;
|
||||
if (args == null) {
|
||||
args = ImmutableList.<String>of();
|
||||
}
|
||||
|
||||
return InjectionPoint.parse(at, shift, by, args, target, ordinal, opcode);
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse and instantiate an InjectionPoint from the supplied information. Returns null if an InjectionPoint could not be created.
|
||||
*/
|
||||
public static InjectionPoint parse(String at, At.Shift shift, int by, List<String> args, String target, int ordinal, int opcode) {
|
||||
InjectionPointData data = new InjectionPointData(args, target, ordinal, opcode);
|
||||
InjectionPoint point = null;
|
||||
|
||||
if (BeforeFieldAccess.CODE.equals(at)) {
|
||||
point = new BeforeFieldAccess(data);
|
||||
} else if (BeforeInvoke.CODE.equals(at)) {
|
||||
point = new BeforeInvoke(data);
|
||||
} else if (BeforeNew.CODE.equals(at)) {
|
||||
point = new BeforeNew(data);
|
||||
} else if (BeforeReturn.CODE.equals(at)) {
|
||||
point = new BeforeReturn(data);
|
||||
} else if (BeforeStringInvoke.CODE.equals(at)) {
|
||||
point = new BeforeStringInvoke(data);
|
||||
} else if (JumpInsnPoint.CODE.equals(at)) {
|
||||
point = new JumpInsnPoint(data);
|
||||
} else if (MethodHead.CODE.equals(at)) {
|
||||
point = 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);
|
||||
point = ctor.newInstance(data);
|
||||
} catch (Exception ex) {
|
||||
throw new InvalidInjectionException("The specified class " + at + " could not be instanced or is not a valid InjectionPoint", ex);
|
||||
}
|
||||
} else {
|
||||
throw new InvalidInjectionException(at + " is not a valid injection point specifier");
|
||||
}
|
||||
|
||||
if (point != null) {
|
||||
if (shift == At.Shift.BEFORE) {
|
||||
return InjectionPoint.before(point);
|
||||
} else if (shift == At.Shift.AFTER) {
|
||||
return InjectionPoint.after(point);
|
||||
} else if (shift == At.Shift.BY) {
|
||||
return InjectionPoint.shift(point, by);
|
||||
}
|
||||
}
|
||||
|
||||
return point;
|
||||
}
|
||||
}
|
||||
@@ -1,4 +1,4 @@
|
||||
/**
|
||||
/*
|
||||
* This file is part of Sponge, licensed under the MIT License (MIT).
|
||||
*
|
||||
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
|
||||
|
||||
@@ -1,135 +1,137 @@
|
||||
/**
|
||||
* This file contributed from LiteLoader. Pending refactor. DO NOT ALTER THIS FILE.
|
||||
/*
|
||||
* This file is part of Sponge, licensed under the MIT License (MIT).
|
||||
*
|
||||
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
|
||||
* Copyright (c) contributors
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
|
||||
package org.spongepowered.asm.mixin.injection.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 <S> Source object type. For non-static methods this will be the containing object instance.
|
||||
* CallbackInfo instances are passed to callbacks in order to provide information and handling opportunities to the callback to interact with the
|
||||
* callback itself. For example by allowing the callback to be "cancelled" and return from a method prematurely.
|
||||
*/
|
||||
public class CallbackInfo implements Cancellable
|
||||
{
|
||||
public class CallbackInfo implements Cancellable {
|
||||
|
||||
protected static final String STRING = "Ljava/lang/String;";
|
||||
protected static final String OBJECT = "Ljava/lang/Object;";
|
||||
|
||||
/**
|
||||
* Method name being injected into, this is useful if a single callback is injecting into multiple methods
|
||||
*/
|
||||
private final String name;
|
||||
|
||||
// private final S source;
|
||||
|
||||
|
||||
/**
|
||||
* True if this callback is cancellable
|
||||
*/
|
||||
private final boolean cancellable;
|
||||
|
||||
/**
|
||||
* True if this callback has been cancelled
|
||||
*/
|
||||
private boolean cancelled;
|
||||
|
||||
public CallbackInfo(String name, /*S source,*/ boolean cancellable)
|
||||
{
|
||||
/**
|
||||
* This ctor is always called by injected code
|
||||
*/
|
||||
public CallbackInfo(String name, boolean cancellable) {
|
||||
this.name = name;
|
||||
// this.source = source;
|
||||
this.cancellable = cancellable;
|
||||
}
|
||||
|
||||
// public S getSource()
|
||||
// {
|
||||
// return this.source;
|
||||
// }
|
||||
|
||||
public String getName()
|
||||
{
|
||||
|
||||
/**
|
||||
* Get the method name where this callback originated
|
||||
*/
|
||||
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()
|
||||
* @see java.lang.Object#toString()
|
||||
*/
|
||||
@Override
|
||||
public final boolean isCancellable()
|
||||
{
|
||||
public String toString() {
|
||||
return String.format("CallbackInfo[TYPE=%s,NAME=%s,CANCELLABLE=%s]", this.getClass().getSimpleName(), this.name, this.cancellable);
|
||||
}
|
||||
|
||||
/* (non-Javadoc)
|
||||
* @see org.spongepowered.asm.mixin.injection.callback.Cancellable#isCancellable()
|
||||
*/
|
||||
@Override
|
||||
public final boolean isCancellable() {
|
||||
return this.cancellable;
|
||||
}
|
||||
|
||||
/* (non-Javadoc)
|
||||
* @see com.mumfrey.liteloader.transformers.event.Cancellable#isCancelled()
|
||||
* @see org.spongepowered.asm.mixin.injection.callback.Cancellable#isCancelled()
|
||||
*/
|
||||
@Override
|
||||
public final boolean isCancelled()
|
||||
{
|
||||
public final boolean isCancelled() {
|
||||
return this.cancelled;
|
||||
}
|
||||
|
||||
|
||||
/* (non-Javadoc)
|
||||
* @see com.mumfrey.liteloader.transformers.event.Cancellable#cancel()
|
||||
* @see org.spongepowered.asm.mixin.injection.callback.Cancellable#cancel()
|
||||
*/
|
||||
@Override
|
||||
public void cancel() throws CancellationException
|
||||
{
|
||||
if (!this.cancellable)
|
||||
{
|
||||
public void cancel() throws CancellationException {
|
||||
if (!this.cancellable) {
|
||||
throw new CancellationException(String.format("The call %s is not cancellable.", this.name));
|
||||
}
|
||||
|
||||
|
||||
this.cancelled = true;
|
||||
}
|
||||
|
||||
// Methods below this point used by the CallbackInjector
|
||||
|
||||
protected static String getCallInfoClassName()
|
||||
{
|
||||
static String getCallInfoClassName() {
|
||||
return CallbackInfo.class.getName();
|
||||
}
|
||||
|
||||
/**
|
||||
* @param returnType
|
||||
*/
|
||||
protected static String getCallInfoClassName(Type returnType)
|
||||
{
|
||||
|
||||
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))
|
||||
{
|
||||
static String getConstructorDescriptor(Type returnType) {
|
||||
if (returnType.equals(Type.VOID_TYPE)) {
|
||||
return CallbackInfo.getConstructorDescriptor();
|
||||
}
|
||||
|
||||
if (returnType.getSort() == Type.OBJECT)
|
||||
{
|
||||
|
||||
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()
|
||||
{
|
||||
static String getConstructorDescriptor() {
|
||||
return String.format("(%sZ)V", CallbackInfo.STRING);
|
||||
}
|
||||
|
||||
public static String getIsCancelledMethodName()
|
||||
{
|
||||
static String getIsCancelledMethodName() {
|
||||
return "isCancelled";
|
||||
}
|
||||
|
||||
public static String getIsCancelledMethodSig()
|
||||
{
|
||||
static String getIsCancelledMethodSig() {
|
||||
return "()Z";
|
||||
}
|
||||
}
|
||||
+82
-80
@@ -1,137 +1,139 @@
|
||||
/**
|
||||
* This file contributed from LiteLoader. Pending refactor. DO NOT ALTER THIS FILE.
|
||||
/*
|
||||
* This file is part of Sponge, licensed under the MIT License (MIT).
|
||||
*
|
||||
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
|
||||
* Copyright (c) contributors
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
|
||||
package org.spongepowered.asm.mixin.injection.callback;
|
||||
|
||||
import org.objectweb.asm.Type;
|
||||
|
||||
//import com.mumfrey.liteloader.core.event.EventCancellationException;
|
||||
|
||||
/**
|
||||
* EventInfo for events which have a return type
|
||||
* For callbacks with a non-void return type, a CallbackInfoReturnable is passed to the callback instead to allow the callback to interact with the
|
||||
* method return value.
|
||||
*
|
||||
* @author Adam Mummery-Smith
|
||||
*
|
||||
* @param <S> Source object type. For non-static methods this will be the containing object instance.
|
||||
* @param <R> Return type
|
||||
*/
|
||||
public class CallbackInfoReturnable<R> extends CallbackInfo
|
||||
{
|
||||
public class CallbackInfoReturnable<R> extends CallbackInfo {
|
||||
|
||||
private R returnValue;
|
||||
|
||||
public CallbackInfoReturnable(String name, boolean cancellable)
|
||||
{
|
||||
|
||||
public CallbackInfoReturnable(String name, boolean cancellable) {
|
||||
super(name, cancellable);
|
||||
this.returnValue = null;
|
||||
}
|
||||
|
||||
public CallbackInfoReturnable(String name, boolean cancellable, R returnValue)
|
||||
{
|
||||
|
||||
public CallbackInfoReturnable(String name, boolean cancellable, R returnValue) {
|
||||
super(name, cancellable);
|
||||
this.returnValue = returnValue;
|
||||
}
|
||||
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
public CallbackInfoReturnable(String name, boolean cancellable, byte returnValue)
|
||||
{
|
||||
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);
|
||||
this.returnValue = (R) Byte.valueOf(returnValue);
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
public CallbackInfoReturnable(String name, boolean cancellable, double returnValue)
|
||||
{
|
||||
public CallbackInfoReturnable(String name, boolean cancellable, char returnValue) {
|
||||
super(name, cancellable);
|
||||
this.returnValue = (R)Double.valueOf(returnValue);
|
||||
this.returnValue = (R) Character.valueOf(returnValue);
|
||||
}
|
||||
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
public CallbackInfoReturnable(String name, boolean cancellable, float returnValue)
|
||||
{
|
||||
public CallbackInfoReturnable(String name, boolean cancellable, double returnValue) {
|
||||
super(name, cancellable);
|
||||
this.returnValue = (R)Float.valueOf(returnValue);
|
||||
this.returnValue = (R) Double.valueOf(returnValue);
|
||||
}
|
||||
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
public CallbackInfoReturnable(String name, boolean cancellable, int returnValue)
|
||||
{
|
||||
public CallbackInfoReturnable(String name, boolean cancellable, float returnValue) {
|
||||
super(name, cancellable);
|
||||
this.returnValue = (R)Integer.valueOf(returnValue);
|
||||
this.returnValue = (R) Float.valueOf(returnValue);
|
||||
}
|
||||
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
public CallbackInfoReturnable(String name, boolean cancellable, long returnValue)
|
||||
{
|
||||
public CallbackInfoReturnable(String name, boolean cancellable, int returnValue) {
|
||||
super(name, cancellable);
|
||||
this.returnValue = (R)Long.valueOf(returnValue);
|
||||
this.returnValue = (R) Integer.valueOf(returnValue);
|
||||
}
|
||||
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
public CallbackInfoReturnable(String name, boolean cancellable, short returnValue)
|
||||
{
|
||||
public CallbackInfoReturnable(String name, boolean cancellable, long returnValue) {
|
||||
super(name, cancellable);
|
||||
this.returnValue = (R)Short.valueOf(returnValue);
|
||||
this.returnValue = (R) Long.valueOf(returnValue);
|
||||
}
|
||||
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
public CallbackInfoReturnable(String name, boolean cancellable, boolean returnValue)
|
||||
{
|
||||
public CallbackInfoReturnable(String name, boolean cancellable, short returnValue) {
|
||||
super(name, cancellable);
|
||||
this.returnValue = (R)Boolean.valueOf(returnValue);
|
||||
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)
|
||||
* Sets a return value for this callback and cancels the callback (required in order to return the new value)
|
||||
*
|
||||
* @param returnValue
|
||||
*/
|
||||
public void setReturnValue(R returnValue) throws CancellationException
|
||||
{
|
||||
public void setReturnValue(R returnValue) throws CancellationException {
|
||||
super.cancel();
|
||||
|
||||
|
||||
this.returnValue = returnValue;
|
||||
}
|
||||
|
||||
public R getReturnValue()
|
||||
{
|
||||
}
|
||||
|
||||
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)
|
||||
{
|
||||
// All of the accessors below are to avoid having to generate unboxing conversions in bytecode
|
||||
// CHECKSTYLE:OFF
|
||||
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; }
|
||||
// CHECKSTYLE:ON
|
||||
|
||||
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)
|
||||
{
|
||||
static String getReturnDescriptor(Type returnType) {
|
||||
if (returnType.getSort() == Type.OBJECT) {
|
||||
return String.format("()%s", CallbackInfo.OBJECT);
|
||||
}
|
||||
|
||||
|
||||
return String.format("()%s", returnType.getDescriptor());
|
||||
}
|
||||
}
|
||||
+225
-155
@@ -1,7 +1,27 @@
|
||||
/**
|
||||
* This file contributed from LiteLoader. Pending refactor. DO NOT ALTER THIS FILE.
|
||||
/*
|
||||
* This file is part of Sponge, licensed under the MIT License (MIT).
|
||||
*
|
||||
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
|
||||
* Copyright (c) contributors
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
|
||||
package org.spongepowered.asm.mixin.injection.callback;
|
||||
|
||||
import java.util.ArrayList;
|
||||
@@ -13,111 +33,152 @@ 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.mixin.injection.struct.InjectionInfo;
|
||||
import org.spongepowered.asm.util.ASMHelper;
|
||||
import org.spongepowered.asm.util.ByteCodeUtilities;
|
||||
|
||||
import org.spongepowered.asm.util.Locals;
|
||||
|
||||
/**
|
||||
* This class is responsible for generating the bytecode for injected callbacks
|
||||
*/
|
||||
public class CallbackInjector {
|
||||
|
||||
|
||||
private static final String CTOR = "<init>";
|
||||
|
||||
class Target
|
||||
{
|
||||
/**
|
||||
* Information about the current injection target, mainly just convenience rather than passing a bunch of values around
|
||||
*/
|
||||
class Target {
|
||||
|
||||
/**
|
||||
* Target method
|
||||
*/
|
||||
final MethodNode method;
|
||||
|
||||
/**
|
||||
* Method arguments
|
||||
*/
|
||||
final Type[] arguments;
|
||||
|
||||
/**
|
||||
* Return type computed from the method descriptor
|
||||
*/
|
||||
final Type returnType;
|
||||
|
||||
/**
|
||||
* Method's (original) MAXS
|
||||
*/
|
||||
// CHECKSTYLE:OFF
|
||||
final int MAXS;
|
||||
|
||||
// CHECKSTYLE:ON
|
||||
|
||||
/**
|
||||
* Callback method descriptor based on this target
|
||||
*/
|
||||
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);
|
||||
/**
|
||||
* Callback info class
|
||||
*/
|
||||
final String callbackInfoClass;
|
||||
|
||||
/**
|
||||
* Make a new Target for the supplied method
|
||||
*/
|
||||
Target(MethodNode method) {
|
||||
this.method = method;
|
||||
this.arguments = Type.getArgumentTypes(method.desc);
|
||||
|
||||
this.returnType = Type.getReturnType(method.desc);
|
||||
this.MAXS = method.maxStack;
|
||||
this.callbackInfoClass = CallbackInfo.getCallInfoClassName(this.returnType);
|
||||
this.callbackDescriptor = String.format("(%sL%s;)V", method.desc.substring(1, method.desc.indexOf(')')), this.callbackInfoClass);
|
||||
}
|
||||
|
||||
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();
|
||||
/**
|
||||
* Get the callback descriptor
|
||||
*/
|
||||
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";
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* True if the callback method is static
|
||||
*/
|
||||
private final boolean isStatic;
|
||||
private final ClassNode classNode;
|
||||
private final MethodNode methodNode;
|
||||
private final boolean cancellable;
|
||||
private final boolean captureLocals;
|
||||
|
||||
public CallbackInjector(InjectionInfo info)
|
||||
{
|
||||
/**
|
||||
* Class node
|
||||
*/
|
||||
private final ClassNode classNode;
|
||||
|
||||
/**
|
||||
* Callback method
|
||||
*/
|
||||
private final MethodNode methodNode;
|
||||
|
||||
/**
|
||||
* True if cancellable
|
||||
*/
|
||||
private final boolean cancellable;
|
||||
|
||||
/**
|
||||
* True if capturing locals
|
||||
*/
|
||||
private final boolean captureLocals;
|
||||
|
||||
/**
|
||||
* Make a new CallbackInjector for the supplied InjectionInfo
|
||||
*/
|
||||
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;
|
||||
|
||||
/**
|
||||
* Make a new CallbackInjector with the supplied args
|
||||
*/
|
||||
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);
|
||||
this.isStatic = ASMHelper.methodIsStatic(methodNode);
|
||||
}
|
||||
|
||||
public void injectInto(MethodNode into, List<InjectionPoint> injectionPoints)
|
||||
{
|
||||
|
||||
/**
|
||||
* Inject into the specified method at the specified injection points
|
||||
*/
|
||||
public void injectInto(MethodNode into, List<InjectionPoint> injectionPoints) {
|
||||
this.sanityCheck(into, injectionPoints);
|
||||
|
||||
for (AbstractInsnNode targetNode : this.findTargetNodes(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)
|
||||
{
|
||||
|
||||
if (this.captureLocals) {
|
||||
LocalVariableNode[] locals = Locals.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)
|
||||
{
|
||||
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);
|
||||
@@ -127,121 +188,135 @@ public class CallbackInjector {
|
||||
|
||||
private Set<AbstractInsnNode> findTargetNodes(MethodNode into, List<InjectionPoint> injectionPoints) {
|
||||
Set<AbstractInsnNode> targetNodes = new HashSet<AbstractInsnNode>();
|
||||
|
||||
|
||||
// Defensive objects, so that injectionPoint instances can't modify our working copies
|
||||
ReadOnlyInsnList insns = new ReadOnlyInsnList(into.instructions);
|
||||
Collection<AbstractInsnNode> nodes = new ArrayList<AbstractInsnNode>(32);
|
||||
|
||||
for (InjectionPoint injectionPoint : injectionPoints)
|
||||
{
|
||||
for (InjectionPoint injectionPoint : injectionPoints) {
|
||||
nodes.clear();
|
||||
if (injectionPoint.find(into.desc, insns, nodes))
|
||||
{
|
||||
if (injectionPoint.find(into.desc, insns, nodes)) {
|
||||
targetNodes.addAll(nodes);
|
||||
}
|
||||
}
|
||||
|
||||
insns.dispose();
|
||||
return targetNodes;
|
||||
}
|
||||
|
||||
private void sanityCheck(MethodNode target, List<InjectionPoint> injectionPoints)
|
||||
{
|
||||
if (ASMHelper.methodIsStatic(target) != this.isStatic)
|
||||
{
|
||||
private void sanityCheck(MethodNode target, List<InjectionPoint> 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");
|
||||
|
||||
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);
|
||||
|
||||
/**
|
||||
* Generate the actual bytecode
|
||||
*/
|
||||
private void inject(Target target, final AbstractInsnNode targetNode, final Type[] locals) {
|
||||
// Calculate the initial frame size based on the target method's arguments
|
||||
int initialFrameSize = ASMHelper.getFirstNonArgLocalIndex(target.arguments, !this.isStatic);
|
||||
|
||||
// Work out whether we have enough info to capture locals in this scenario
|
||||
boolean doCaptureLocals = this.captureLocals && locals != null && locals.length > initialFrameSize;
|
||||
String callbackDescriptor = target.getCallbackDescriptor(doCaptureLocals, locals, arguments, initialFrameSize);
|
||||
if (!callbackDescriptor.equals(this.methodNode.desc))
|
||||
{
|
||||
|
||||
// Determine the descriptor for the callback based on the target method and current context
|
||||
String callbackDescriptor = target.getCallbackDescriptor(doCaptureLocals, locals, target.arguments, initialFrameSize);
|
||||
|
||||
// If it doesn't match, then cry
|
||||
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
|
||||
|
||||
// These two variables keep track of the (additional) stack size required for the two actions we're going to be injecting insns to perform,
|
||||
// namely calling the CallbackInfo ctor, and then invoking the callback itself. When we get to the end of this injection we will then set
|
||||
// the MAXS value on the target method to its original value plus the larger of the two values.
|
||||
int ctorMAXS = 0;
|
||||
int invokeMAXS = target.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, those being the current return
|
||||
// value for value-return scenarios (we store the topmost stack entry and then push it into the ctor of the CallbackInfo) and also the
|
||||
// CallbackInfo reference itself (we use the same local var for these two purposes because they don't exist at the same time).
|
||||
int marshallVar = target.method.maxLocals++;
|
||||
|
||||
|
||||
// Insns we will inject
|
||||
InsnList insns = new InsnList();
|
||||
|
||||
|
||||
// Assume (for now) that we won't push the return value into the CallbackInfo ctor
|
||||
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)
|
||||
{
|
||||
|
||||
// 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));
|
||||
}
|
||||
|
||||
|
||||
// CHECKSTYLE:OFF
|
||||
// Instance the EventInfo for this event
|
||||
insns.add(new TypeInsnNode(Opcodes.NEW, target.callInfoClass)); ctorMAXS++;
|
||||
insns.add(new TypeInsnNode(Opcodes.NEW, target.callbackInfoClass)); ctorMAXS++;
|
||||
insns.add(new InsnNode(Opcodes.DUP)); ctorMAXS++; invokeMAXS++;
|
||||
// CHECKSTYLE:ON
|
||||
ctorMAXS += this.invokeCallbackInfoCtor(target, insns, this.cancellable, pushReturnValue, marshallVar);
|
||||
insns.add(new VarInsnNode(Opcodes.ASTORE, marshallVar));
|
||||
|
||||
if (!this.isStatic)
|
||||
{
|
||||
|
||||
// Push "this" onto the stack if the callback is not static
|
||||
if (!this.isStatic) {
|
||||
insns.add(new VarInsnNode(Opcodes.ALOAD, 0));
|
||||
}
|
||||
|
||||
// Push the target method's parameters onto the stack
|
||||
ASMHelper.loadArgs(target.arguments, insns, this.isStatic ? 0 : 1);
|
||||
|
||||
// Call the event handler method in the proxy
|
||||
ByteCodeUtilities.loadArgs(arguments, insns, this.isStatic ? 0 : 1);
|
||||
// Push the callback info onto the stack
|
||||
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)
|
||||
{
|
||||
// (Maybe) push the locals onto the stack
|
||||
if (doCaptureLocals) {
|
||||
Locals.loadLocals(locals, insns, initialFrameSize);
|
||||
}
|
||||
|
||||
// Call the callback!
|
||||
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)
|
||||
{
|
||||
protected int invokeCallbackInfoCtor(Target target, InsnList insns, boolean cancellable, boolean pushReturnValue, int marshallVar) {
|
||||
int ctorMAXS = 0;
|
||||
|
||||
|
||||
// CHECKSTYLE:OFF
|
||||
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)
|
||||
{
|
||||
// CHECKSTYLE:ON
|
||||
|
||||
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));
|
||||
insns.add(new MethodInsnNode(Opcodes.INVOKESPECIAL,
|
||||
target.callbackInfoClass, CallbackInjector.CTOR, CallbackInfo.getConstructorDescriptor(target.returnType), false));
|
||||
} else {
|
||||
insns.add(new MethodInsnNode(Opcodes.INVOKESPECIAL,
|
||||
target.callbackInfoClass, CallbackInjector.CTOR, CallbackInfo.getConstructorDescriptor(), false));
|
||||
}
|
||||
else
|
||||
{
|
||||
insns.add(new MethodInsnNode(Opcodes.INVOKESPECIAL, target.callInfoClass, CallbackInjector.CTOR, CallbackInfo.getConstructorDescriptor(), false));
|
||||
}
|
||||
|
||||
|
||||
return ctorMAXS;
|
||||
}
|
||||
|
||||
@@ -252,17 +327,17 @@ public class CallbackInjector {
|
||||
* @param targetNode
|
||||
* @param marshallVar
|
||||
*/
|
||||
protected void injectCancellationCode(Target target, final InsnList insns, final AbstractInsnNode targetNode, int 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));
|
||||
insns.add(new MethodInsnNode(Opcodes.INVOKEVIRTUAL, target.callbackInfoClass, 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);
|
||||
}
|
||||
|
||||
@@ -273,22 +348,17 @@ public class CallbackInjector {
|
||||
* @param targetNode
|
||||
* @param marshallVar
|
||||
*/
|
||||
protected void injectReturnCode(Target target, final InsnList insns, final AbstractInsnNode targetNode, int marshallVar)
|
||||
{
|
||||
if (target.returnType.equals(Type.VOID_TYPE))
|
||||
{
|
||||
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
|
||||
{
|
||||
} 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 MethodInsnNode(Opcodes.INVOKEVIRTUAL, target.callbackInfoClass, 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)));
|
||||
|
||||
@@ -1,17 +1,34 @@
|
||||
/**
|
||||
* This file contributed from LiteLoader. Pending refactor. DO NOT ALTER THIS FILE.
|
||||
/*
|
||||
* This file is part of Sponge, licensed under the MIT License (MIT).
|
||||
*
|
||||
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
|
||||
* Copyright (c) contributors
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
|
||||
package org.spongepowered.asm.mixin.injection.callback;
|
||||
|
||||
|
||||
/**
|
||||
* Interface for (potentially) cancellable things :)
|
||||
*
|
||||
* @author Adam Mummery-Smith
|
||||
* Interface for things which can be cancelled
|
||||
*/
|
||||
public interface Cancellable
|
||||
{
|
||||
public interface Cancellable {
|
||||
/**
|
||||
* Get whether this is actually cancellable
|
||||
*/
|
||||
@@ -23,10 +40,11 @@ public interface Cancellable
|
||||
public abstract boolean isCancelled();
|
||||
|
||||
/**
|
||||
* If the object is cancellable, cancels the object, implementors may throw
|
||||
* an EventCancellationException if the object is not actually cancellable.
|
||||
* 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
|
||||
* @throws CancellationException (optional) may be thrown if the object is not actually cancellable. Contractually, this object may not throw the
|
||||
* exception if isCancellable() returns true.
|
||||
*/
|
||||
public abstract void cancel() throws CancellationException;
|
||||
}
|
||||
+32
-16
@@ -1,29 +1,45 @@
|
||||
/**
|
||||
* This file contributed from LiteLoader. Pending refactor. DO NOT ALTER THIS FILE.
|
||||
/*
|
||||
* This file is part of Sponge, licensed under the MIT License (MIT).
|
||||
*
|
||||
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
|
||||
* Copyright (c) contributors
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
|
||||
package org.spongepowered.asm.mixin.injection.callback;
|
||||
|
||||
public class CancellationException extends RuntimeException
|
||||
{
|
||||
public class CancellationException extends RuntimeException {
|
||||
|
||||
private static final long serialVersionUID = 1L;
|
||||
|
||||
public CancellationException()
|
||||
{
|
||||
public CancellationException() {
|
||||
}
|
||||
|
||||
public CancellationException(String message)
|
||||
{
|
||||
|
||||
public CancellationException(String message) {
|
||||
super(message);
|
||||
}
|
||||
|
||||
public CancellationException(Throwable cause)
|
||||
{
|
||||
|
||||
public CancellationException(Throwable cause) {
|
||||
super(cause);
|
||||
}
|
||||
|
||||
public CancellationException(String message, Throwable cause)
|
||||
{
|
||||
|
||||
public CancellationException(String message, Throwable cause) {
|
||||
super(message, cause);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,247 @@
|
||||
/*
|
||||
* This file is part of Sponge, licensed under the MIT License (MIT).
|
||||
*
|
||||
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
|
||||
* Copyright (c) contributors
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
package org.spongepowered.asm.mixin.injection.callback;
|
||||
|
||||
import java.util.ListIterator;
|
||||
|
||||
import org.objectweb.asm.tree.AbstractInsnNode;
|
||||
import org.objectweb.asm.tree.InsnList;
|
||||
|
||||
/**
|
||||
* Read-only wrapper for InsnList, defensively passed to InjectionPoint instances so that custom InjectionPoint implementations cannot modify the insn
|
||||
* list whilst inspecting it.
|
||||
*/
|
||||
public class ReadOnlyInsnList extends InsnList {
|
||||
|
||||
private InsnList insnList;
|
||||
|
||||
public ReadOnlyInsnList(InsnList insns) {
|
||||
this.insnList = insns;
|
||||
}
|
||||
|
||||
void dispose() {
|
||||
this.insnList = null;
|
||||
}
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
*
|
||||
* @see org.objectweb.asm.tree.InsnList#set(org.objectweb.asm.tree.AbstractInsnNode, org.objectweb.asm.tree.AbstractInsnNode)
|
||||
*/
|
||||
@Override
|
||||
public void set(AbstractInsnNode location, AbstractInsnNode insn) {
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
*
|
||||
* @see org.objectweb.asm.tree.InsnList#add(org.objectweb.asm.tree.AbstractInsnNode)
|
||||
*/
|
||||
@Override
|
||||
public void add(AbstractInsnNode insn) {
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
*
|
||||
* @see org.objectweb.asm.tree.InsnList#add(org.objectweb.asm.tree.InsnList)
|
||||
*/
|
||||
@Override
|
||||
public void add(InsnList insns) {
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
*
|
||||
* @see org.objectweb.asm.tree.InsnList#insert(org.objectweb.asm.tree.AbstractInsnNode)
|
||||
*/
|
||||
@Override
|
||||
public void insert(AbstractInsnNode insn) {
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
*
|
||||
* @see org.objectweb.asm.tree.InsnList#insert(org.objectweb.asm.tree.InsnList)
|
||||
*/
|
||||
@Override
|
||||
public void insert(InsnList insns) {
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
*
|
||||
* @see org.objectweb.asm.tree.InsnList#insert(org.objectweb.asm.tree.AbstractInsnNode, org.objectweb.asm.tree.AbstractInsnNode)
|
||||
*/
|
||||
@Override
|
||||
public void insert(AbstractInsnNode location, AbstractInsnNode insn) {
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
*
|
||||
* @see org.objectweb.asm.tree.InsnList#insert(org.objectweb.asm.tree.AbstractInsnNode, org.objectweb.asm.tree.InsnList)
|
||||
*/
|
||||
@Override
|
||||
public void insert(AbstractInsnNode location, InsnList insns) {
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
*
|
||||
* @see org.objectweb.asm.tree.InsnList#insertBefore(org.objectweb.asm.tree.AbstractInsnNode, org.objectweb.asm.tree.AbstractInsnNode)
|
||||
*/
|
||||
@Override
|
||||
public void insertBefore(AbstractInsnNode location, AbstractInsnNode insn) {
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
*
|
||||
* @see org.objectweb.asm.tree.InsnList#insertBefore(org.objectweb.asm.tree.AbstractInsnNode, org.objectweb.asm.tree.InsnList)
|
||||
*/
|
||||
@Override
|
||||
public void insertBefore(AbstractInsnNode location, InsnList insns) {
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
*
|
||||
* @see org.objectweb.asm.tree.InsnList#remove(org.objectweb.asm.tree.AbstractInsnNode)
|
||||
*/
|
||||
@Override
|
||||
public void remove(AbstractInsnNode insn) {
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
*
|
||||
* @see org.objectweb.asm.tree.InsnList#toArray()
|
||||
*/
|
||||
@Override
|
||||
public AbstractInsnNode[] toArray() {
|
||||
return this.insnList.toArray();
|
||||
}
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
*
|
||||
* @see org.objectweb.asm.tree.InsnList#size()
|
||||
*/
|
||||
@Override
|
||||
public int size() {
|
||||
return this.insnList.size();
|
||||
}
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
*
|
||||
* @see org.objectweb.asm.tree.InsnList#getFirst()
|
||||
*/
|
||||
@Override
|
||||
public AbstractInsnNode getFirst() {
|
||||
return this.insnList.getFirst();
|
||||
}
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
*
|
||||
* @see org.objectweb.asm.tree.InsnList#getLast()
|
||||
*/
|
||||
@Override
|
||||
public AbstractInsnNode getLast() {
|
||||
return this.insnList.getLast();
|
||||
}
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
*
|
||||
* @see org.objectweb.asm.tree.InsnList#get(int)
|
||||
*/
|
||||
@Override
|
||||
public AbstractInsnNode get(int index) {
|
||||
return this.insnList.get(index);
|
||||
}
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
*
|
||||
* @see org.objectweb.asm.tree.InsnList#contains(org.objectweb.asm.tree.AbstractInsnNode)
|
||||
*/
|
||||
@Override
|
||||
public boolean contains(AbstractInsnNode insn) {
|
||||
return this.insnList.contains(insn);
|
||||
}
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
*
|
||||
* @see org.objectweb.asm.tree.InsnList#indexOf(org.objectweb.asm.tree.AbstractInsnNode)
|
||||
*/
|
||||
@Override
|
||||
public int indexOf(AbstractInsnNode insn) {
|
||||
return this.insnList.indexOf(insn);
|
||||
}
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
*
|
||||
* @see org.objectweb.asm.tree.InsnList#iterator()
|
||||
*/
|
||||
@Override
|
||||
public ListIterator<AbstractInsnNode> iterator() {
|
||||
return this.insnList.iterator();
|
||||
}
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
*
|
||||
* @see org.objectweb.asm.tree.InsnList#iterator(int)
|
||||
*/
|
||||
@Override
|
||||
public ListIterator<AbstractInsnNode> iterator(int index) {
|
||||
return this.insnList.iterator(index);
|
||||
}
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
*
|
||||
* @see org.objectweb.asm.tree.InsnList#resetLabels()
|
||||
*/
|
||||
@Override
|
||||
public void resetLabels() {
|
||||
this.insnList.resetLabels();
|
||||
}
|
||||
}
|
||||
@@ -1,36 +1,69 @@
|
||||
/**
|
||||
* This file contributed from LiteLoader. Pending refactor. DO NOT ALTER THIS FILE.
|
||||
/*
|
||||
* This file is part of Sponge, licensed under the MIT License (MIT).
|
||||
*
|
||||
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
|
||||
* Copyright (c) contributors
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
|
||||
package org.spongepowered.asm.mixin.injection.points;
|
||||
|
||||
import org.objectweb.asm.Opcodes;
|
||||
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.
|
||||
* <p>This injection point searches for GETFIELD and PUTFIELD (and static equivalent) opcodes matching its arguments and returns a list of insns
|
||||
* immediately prior to matching instructions. It accepts the following parameters from {@link org.spongepowered.asm.mixin.injection.At At}:<p>
|
||||
*
|
||||
* @author Adam Mummery-Smith
|
||||
* <dl>
|
||||
* <dt>target</dt>
|
||||
* <dd>A {@link org.spongepowered.asm.mixin.injection.struct.MemberInfo MemberInfo} which identifies the target field</dd>
|
||||
* <dt>opcode</dt>
|
||||
* <dd>The {@link Opcodes opcode} of the field access, must be one of GETSTATIC, PUTSTATIC, GETFIELD or PUTFIELD.</dd>
|
||||
* <dt>ordinal</dt>
|
||||
* <dd>The ordinal position of the field access to match. For example if the field is referenced 3 times and you want to match the 3rd then you can
|
||||
* specify an <em>ordinal</em> of <b>2</b> (ordinals are zero-indexed). The default value is <b>-1</b> which supresses ordinal matching</dd>
|
||||
* </dl>
|
||||
*
|
||||
* <p>Example:<blockquote><pre>
|
||||
* @At(value = "FIELD", target="field_5678_z:I", opcode = Opcodes.GETFIELD)</pre>
|
||||
* </blockquote></p>
|
||||
*
|
||||
* <p>Note that like all standard injection points, this class matches the insn itself, putting the injection point immediately <em>before</em> the
|
||||
* access in question. Use the {@link org.spongepowered.asm.mixin.injection.At#shift shift} specifier to adjust the matched opcode as necessary.</p>
|
||||
*/
|
||||
public class BeforeFieldAccess extends BeforeInvoke
|
||||
{
|
||||
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;
|
||||
}
|
||||
|
||||
private final int opcode;
|
||||
|
||||
public BeforeFieldAccess(InjectionPointData data) {
|
||||
super(data);
|
||||
this.opcode = data.getOpcode(-1, Opcodes.GETFIELD, Opcodes.PUTFIELD, Opcodes.GETSTATIC, Opcodes.PUTSTATIC, -1);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected boolean matchesInsn(AbstractInsnNode insn) {
|
||||
return insn instanceof FieldInsnNode && (((FieldInsnNode) insn).getOpcode() == this.opcode || this.opcode == -1);
|
||||
}
|
||||
}
|
||||
@@ -1,199 +1,159 @@
|
||||
/**
|
||||
* This file contributed from LiteLoader. Pending refactor. DO NOT ALTER THIS FILE.
|
||||
/*
|
||||
* This file is part of Sponge, licensed under the MIT License (MIT).
|
||||
*
|
||||
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
|
||||
* Copyright (c) contributors
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
|
||||
package org.spongepowered.asm.mixin.injection.points;
|
||||
|
||||
import java.util.Collection;
|
||||
import java.util.ListIterator;
|
||||
|
||||
import org.apache.logging.log4j.LogManager;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
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.
|
||||
* <p>This injection point searches for INVOKEVIRTUAL, INVOKESTATIC and INVOKESPECIAL opcodes matching its arguments and returns a list of insns
|
||||
* immediately prior to matching instructions. It accepts the following parameters from {@link org.spongepowered.asm.mixin.injection.At At}:<p>
|
||||
*
|
||||
* @author Adam Mummery-Smith
|
||||
* <dl>
|
||||
* <dt>target</dt>
|
||||
* <dd>A {@link org.spongepowered.asm.mixin.injection.struct.MemberInfo MemberInfo} which identifies the target method</dd>
|
||||
* <dt>ordinal</dt>
|
||||
* <dd>The ordinal position of the method invocation to match. For example if the method is invoked 3 times and you want to match the 3rd then you
|
||||
* can specify an <em>ordinal</em> of <b>2</b> (ordinals are zero-indexed). The default value is <b>-1</b> which supresses ordinal matching</dd>
|
||||
* </dl>
|
||||
*
|
||||
* <p>Example:<blockquote><pre>
|
||||
* @At(value = "INVOKE", target="func_1234_a(III)V")</pre>
|
||||
* </blockquote></p>
|
||||
*
|
||||
* <p>Note that like all standard injection points, this class matches the insn itself, putting the injection point immediately <em>before</em> the
|
||||
* access in question. Use the {@link org.spongepowered.asm.mixin.injection.At#shift shift} specifier to adjust the matched opcode as necessary.</p>
|
||||
*/
|
||||
public class BeforeInvoke extends InjectionPoint
|
||||
{
|
||||
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();
|
||||
protected final MemberInfo target;
|
||||
|
||||
// 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<AbstractInsnNode> nodes) //, Event event)
|
||||
{
|
||||
int ordinal = 0;
|
||||
boolean found = false;
|
||||
/**
|
||||
* 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 <em>all</em> invokations of the method.
|
||||
*/
|
||||
protected final int ordinal;
|
||||
|
||||
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<AbstractInsnNode> 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++;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* True to turn on strategy debugging to the console
|
||||
*/
|
||||
protected boolean logging = false;
|
||||
|
||||
this.inspectInsn(desc, insns, insn);
|
||||
}
|
||||
|
||||
// if (this.logging) LiteLoaderLogger.debug(ClassTransformer.HORIZONTAL_RULE);
|
||||
|
||||
return found;
|
||||
}
|
||||
protected final Logger logger = LogManager.getLogger("mixin");
|
||||
|
||||
protected boolean matchesInsn(AbstractInsnNode insn)
|
||||
{
|
||||
return insn instanceof MethodInsnNode;
|
||||
}
|
||||
protected final String className;
|
||||
|
||||
protected void inspectInsn(String desc, InsnList insns, AbstractInsnNode insn)
|
||||
{
|
||||
// stub for subclasses
|
||||
}
|
||||
public BeforeInvoke(InjectionPointData data) {
|
||||
this.target = data.getTarget();
|
||||
this.ordinal = data.getOrdinal();
|
||||
this.logging = data.get("log", false);
|
||||
this.className = this.getClass().getSimpleName();
|
||||
}
|
||||
|
||||
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;
|
||||
// }
|
||||
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<AbstractInsnNode> nodes) {
|
||||
int ordinal = 0;
|
||||
boolean found = false;
|
||||
|
||||
if (this.logging) {
|
||||
this.logger.info("{} is searching for an injection point in method with descriptor {}", this.className, desc);
|
||||
}
|
||||
|
||||
ListIterator<AbstractInsnNode> iter = insns.iterator();
|
||||
while (iter.hasNext()) {
|
||||
AbstractInsnNode insn = iter.next();
|
||||
|
||||
if (this.matchesInsn(insn)) {
|
||||
MemberInfo nodeInfo = new MemberInfo(insn);
|
||||
|
||||
if (this.logging) {
|
||||
this.logger.info("{} is considering insn {}", this.className, nodeInfo);
|
||||
}
|
||||
|
||||
if (this.target.matches(nodeInfo.owner, nodeInfo.name, nodeInfo.desc)) {
|
||||
if (this.logging) {
|
||||
this.logger.info("{} > found a matching insn, checking preconditions...", this.className);
|
||||
}
|
||||
|
||||
if (this.matchesInsn(nodeInfo, ordinal)) {
|
||||
if (this.logging) {
|
||||
this.logger.info("{} > > > found a matching insn at ordinal {}", this.className, ordinal);
|
||||
}
|
||||
|
||||
nodes.add(insn);
|
||||
found = true;
|
||||
|
||||
if (this.ordinal == ordinal) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
ordinal++;
|
||||
}
|
||||
}
|
||||
|
||||
this.inspectInsn(desc, insns, insn);
|
||||
}
|
||||
|
||||
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(MemberInfo nodeInfo, int ordinal) {
|
||||
if (this.logging) {
|
||||
this.logger.info("{} > > comparing target ordinal {} with current ordinal {}", this.className, this.ordinal, ordinal);
|
||||
}
|
||||
return this.ordinal == -1 || this.ordinal == ordinal;
|
||||
}
|
||||
}
|
||||
@@ -1,7 +1,27 @@
|
||||
/**
|
||||
* This file contributed from LiteLoader. Pending refactor. DO NOT ALTER THIS FILE.
|
||||
/*
|
||||
* This file is part of Sponge, licensed under the MIT License (MIT).
|
||||
*
|
||||
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
|
||||
* Copyright (c) contributors
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
|
||||
package org.spongepowered.asm.mixin.injection.points;
|
||||
|
||||
import java.util.Collection;
|
||||
@@ -14,63 +34,68 @@ 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;
|
||||
/**
|
||||
* <p>This injection point searches for NEW opcodes matching its arguments and returns a list of insns immediately prior to matching instructions. It
|
||||
* accepts the following parameters from {@link org.spongepowered.asm.mixin.injection.At At}:<p>
|
||||
*
|
||||
* <dl>
|
||||
* <dt><em>named argument</em> class</dt>
|
||||
* <dd>The value of the NEW node to look for, the fully-qualified class name</dd>
|
||||
* <dt>ordinal</dt>
|
||||
* <dd>The ordinal position of the NEW opcode to match. For example if the NEW opcode appears 3 times in the method and you want to match the 3rd
|
||||
* then you can specify an <em>ordinal</em> of <b>2</b> (ordinals are zero-indexed). The default value is <b>-1</b> which supresses ordinal
|
||||
* matching</dd>
|
||||
* </dl>
|
||||
*
|
||||
* <p>Example:<blockquote><pre>
|
||||
* @At(value = "NEW", args = { "class=java/lang/String" })</pre>
|
||||
* </blockquote></p>
|
||||
*
|
||||
* <p>Note that like all standard injection points, this class matches the insn itself, putting the injection point immediately <em>before</em> the
|
||||
* access in question. Use the {@link org.spongepowered.asm.mixin.injection.At#shift shift} specifier to adjust the matched opcode as necessary.</p>
|
||||
*/
|
||||
public class BeforeNew extends InjectionPoint {
|
||||
|
||||
public class BeforeNew extends InjectionPoint
|
||||
{
|
||||
public static final String CODE = "NEW";
|
||||
|
||||
/**
|
||||
* Class name we're looking for
|
||||
*/
|
||||
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<AbstractInsnNode> nodes) //, Event event)
|
||||
{
|
||||
boolean found = false;
|
||||
int ordinal = 0;
|
||||
|
||||
ListIterator<AbstractInsnNode> 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;
|
||||
}
|
||||
/**
|
||||
* Ordinal value
|
||||
*/
|
||||
private final int ordinal;
|
||||
|
||||
private boolean matchesOwner(TypeInsnNode insn)
|
||||
{
|
||||
// for (String className : this.classNames)
|
||||
// {
|
||||
// if (className.equals(insn.desc)) return true;
|
||||
// }
|
||||
|
||||
return this.className.equals(insn.desc);
|
||||
}
|
||||
public BeforeNew(InjectionPointData data) {
|
||||
this.ordinal = data.getOrdinal();
|
||||
this.className = data.get("class", null).replace('.', '/');
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean find(String desc, InsnList insns, Collection<AbstractInsnNode> nodes) {
|
||||
boolean found = false;
|
||||
int ordinal = 0;
|
||||
|
||||
ListIterator<AbstractInsnNode> 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) {
|
||||
return this.className == null || this.className.equals(insn.desc);
|
||||
}
|
||||
}
|
||||
@@ -1,7 +1,27 @@
|
||||
/**
|
||||
* This file contributed from LiteLoader. Pending refactor. DO NOT ALTER THIS FILE.
|
||||
/*
|
||||
* This file is part of Sponge, licensed under the MIT License (MIT).
|
||||
*
|
||||
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
|
||||
* Copyright (c) contributors
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
|
||||
package org.spongepowered.asm.mixin.injection.points;
|
||||
|
||||
import java.util.Collection;
|
||||
@@ -15,50 +35,62 @@ 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
|
||||
* <p>This injection point searches for RETURN opcodes in the target method and returns a list of insns immediately prior to matching instructions.
|
||||
* Note that <em>every</em> RETURN opcode will be returned and thus every natural exit from the method except for exception throws will be implicitly
|
||||
* specified. To specify a particular RETURN use the <em>ordinal</em> parameter. The injection point accepts the following parameters from
|
||||
* {@link org.spongepowered.asm.mixin.injection.At At}:<p>
|
||||
*
|
||||
* @author Adam Mummery-Smith
|
||||
* <dl>
|
||||
* <dt>ordinal</dt>
|
||||
* <dd>The ordinal position of the RETURN opcode to match, if not specified then the injection point returns <em>all</em> RETURN opcodes. For
|
||||
* example if the RETURN opcode appears 3 times in the method and you want to match the 3rd then you can specify an <em>ordinal</em> of <b>2</b>
|
||||
* (ordinals are zero-indexed). The default value is <b>-1</b> which supresses ordinal matching</dd>
|
||||
* </dl>
|
||||
*
|
||||
* <p>Example:<blockquote><pre>
|
||||
* @At(value = "RETURN")</pre>
|
||||
* </blockquote>
|
||||
* Note that if <em>value</em> is the only parameter specified, it can be omitted:
|
||||
* <blockquote><pre>
|
||||
* @At("RETURN")</pre>
|
||||
* </blockquote></p>
|
||||
*/
|
||||
public class BeforeReturn extends InjectionPoint
|
||||
{
|
||||
public class BeforeReturn extends InjectionPoint {
|
||||
|
||||
public static final String CODE = "RETURN";
|
||||
|
||||
/**
|
||||
* Ordinal of the target insn
|
||||
*/
|
||||
private final int ordinal;
|
||||
|
||||
public BeforeReturn(InjectionPointData data)
|
||||
{
|
||||
this.ordinal = data.getOrdinal();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean find(String desc, InsnList insns, Collection<AbstractInsnNode> nodes) //, Event event)
|
||||
{
|
||||
boolean found = false;
|
||||
int returnOpcode = Type.getReturnType(desc).getOpcode(Opcodes.IRETURN);
|
||||
int ordinal = 0;
|
||||
|
||||
ListIterator<AbstractInsnNode> 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;
|
||||
}
|
||||
public BeforeReturn(InjectionPointData data) {
|
||||
this.ordinal = data.getOrdinal();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean find(String desc, InsnList insns, Collection<AbstractInsnNode> nodes) {
|
||||
boolean found = false;
|
||||
|
||||
// RETURN opcode varies based on return type, thus we calculate what opcode we're actually looking for by inspecting the target method
|
||||
int returnOpcode = Type.getReturnType(desc).getOpcode(Opcodes.IRETURN);
|
||||
int ordinal = 0;
|
||||
|
||||
ListIterator<AbstractInsnNode> 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;
|
||||
}
|
||||
}
|
||||
+109
-63
@@ -1,7 +1,27 @@
|
||||
/**
|
||||
* This file contributed from LiteLoader. Pending refactor. DO NOT ALTER THIS FILE.
|
||||
/*
|
||||
* This file is part of Sponge, licensed under the MIT License (MIT).
|
||||
*
|
||||
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
|
||||
* Copyright (c) contributors
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
|
||||
package org.spongepowered.asm.mixin.injection.points;
|
||||
|
||||
import java.util.Collection;
|
||||
@@ -10,71 +30,97 @@ 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;
|
||||
import org.spongepowered.asm.mixin.injection.struct.MemberInfo;
|
||||
|
||||
/**
|
||||
* An injection point which searches for a matching String LDC insn immediately prior to a qualifying invoke
|
||||
*
|
||||
* @author Adam Mummery-Smith
|
||||
* <p>Like {@link BeforeInvoke}, this injection point searches for INVOKEVIRTUAL, INVOKESTATIC and INVOKESPECIAL opcodes matching its arguments and
|
||||
* returns a list of insns immediately prior to matching instructions. This specialised version however only matches methods which accept a single
|
||||
* string and return void, but allows the string itself to be matched as part of the search process. This is primarily used for matching particular
|
||||
* invocations of <em>Profiler::startSection</em> with a specific argument. Note that because a string literal is required, this injection point can
|
||||
* not be used to match invocations where the value being passed in is a variable.</p>
|
||||
*
|
||||
* <p>To be precise, this injection point matches invocations of the specified method which are preceded by an LDC instruction. The LDC instruction's
|
||||
* payload can be specified with the <b>ldc</b> named argument (see below)</p>
|
||||
*
|
||||
* <p>The following parameters from {@link org.spongepowered.asm.mixin.injection.At At} are accepted<p>
|
||||
*
|
||||
* <dl>
|
||||
* <dt>target</dt>
|
||||
* <dd>A {@link org.spongepowered.asm.mixin.injection.struct.MemberInfo MemberInfo} which identifies the target method, the method <b>must</b> be
|
||||
* specified with a signature which accepts a single string and returns void, eg. <code>(Ljava/lang/String;)V</code></dd>
|
||||
* <dt>ordinal</dt>
|
||||
* <dd>The ordinal position of the method invocation to match. For example if the method is invoked 3 times and you want to match the 3rd then you
|
||||
* can specify an <em>ordinal</em> of <b>2</b> (ordinals are zero-indexed). The default value is <b>-1</b> which supresses ordinal matching</dd>
|
||||
* <dt><em>named argument</em> ldc</dt>
|
||||
* <dd>The value of the LDC node to look for prior to the method invocation</dd>
|
||||
* </dl>
|
||||
*
|
||||
* <p>Example:<blockquote><pre>
|
||||
* @At(value = "INVOKE_STRING", target="startSection(Ljava/lang/String;)V", args = { "ldc=root" })</pre>
|
||||
* </blockquote>
|
||||
* Notice the use of the <em>named argument</em> "ldc" which specifies the value of the target LDC node.</p>
|
||||
*
|
||||
* <p>Note that like all standard injection points, this class matches the insn itself, putting the injection point immediately <em>before</em> the
|
||||
* access in question. Use the {@link org.spongepowered.asm.mixin.injection.At#shift shift} specifier to adjust the matched opcode as necessary.</p>
|
||||
*/
|
||||
public class BeforeStringInvoke extends BeforeInvoke
|
||||
{
|
||||
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", "");
|
||||
private static final String STRING_VOID_SIG = "(Ljava/lang/String;)V";
|
||||
|
||||
// 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<AbstractInsnNode> 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);
|
||||
}
|
||||
/**
|
||||
* LDC value we're searching for
|
||||
*/
|
||||
private final String ldcValue;
|
||||
|
||||
/**
|
||||
* True once a matching LDC node is found
|
||||
*/
|
||||
private boolean foundLdc;
|
||||
|
||||
public BeforeStringInvoke(InjectionPointData data) {
|
||||
super(data);
|
||||
this.ldcValue = data.get("ldc", null);
|
||||
|
||||
if (this.ldcValue == null) {
|
||||
throw new IllegalArgumentException(this.getClass().getSimpleName() + " requires named argument \"ldc\" to specify the desired target");
|
||||
}
|
||||
|
||||
if (!STRING_VOID_SIG.equals(this.target.desc)) {
|
||||
throw new IllegalArgumentException(this.getClass().getSimpleName() + " requires target method with with signature " + STRING_VOID_SIG);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean find(String desc, InsnList insns, Collection<AbstractInsnNode> nodes) {
|
||||
this.foundLdc = false;
|
||||
|
||||
return super.find(desc, insns, nodes);
|
||||
}
|
||||
|
||||
@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) {
|
||||
this.logger.info("{} > found a matching LDC with value {}", this.className, node.cst);
|
||||
}
|
||||
this.foundLdc = true;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
this.foundLdc = false;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected boolean matchesInsn(MemberInfo nodeInfo, int ordinal) {
|
||||
if (this.logging) {
|
||||
this.logger.info("{} > > found LDC \"{}\" = {}", this.className, this.ldcValue, this.foundLdc);
|
||||
}
|
||||
return this.foundLdc && super.matchesInsn(nodeInfo, ordinal);
|
||||
}
|
||||
}
|
||||
@@ -1,65 +1,95 @@
|
||||
/**
|
||||
* This file contributed from LiteLoader. Pending refactor. DO NOT ALTER THIS FILE.
|
||||
/*
|
||||
* This file is part of Sponge, licensed under the MIT License (MIT).
|
||||
*
|
||||
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
|
||||
* Copyright (c) contributors
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
|
||||
package org.spongepowered.asm.mixin.injection.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.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.
|
||||
* <p>This injection point 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. It accepts the following parameters from {@link org.spongepowered.asm.mixin.injection.At At}:<p>
|
||||
*
|
||||
* @author Adam Mummery-Smith
|
||||
* <dl>
|
||||
* <dt>opcode</dt>
|
||||
* <dd>The {@link Opcodes opcode} of the jump instruction, must be one of IFEQ, IFNE, IFLT, IFGE, IFGT, IFLE, IF_ICMPEQ, IF_ICMPNE, IF_ICMPLT,
|
||||
* IF_ICMPGE, IF_ICMPGT, IF_ICMPLE, IF_ACMPEQ, IF_ACMPNE, GOTO, JSR, IFNULL or IFNONNULL. Defaults to <b>-1</b> which matches any JUMP opcode.
|
||||
* </dd>
|
||||
* <dt>ordinal</dt>
|
||||
* <dd>The ordinal position of the jump insn to match. For example if there are 3 jumps of the specified type and you want to match the 2nd then you
|
||||
* can specify an <em>ordinal</em> of <b>1</b> (ordinals are zero-indexed). The default value is <b>-1</b> which supresses ordinal matching</dd>
|
||||
* </dl>
|
||||
*
|
||||
* <p>Example:<blockquote><pre>
|
||||
* @At(value = "JUMP", opcode = Opcodes.IFLE, ordinal = 2)</pre>
|
||||
* </blockquote></p>
|
||||
*
|
||||
* <p>Note that like all standard injection points, this class matches the insn itself, putting the injection point immediately <em>before</em> the
|
||||
* access in question. Use the {@link org.spongepowered.asm.mixin.injection.At#shift shift} specifier to adjust the matched opcode as necessary.</p>
|
||||
*/
|
||||
public class JumpInsnPoint extends InjectionPoint
|
||||
{
|
||||
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<AbstractInsnNode> nodes) //, Event event)
|
||||
{
|
||||
boolean found = false;
|
||||
int ordinal = 0;
|
||||
|
||||
ListIterator<AbstractInsnNode> 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;
|
||||
}
|
||||
|
||||
private final int ordinal;
|
||||
|
||||
public JumpInsnPoint(InjectionPointData data) {
|
||||
this.opCode = data.getOpcode(-1, Opcodes.IFEQ, Opcodes.IFNE, Opcodes.IFLT, Opcodes.IFGE, Opcodes.IFGT, Opcodes.IFLE, Opcodes.IF_ICMPEQ,
|
||||
Opcodes.IF_ICMPNE, Opcodes.IF_ICMPLT, Opcodes.IF_ICMPGE, Opcodes.IF_ICMPGT, Opcodes.IF_ICMPLE, Opcodes.IF_ACMPEQ, Opcodes.IF_ACMPNE,
|
||||
Opcodes.GOTO, Opcodes.JSR, Opcodes.IFNULL, Opcodes.IFNONNULL, -1);
|
||||
this.ordinal = data.getOrdinal();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean find(String desc, InsnList insns, Collection<AbstractInsnNode> nodes) {
|
||||
boolean found = false;
|
||||
int ordinal = 0;
|
||||
|
||||
ListIterator<AbstractInsnNode> 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;
|
||||
}
|
||||
}
|
||||
@@ -1,7 +1,27 @@
|
||||
/**
|
||||
* This file contributed from LiteLoader. Pending refactor. DO NOT ALTER THIS FILE.
|
||||
/*
|
||||
* This file is part of Sponge, licensed under the MIT License (MIT).
|
||||
*
|
||||
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
|
||||
* Copyright (c) contributors
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
|
||||
package org.spongepowered.asm.mixin.injection.points;
|
||||
|
||||
import java.util.Collection;
|
||||
@@ -11,26 +31,24 @@ 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
|
||||
* <p>This injection point simply returns the first instruction in the target method body, allowing the injection to be placed at the "head" of the
|
||||
* target method. It accepts no parameters and only returns a single insn in all circumstances.</p>
|
||||
*
|
||||
* <p>Example:<blockquote><pre>
|
||||
* @At("HEAD")</pre>
|
||||
* </blockquote></p>
|
||||
*/
|
||||
public class MethodHead extends InjectionPoint
|
||||
{
|
||||
public class MethodHead extends InjectionPoint {
|
||||
|
||||
public static final String CODE = "HEAD";
|
||||
|
||||
public MethodHead(InjectionPointData data)
|
||||
{
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean find(String desc, InsnList insns, Collection<AbstractInsnNode> nodes) //, Event event)
|
||||
{
|
||||
nodes.add(insns.getFirst());
|
||||
return true;
|
||||
}
|
||||
public MethodHead(InjectionPointData data) {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean find(String desc, InsnList insns, Collection<AbstractInsnNode> nodes) {
|
||||
nodes.add(insns.getFirst());
|
||||
return true;
|
||||
}
|
||||
}
|
||||
+8
-7
@@ -1,4 +1,4 @@
|
||||
/**
|
||||
/*
|
||||
* This file is part of Sponge, licensed under the MIT License (MIT).
|
||||
*
|
||||
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
|
||||
@@ -22,7 +22,7 @@
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
package org.spongepowered.asm.mixin.injection;
|
||||
package org.spongepowered.asm.mixin.injection.struct;
|
||||
|
||||
import java.util.ArrayDeque;
|
||||
import java.util.ArrayList;
|
||||
@@ -33,15 +33,16 @@ 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.At;
|
||||
import org.spongepowered.asm.mixin.injection.Inject;
|
||||
import org.spongepowered.asm.mixin.injection.InjectionPoint;
|
||||
import org.spongepowered.asm.mixin.injection.InvalidInjectionException;
|
||||
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 {
|
||||
|
||||
@@ -120,8 +121,8 @@ public class InjectionInfo {
|
||||
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");
|
||||
throw new InvalidInjectionException("@Inject annotation on " + this.method.name + " specifies a target class '" + targetMember.owner
|
||||
+ "', which is not supported");
|
||||
}
|
||||
|
||||
this.findMethods(targetMember);
|
||||
@@ -1,4 +1,4 @@
|
||||
/**
|
||||
/*
|
||||
* This file is part of Sponge, licensed under the MIT License (MIT).
|
||||
*
|
||||
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
|
||||
@@ -33,8 +33,6 @@ 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 {
|
||||
|
||||
@@ -127,4 +125,17 @@ public class InjectionPointData {
|
||||
public int getOpcode() {
|
||||
return this.opcode;
|
||||
}
|
||||
|
||||
public int getOpcode(int defaultOpcode) {
|
||||
return this.opcode > 0 ? this.opcode : defaultOpcode;
|
||||
}
|
||||
|
||||
public int getOpcode(int defaultOpcode, int... validOpcodes) {
|
||||
for (int validOpcode : validOpcodes) {
|
||||
if (this.opcode == validOpcode) {
|
||||
return this.opcode;
|
||||
}
|
||||
}
|
||||
return defaultOpcode;
|
||||
}
|
||||
}
|
||||
@@ -1,4 +1,4 @@
|
||||
/**
|
||||
/*
|
||||
* This file is part of Sponge, licensed under the MIT License (MIT).
|
||||
*
|
||||
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
|
||||
@@ -24,35 +24,43 @@
|
||||
*/
|
||||
package org.spongepowered.asm.mixin.injection.struct;
|
||||
|
||||
import org.objectweb.asm.tree.AbstractInsnNode;
|
||||
import org.objectweb.asm.tree.FieldInsnNode;
|
||||
import org.objectweb.asm.tree.MethodInsnNode;
|
||||
|
||||
|
||||
/**
|
||||
* <p>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.</p>
|
||||
*
|
||||
* <p>Some examples: <blockquote><pre>
|
||||
* // references a method called func_1234_a, if there are multiple methods with the same signature, matches the first occurrence
|
||||
* // references a method or field called func_1234_a, if there are multiple members 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
|
||||
* // references a method or field called func_1234_a, if there are multiple members 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 field called field_5678_z which is a String
|
||||
* field_5678_z:Ljava/lang/String;
|
||||
*
|
||||
* // references a ctor which takes a single String argument
|
||||
* <init>(Ljava/lang/String;)V
|
||||
*
|
||||
* // references a method called func_1234_a in class foo.bar.Baz
|
||||
* Lfoo/bar/Baz;func_1234_a
|
||||
*
|
||||
* // references a field called field_5678_z in class com.example.Dave
|
||||
* Lcom/example/Dave;field_5678_z
|
||||
*
|
||||
* // 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</pre></blockquote>
|
||||
* </p>
|
||||
*
|
||||
* @author Adam Mummery-Smith
|
||||
*/
|
||||
public class MemberInfo {
|
||||
|
||||
@@ -108,12 +116,33 @@ public class MemberInfo {
|
||||
this.matchAll = matchAll;
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialise a MemberInfo using the supplied insn which must be an instance of MethodInsnNode or FieldInsnNode
|
||||
*/
|
||||
public MemberInfo(AbstractInsnNode insn) {
|
||||
this.matchAll = false;
|
||||
|
||||
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");
|
||||
}
|
||||
}
|
||||
|
||||
/* (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);
|
||||
return String.format("[OWNER=%s,NAME=%s,DESC=%s,ALL=%s]", this.owner, this.name, this.desc, this.matchAll);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -173,15 +202,23 @@ public class MemberInfo {
|
||||
}
|
||||
|
||||
int parenPos = name.indexOf('(');
|
||||
int colonPos = name.indexOf(':');
|
||||
if (parenPos > -1) {
|
||||
desc = name.substring(parenPos);
|
||||
name = name.substring(0, parenPos);
|
||||
} else if (colonPos > -1) {
|
||||
desc = name.substring(colonPos);
|
||||
name = name.substring(0, colonPos);
|
||||
}
|
||||
|
||||
boolean matchAll = name.endsWith("*");
|
||||
if (matchAll) name = name.substring(0, name.length() - 1);
|
||||
if (matchAll) {
|
||||
name = name.substring(0, name.length() - 1);
|
||||
}
|
||||
|
||||
if (name.isEmpty()) name = null;
|
||||
if (name.isEmpty()) {
|
||||
name = null;
|
||||
}
|
||||
|
||||
return new MemberInfo(name, owner, desc, matchAll);
|
||||
}
|
||||
|
||||
@@ -1,151 +0,0 @@
|
||||
/**
|
||||
* 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<AbstractInsnNode> iterator()
|
||||
{
|
||||
return this.insnList.iterator();
|
||||
}
|
||||
|
||||
@Override
|
||||
public ListIterator<AbstractInsnNode> iterator(int index)
|
||||
{
|
||||
return this.insnList.iterator(index);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void resetLabels()
|
||||
{
|
||||
this.insnList.resetLabels();
|
||||
}
|
||||
}
|
||||
@@ -52,7 +52,7 @@ 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.mixin.injection.struct.InjectionInfo;
|
||||
import org.spongepowered.asm.transformers.TreeTransformer;
|
||||
import org.spongepowered.asm.util.ASMHelper;
|
||||
|
||||
@@ -106,8 +106,7 @@ public class MixinTransformer extends TreeTransformer {
|
||||
*/
|
||||
@Override
|
||||
public byte[] transform(String name, String transformedName, byte[] basicClass) {
|
||||
for (MixinConfig config : this.configs)
|
||||
{
|
||||
for (MixinConfig config : this.configs) {
|
||||
if (transformedName != null && transformedName.startsWith(config.getMixinPackage())) {
|
||||
throw new RuntimeException(String.format("%s is a mixin class and cannot be referenced directly", transformedName));
|
||||
}
|
||||
@@ -156,8 +155,9 @@ public class MixinTransformer extends TreeTransformer {
|
||||
if (MixinTransformer.DEBUG_EXPORT) {
|
||||
try {
|
||||
FileUtils.writeByteArrayToFile(new File(".mixin.out/" + transformedName.replace('.', '/') + ".class"), bytes);
|
||||
} catch (IOException ex) {
|
||||
// don't care
|
||||
}
|
||||
catch (IOException ex) {}
|
||||
}
|
||||
|
||||
return bytes;
|
||||
@@ -179,7 +179,6 @@ public class MixinTransformer extends TreeTransformer {
|
||||
* @param mixin
|
||||
*/
|
||||
protected void applyMixin(ClassNode targetClass, MixinData mixin) {
|
||||
|
||||
try {
|
||||
this.verifyClasses(targetClass, mixin);
|
||||
this.applyMixinInterfaces(targetClass, mixin);
|
||||
@@ -200,7 +199,9 @@ public class MixinTransformer extends TreeTransformer {
|
||||
*/
|
||||
protected void verifyClasses(ClassNode targetClass, MixinData mixin) {
|
||||
String superName = mixin.getClassNode().superName;
|
||||
if (targetClass.superName == null || superName == null || !(targetClass.superName.equals(superName) || "java/lang/Object".equals(superName))) {
|
||||
if (targetClass.superName == null
|
||||
|| superName == null
|
||||
|| !(targetClass.superName.equals(superName) || "java/lang/Object".equals(superName))) {
|
||||
throw new InvalidMixinException("Mixin classes must have the same superclass as their target class");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -490,4 +490,74 @@ public class ASMHelper {
|
||||
public static boolean fieldIsStatic(FieldNode field) {
|
||||
return (field.access & Opcodes.ACC_STATIC) == Opcodes.ACC_STATIC;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 ASMHelper.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 ASMHelper.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;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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) {
|
||||
ASMHelper.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;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,809 +0,0 @@
|
||||
/**
|
||||
* 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<String, List<LocalVariableNode>> calculatedLocalVariables = new HashMap<String, List<LocalVariableNode>>();
|
||||
|
||||
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<AbstractInsnNode> 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)) && "<init>".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<AbstractInsnNode> 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<LocalVariableNode> 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<LocalVariableNode> getLocalVariableTable(ClassNode classNode, MethodNode method)
|
||||
{
|
||||
if (method.localVariables.isEmpty())
|
||||
{
|
||||
String signature = String.format("%s.%s%s", classNode.name, method.name, method.desc);
|
||||
|
||||
List<LocalVariableNode> 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<LocalVariableNode> generateLocalVariableTable(ClassNode classNode, MethodNode method)
|
||||
{
|
||||
List<Type> interfaces = null;
|
||||
if (classNode.interfaces != null)
|
||||
{
|
||||
interfaces = new ArrayList<Type>();
|
||||
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<BasicValue> analyzer = new Analyzer<BasicValue>(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<BasicValue>[] frames = analyzer.getFrames();
|
||||
|
||||
// Record the original size of hte method
|
||||
int methodSize = method.instructions.size();
|
||||
|
||||
// List of LocalVariableNodes to return
|
||||
List<LocalVariableNode> localVariables = new ArrayList<LocalVariableNode>();
|
||||
|
||||
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<BasicValue> 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.<List<String>>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.<List<String>>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<IClassTransformer> 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<AnnotationNode> 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> 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> 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();
|
||||
// }
|
||||
}
|
||||
@@ -0,0 +1,318 @@
|
||||
/*
|
||||
* This file is part of Sponge, licensed under the MIT License (MIT).
|
||||
*
|
||||
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
|
||||
* Copyright (c) contributors
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
package org.spongepowered.asm.util;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
import org.objectweb.asm.Opcodes;
|
||||
import org.objectweb.asm.Type;
|
||||
import org.objectweb.asm.tree.AbstractInsnNode;
|
||||
import org.objectweb.asm.tree.ClassNode;
|
||||
import org.objectweb.asm.tree.FrameNode;
|
||||
import org.objectweb.asm.tree.InsnList;
|
||||
import org.objectweb.asm.tree.LabelNode;
|
||||
import org.objectweb.asm.tree.LocalVariableNode;
|
||||
import org.objectweb.asm.tree.MethodNode;
|
||||
import org.objectweb.asm.tree.VarInsnNode;
|
||||
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;
|
||||
|
||||
|
||||
/**
|
||||
* Utility methods for working with local variables using ASM
|
||||
*/
|
||||
public class Locals {
|
||||
|
||||
/**
|
||||
* Cached local variable lists, to avoid having to recalculate them (expensive) if multiple injectors are working with the same method
|
||||
*/
|
||||
private static final Map<String, List<LocalVariableNode>> calculatedLocalVariables = new HashMap<String, List<LocalVariableNode>>();
|
||||
|
||||
/**
|
||||
* 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));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* <p>Attempts to identify available locals at an arbitrary point in the bytecode specified by node.</p>
|
||||
*
|
||||
* <p>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:</p>
|
||||
* <ul>
|
||||
* <li>Any available stack map frames</li>
|
||||
* <li>STORE opcodes</li>
|
||||
* <li>The local variable table</li>
|
||||
* </ul>
|
||||
*
|
||||
* <p>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.</p>
|
||||
*
|
||||
* <p>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.</p>
|
||||
*
|
||||
* @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<AbstractInsnNode> 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] = Locals.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] = Locals.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] = Locals.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<LocalVariableNode> localVariables = Locals.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<LocalVariableNode> getLocalVariableTable(ClassNode classNode, MethodNode method) {
|
||||
if (method.localVariables.isEmpty()) {
|
||||
String signature = String.format("%s.%s%s", classNode.name, method.name, method.desc);
|
||||
|
||||
List<LocalVariableNode> localVars = Locals.calculatedLocalVariables.get(signature);
|
||||
if (localVars != null) {
|
||||
return localVars;
|
||||
}
|
||||
|
||||
localVars = Locals.generateLocalVariableTable(classNode, method);
|
||||
Locals.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<LocalVariableNode> generateLocalVariableTable(ClassNode classNode, MethodNode method) {
|
||||
List<Type> interfaces = null;
|
||||
if (classNode.interfaces != null) {
|
||||
interfaces = new ArrayList<Type>();
|
||||
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<BasicValue> analyzer = new Analyzer<BasicValue>(
|
||||
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<BasicValue>[] frames = analyzer.getFrames();
|
||||
|
||||
// Record the original size of hte method
|
||||
int methodSize = method.instructions.size();
|
||||
|
||||
// List of LocalVariableNodes to return
|
||||
List<LocalVariableNode> localVariables = new ArrayList<LocalVariableNode>();
|
||||
|
||||
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<BasicValue> 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;
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user