adding BeforeStringInvoke injection point class

Mumfrey
1 parent b29e8bbb
Showing 2 changed files with 93 additions and 12 deletions
java/common/com/mumfrey/liteloader/transformers/event/inject/BeforeInvoke.java
java/common/com/mumfrey/liteloader/transformers/event/inject/BeforeStringInvoke.java
@@ -24,30 +24,30 @@ public class BeforeInvoke extends InjectionPoint
 	/**
 	 * Method name(s) to search for, usually this will contain the different names of the method for different obfuscations (mcp, srg, notch)
 	 */
-	private final String[] methodNames;
+	protected final String[] methodNames;
 	/**
 	 * Method owner(s) to search for, the values in this array MUST much the equivalent indices in methodNames, if the array is NULL then
 	 * all owners are valid  
 	 */
-	private final String[] methodOwners;
+	protected final String[] methodOwners;
 	/**
 	 * Method signature(s) to search for, the values in this array MUST much the equivalent indices in methodNames, if the array is NULL
 	 * then all signatures are valid  
 	 */
-	private final String[] methodSignatures;
+	protected final String[] methodSignatures;
 	/**
 	 * 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. 
 	 */
-	private final int ordinal;
+	protected final int ordinal;
 	/**
 	 * True to turn on strategy debugging to the console
 	 */
-	private boolean logging = false;
+	protected boolean logging = false;
 	/**
 	 * Match all occurrences of the specified method or methods
@@ -220,27 +220,36 @@ public class BeforeInvoke extends InjectionPoint
 				if (index > -1 && ownerIndex == index && descIndex == index)
 				{
 					if (this.logging) LiteLoaderLogger.info("BeforeInvoke found a matching invoke, checking ordinal...");
-					if (this.ordinal == -1)
+					if (this.matchesInsn(node, ordinal))
 					{
 						if (this.logging) LiteLoaderLogger.info("BeforeInvoke found a matching invoke at ordinal %d", ordinal);
 						nodes.add(node);
 						found = true;
-					}
-					else if (this.ordinal == ordinal)
-					{
-						if (this.logging) LiteLoaderLogger.info("BeforeInvoke found a matching invoke at ordinal %d", ordinal);
-						nodes.add(node);
-						return true;
+						
+						if (this.ordinal == ordinal)
+							break;
 					}
 					ordinal++;
 				}
 			}
+
+			this.inspectInsn(desc, insns, insn);
 		}
 		return found;
 	}
+	protected void inspectInsn(String desc, InsnList insns, AbstractInsnNode insn)
+	{
+		// stub for subclasses
+	}
+
+	protected boolean matchesInsn(MethodInsnNode node, int 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
+package com.mumfrey.liteloader.transformers.event.inject;
+
+import java.util.Collection;
+
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.InsnList;
+import org.objectweb.asm.tree.LdcInsnNode;
+import org.objectweb.asm.tree.MethodInsnNode;
+
+import com.mumfrey.liteloader.transformers.event.Event;
+import com.mumfrey.liteloader.transformers.event.MethodInfo;
+import com.mumfrey.liteloader.util.log.LiteLoaderLogger;
+
+/**
+ * An injection point which searches for a matching String LDC insn immediately prior to a qualifying invoke
+ *  
+ * @author Adam Mummery-Smith
+ */
+public class BeforeStringInvoke extends BeforeInvoke
+{
+	private static final String STRING_VOID_SIG = "(Ljava/lang/String;)V";
+	
+	private final String ldcValue;
+	
+	private boolean foundLdc;
+	
+	public BeforeStringInvoke(String ldcValue, MethodInfo method)
+	{
+		this(ldcValue, method, -1);
+	}
+	
+	public BeforeStringInvoke(String ldcValue, MethodInfo method, int ordinal)
+	{
+		super(method, ordinal);
+		this.ldcValue = ldcValue;
+
+		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(MethodInsnNode node, int ordinal)
+	{
+		return this.foundLdc && super.matchesInsn(node, ordinal);
+	}
+}