fix issue with naming method arguments and the local variable tables

4 files changed, 82 insertions, 7 deletions

diff --git a/src/cuchaz/enigma/TranslatingTypeLoader.java b/src/cuchaz/enigma/TranslatingTypeLoader.java
index ecd7d64..dce4b85 100644
--- a/src/cuchaz/enigma/TranslatingTypeLoader.java
+++ b/src/cuchaz/enigma/TranslatingTypeLoader.java
@@ -233,7 +233,7 @@ public class TranslatingTypeLoader implements ITypeLoader {
                 // do all kinds of deobfuscating transformations on the class
                 new BridgeMarker(m_jarIndex).markBridges(c);
                 new MethodParameterWriter(m_deobfuscatingTranslator).writeMethodArguments(c);
-                new LocalVariableRenamer().rename(c);
+                new LocalVariableRenamer(m_deobfuscatingTranslator).rename(c);
                 new ClassTranslator(m_deobfuscatingTranslator).translate(c);
                 
                 return c;
diff --git a/src/cuchaz/enigma/bytecode/LocalVariableRenamer.java b/src/cuchaz/enigma/bytecode/LocalVariableRenamer.java
index c87c25b..1179560 100644
--- a/src/cuchaz/enigma/bytecode/LocalVariableRenamer.java
+++ b/src/cuchaz/enigma/bytecode/LocalVariableRenamer.java
@@ -6,9 +6,20 @@ import javassist.bytecode.ByteArray;
 import javassist.bytecode.CodeAttribute;
 import javassist.bytecode.ConstPool;
 import javassist.bytecode.LocalVariableAttribute;
+import javassist.bytecode.LocalVariableTypeAttribute;
+import cuchaz.enigma.mapping.ArgumentEntry;
+import cuchaz.enigma.mapping.BehaviorEntry;
+import cuchaz.enigma.mapping.EntryFactory;
+import cuchaz.enigma.mapping.Translator;
 
 
 public class LocalVariableRenamer {
+        
+        private Translator m_translator;
+        
+        public LocalVariableRenamer(Translator translator) {
+                m_translator = translator;
+        }
 
         public void rename(CtClass c) {
                 for (CtBehavior behavior : c.getDeclaredBehaviors()) {
@@ -18,18 +29,67 @@ public class LocalVariableRenamer {
                         if (codeAttribute == null) {
                                 continue;
                         }
+                        
+                        BehaviorEntry behaviorEntry = EntryFactory.getBehaviorEntry(behavior);
+                        ConstPool constants = c.getClassFile().getConstPool();
+                        
                         LocalVariableAttribute table = (LocalVariableAttribute)codeAttribute.getAttribute(LocalVariableAttribute.tag);
-                        if (table == null) {
-                                continue;
+                        if (table != null) {
+                                renameTable(behaviorEntry, constants, table);
                         }
                         
-                        ConstPool constants = c.getClassFile().getConstPool();
-                        for (int i=0; i<table.tableLength(); i++) {
-                                renameVariable(table, i, constants.addUtf8Info("v" + i));
+                        LocalVariableTypeAttribute typeTable = (LocalVariableTypeAttribute)codeAttribute.getAttribute(LocalVariableAttribute.typeTag);
+                        if (typeTable != null) {
+                                renameTable(behaviorEntry, constants, typeTable);
                         }
                 }
         }
 
+        // DEBUG
+        @SuppressWarnings("unused")
+        private void dumpTable(LocalVariableAttribute table) {
+                for (int i=0; i<table.tableLength(); i++) {
+                        System.out.println(String.format("\t%d (%d): %s %s",
+                                i, table.index(i), table.variableName(i), table.descriptor(i)
+                        ));
+                }
+        }
+
+        private void renameTable(BehaviorEntry behaviorEntry, ConstPool constants, LocalVariableAttribute table) {
+                
+                // skip empty tables
+                if (table.tableLength() <= 0) {
+                        return;
+                }
+                
+                // where do we start counting variables?
+                int starti = 0;
+                if (table.variableName(0).equals("this")) {
+                        // skip the "this" variable
+                        starti = 1;
+                }
+                
+                // rename method arguments first
+                int numArgs = 0;
+                if (behaviorEntry.getSignature() != null) {
+                        numArgs = behaviorEntry.getSignature().getArgumentTypes().size();
+                        for (int i=starti; i<starti + numArgs && i<table.tableLength(); i++) {
+                                int argi = i - starti;
+                                String argName = m_translator.translate(new ArgumentEntry(behaviorEntry, argi, ""));
+                                if (argName == null) {
+                                        argName = "a" + (argi + 1);
+                                }
+                                renameVariable(table, i, constants.addUtf8Info(argName));
+                        }
+                }
+                
+                // then rename the rest of the args, if any
+                for (int i=starti + numArgs; i<table.tableLength(); i++) {
+                        int firstIndex = table.index(starti + numArgs);
+                        renameVariable(table, i, constants.addUtf8Info("v" + (table.index(i) - firstIndex + 1)));
+                }
+        }
+        
         private void renameVariable(LocalVariableAttribute table, int i, int stringId) {
                 // based off of LocalVariableAttribute.nameIndex()
                 ByteArray.write16bit(stringId, table.get(), i*10 + 6);
diff --git a/src/cuchaz/enigma/bytecode/MethodParameterWriter.java b/src/cuchaz/enigma/bytecode/MethodParameterWriter.java
index f64ca02..87c9196 100644
--- a/src/cuchaz/enigma/bytecode/MethodParameterWriter.java
+++ b/src/cuchaz/enigma/bytecode/MethodParameterWriter.java
@@ -15,6 +15,8 @@ import java.util.List;
 
 import javassist.CtBehavior;
 import javassist.CtClass;
+import javassist.bytecode.CodeAttribute;
+import javassist.bytecode.LocalVariableAttribute;
 import cuchaz.enigma.mapping.ArgumentEntry;
 import cuchaz.enigma.mapping.BehaviorEntry;
 import cuchaz.enigma.mapping.EntryFactory;
@@ -33,6 +35,15 @@ public class MethodParameterWriter {
                 
                 // Procyon will read method arguments from the "MethodParameters" attribute, so write those
                 for (CtBehavior behavior : c.getDeclaredBehaviors()) {
+                        
+                        // if there's a local variable table here, don't write a MethodParameters attribute
+                        // let the local variable writer deal with it instead
+                        // procyon starts doing really weird things if we give it both attributes
+                        CodeAttribute codeAttribute = behavior.getMethodInfo().getCodeAttribute();
+                        if (codeAttribute != null && codeAttribute.getAttribute(LocalVariableAttribute.tag) != null) {
+                                continue;
+                        }
+                        
                         BehaviorEntry behaviorEntry = EntryFactory.getBehaviorEntry(behavior);
 
                         // get the number of arguments
@@ -53,6 +64,9 @@ public class MethodParameterWriter {
                         }
                         
                         // save the mappings to the class
+                        for (String name : names) {
+                                System.out.println("\t" + name);
+                        }
                         MethodParametersAttribute.updateClass(behavior.getMethodInfo(), names);
                 }
         }
diff --git a/src/cuchaz/enigma/bytecode/MethodParametersAttribute.java b/src/cuchaz/enigma/bytecode/MethodParametersAttribute.java
index bf95956..27f5b9b 100644
--- a/src/cuchaz/enigma/bytecode/MethodParametersAttribute.java
+++ b/src/cuchaz/enigma/bytecode/MethodParametersAttribute.java
@@ -27,6 +27,7 @@ public class MethodParametersAttribute extends AttributeInfo {
         }
         
         public static void updateClass(MethodInfo info, List<String> names) {
+                
                 // add the names to the class const pool
                 ConstPool constPool = info.getConstPool();
                 List<Integer> parameterNameIndices = new ArrayList<Integer>();
@@ -44,7 +45,7 @@ public class MethodParametersAttribute extends AttributeInfo {
         
         private static byte[] writeStruct(List<Integer> parameterNameIndices) {
                 // JVM 8 Spec says the struct looks like this:
-                // http://cr.openjdk.java.net/~mr/se/8/java-se-8-fr-spec-01/java-se-8-jvms-fr-diffs.pdf
+                // http://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.24
                 // uint8 num_params
                 // for each param:
                 // uint16 name_index -> points to UTF8 entry in constant pool, or 0 for no entry