New optional --lvt argument, possible values STRIP and FERNFLOWER. STRIP will remove the LocalVariableTable {Emulating the old MC versions where it was removed} and FERNFLOWER will rename any 'snowman' LV's to Fermflower 'var'+index names.

LexManos · LexManos · commit 78da22c3e3ce · 2015-05-26T01:08:23.000-07:00
diff --git a/src/main/java/de/oceanlabs/mcp/mcinjector/LVTNaming.java b/src/main/java/de/oceanlabs/mcp/mcinjector/LVTNaming.java
@@ -0,0 +1,7 @@
+package de.oceanlabs.mcp.mcinjector;
+
+public enum LVTNaming
+{
+    STRIP,
+    FERNFLOWER
+}
diff --git a/src/main/java/de/oceanlabs/mcp/mcinjector/MCInjector.java b/src/main/java/de/oceanlabs/mcp/mcinjector/MCInjector.java
@@ -13,10 +13,10 @@ public class MCInjector
 {
     private final static Logger log = Logger.getLogger("MCInjector");
     public static final String VERSION = "MCInjector v3.2 by Searge, LexManos, Fesh0r";
-    
+
     public static void main(String[] args) throws Exception
     {
-        
+
         OptionParser parser = new OptionParser();
         parser.accepts("help").forHelp();
         parser.accepts("version").forHelp();
@@ -29,6 +29,7 @@ public static void main(String[] args) throws Exception
         parser.accepts("jsonIn").withRequiredArg();
         parser.accepts("applyMarkers");
         parser.accepts("generateParams");
+        parser.accepts("lvt").withRequiredArg().ofType(LVTNaming.class).defaultsTo(LVTNaming.STRIP);
 
         try
         {
@@ -54,10 +55,11 @@ else if (options.has("version"))
             int index      = (Integer)options.valueOf("index");
             boolean applyM = options.has("applyMarkers");
             boolean genArgs = options.has("generateParams");
-    
+            LVTNaming naming = (LVTNaming)options.valueOf("lvt");
+
             MCInjector.log.setUseParentHandlers(false);
             MCInjector.log.setLevel(Level.ALL);
-    
+
             if (log != null)
             {
                 FileHandler filehandler = new FileHandler(log);
@@ -69,13 +71,13 @@ else if (options.has("version"))
                     public void publish(LogRecord record)
                     {
                         System.out.println(String.format(record.getMessage(), record.getParameters()));
-                        
+
                     }
                     @Override public void flush() {}
                     @Override public void close() throws SecurityException {}
                 });
             }
-    
+
             log(MCInjector.VERSION);
             log("Input:          " + jarIn);
             log("Output:         " + jarOut);
@@ -86,10 +88,11 @@ public void publish(LogRecord record)
             log("Json:           " + jsonIn);
             log("ApplyMarker:    " + applyM);
             log("GenArgs:        " + genArgs);
-    
+            log("LVT:            " + naming);
+
             try
             {
-                MCInjectorImpl.process(jarIn, jarOut, mapIn, log, mapOut, index, jsonIn, applyM, genArgs);
+                MCInjectorImpl.process(jarIn, jarOut, mapIn, log, mapOut, index, jsonIn, applyM, genArgs, naming);
             }
             catch (Exception e)
             {
diff --git a/src/main/java/de/oceanlabs/mcp/mcinjector/MCInjectorImpl.java b/src/main/java/de/oceanlabs/mcp/mcinjector/MCInjectorImpl.java
@@ -12,6 +12,7 @@
 import java.io.OutputStream;
 import java.io.Reader;
 import java.io.Writer;
+import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Enumeration;
@@ -31,7 +32,9 @@
 import org.objectweb.asm.ClassReader;
 import org.objectweb.asm.ClassVisitor;
 import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.MethodVisitor;
 import org.objectweb.asm.tree.ClassNode;
+import org.objectweb.asm.tree.MethodNode;
 
 import com.google.gson.*;
 
@@ -41,6 +44,8 @@
 import de.oceanlabs.mcp.mcinjector.adaptors.ApplyMarker;
 import de.oceanlabs.mcp.mcinjector.adaptors.GenerateMap;
 import de.oceanlabs.mcp.mcinjector.adaptors.JsonAttribute;
+import de.oceanlabs.mcp.mcinjector.adaptors.LVTFernflower;
+import de.oceanlabs.mcp.mcinjector.adaptors.LVTStrip;
 import de.oceanlabs.mcp.mcinjector.adaptors.ReadMarker;
 
 public class MCInjectorImpl
@@ -73,24 +78,31 @@ public synchronized Enumeration keys()
     private boolean applyMarkers = false;
     public final InheratanceMap inheratance;
     public boolean genParams = false;
+    public LVTNaming naming = LVTNaming.STRIP;
 
     public static void process(String inFile, String outFile, String mapFile, String logFile, String outMapFile, int index, String classJson, boolean applyMarkers)
         throws IOException
     {
         process(inFile, outFile, mapFile, logFile, outMapFile, index, classJson, applyMarkers, false);
     }
+    public static void process(String inFile, String outFile, String mapFile, String logFile, String outMapFile, int index, String classJson, boolean applyMarkers, boolean genParams)
+        throws IOException
+    {
+        process(inFile, outFile, mapFile, logFile, outMapFile, index, classJson, applyMarkers, false, LVTNaming.STRIP);
+    }
 
     public static void process(
             String inFile, String outFile, String mapFile, String logFile,
             String outMapFile, int index, String classJson,
-            boolean applyMarkers, boolean genParams)
+            boolean applyMarkers, boolean genParams, LVTNaming naming)
         throws IOException
     {
         MCInjectorImpl mci = new MCInjectorImpl(index, outMapFile != null);
         mci.loadJson(classJson);
         mci.loadMap(mapFile);
         mci.applyMarkers = applyMarkers;
         mci.genParams = genParams;
+        mci.naming = naming;
 
         mci.processJar(inFile, outFile);
 
@@ -600,7 +612,14 @@ public byte[] processClass(byte[] cls, boolean readOnly)
         }
         else
         {
-            ca = new ApplyMap(cn, this);
+            ca = new ApplyMap(ca, this);
+
+            switch (naming)
+            {
+                case STRIP:      ca = new LVTStrip     (ca, this); break;
+                case FERNFLOWER: ca = new LVTFernflower(ca, this); break;
+            }
+
             ca = new JsonAttribute(ca, this);
 
             if (applyMarkers)
@@ -624,4 +643,27 @@ public byte[] processClass(byte[] cls, boolean readOnly)
         return writer.toByteArray();
     }
 
-}
+    private static Field field_mv;
+    public static MethodNode getMethodNode(MethodVisitor mv)
+    {
+        try
+        {
+            if (field_mv == null)
+            {
+                field_mv = MethodVisitor.class.getDeclaredField("mv");
+                field_mv.setAccessible(true);
+            }
+            MethodVisitor tmp = mv;
+            while (!(tmp instanceof MethodNode) && tmp != null)
+                tmp = (MethodVisitor)field_mv.get(tmp);
+            return (MethodNode)tmp;
+        }
+        catch (Exception e)
+        {
+            if (e instanceof RuntimeException)
+                throw (RuntimeException)e;
+            throw new RuntimeException(e);
+
+        }
+    }
+}
diff --git a/src/main/java/de/oceanlabs/mcp/mcinjector/adaptors/ApplyMap.java b/src/main/java/de/oceanlabs/mcp/mcinjector/adaptors/ApplyMap.java
@@ -2,7 +2,11 @@
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
@@ -11,7 +15,6 @@
 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.LabelNode;
 import org.objectweb.asm.tree.LocalVariableNode;
 import org.objectweb.asm.tree.MethodNode;
@@ -24,13 +27,11 @@ public class ApplyMap extends ClassVisitor
     private static final Logger log = Logger.getLogger("MCInjector");
     private MCInjectorImpl mci;
     String className;
-    private ClassNode cn;
 
-    public ApplyMap(ClassNode cn, MCInjectorImpl mci)
+    public ApplyMap(ClassVisitor cn, MCInjectorImpl mci)
     {
         super(Opcodes.ASM5, cn);
         this.mci = mci;
-        this.cn = cn;
     }
 
     @Override
@@ -52,7 +53,7 @@ public MethodVisitor visitMethod(int access, String name, String desc, String si
 
         if (!mci.generate) log.log(Level.FINER, "  Name: " + name + " Desc: " + desc + " Sig: " + signature);
 
-        String clsSig = this.className + "." + name + desc;
+        final String clsSig = this.className + "." + name + desc;
 
         exceptions = processExceptions(clsSig, exceptions);
 
@@ -62,9 +63,16 @@ public MethodVisitor visitMethod(int access, String name, String desc, String si
             return super.visitMethod(access, name, desc, signature, exceptions);
         }
 
-        MethodNode mn = (MethodNode)cn.visitMethod(access, name, desc, signature, exceptions);
-        mn = processLVT(className, clsSig, mn);
-        return mn;
+        MethodNode mn = (MethodNode)cv.visitMethod(access, name, desc, signature, exceptions);
+        return new MethodVisitor(api, mn)
+        {
+            @Override
+            public void visitEnd()
+            {
+                super.visitEnd();
+                processLVT(className, clsSig, MCInjectorImpl.getMethodNode(mv));
+            }
+        };
     }
 
     private String[] processExceptions(String clsSig, String[] exceptions)
@@ -143,25 +151,57 @@ else if (tmp.getType() != AbstractInsnNode.LABEL)
         LabelNode start = (LabelNode)mn.instructions.getFirst();
         LabelNode end = (LabelNode)mn.instructions.getLast();
 
-        mn.localVariables = new ArrayList<LocalVariableNode>();
+        Map<Integer, LocalVariableNode> lvt = new HashMap<Integer, LocalVariableNode>();
+        if (mn.localVariables != null)
+        {
+            for (LocalVariableNode lvn : mn.localVariables)
+            {
+                if (lvt.containsKey(lvn.index))
+                {
+                    log.info("  DUPLICATE LVT INDEX: " + lvn.index);
+                }
+                lvt.put(lvn.index, lvn);
+            }
+        }
 
         for (int x = 0, y = x; x < params.size(); x++, y++)
         {
             String arg = params.get(x);
             String desc = types.get(x).getDescriptor();
+            LocalVariableNode lvn = lvt.get(y);
 
             if (arg.equals(""))
             {
                 log.fine("      Skipping argument " + x + " (" + y + ") -> " + desc);
             }
             else
             {
-                log.fine("      Naming argument " + x + " (" + y + ") -> " + arg + " " + desc);
-                mn.localVariables.add(new LocalVariableNode(arg, desc, null, start, end, y));
+                if (lvn != null)
+                {
+                    log.fine("      ReNaming argument " + x + " (" + y + "): " + lvn.name + " -> " + arg);
+                    lvn.name = arg;
+                }
+                else
+                {
+                    log.fine("      Naming argument " + x + " (" + y + ") -> " + arg + " " + desc);
+                    lvt.put(y, new LocalVariableNode(arg, desc, null, start, end, y));
+                }
             }
 
             if (desc.equals("J") || desc.equals("D")) y++;
         }
+
+        mn.localVariables = new ArrayList<LocalVariableNode>();
+        mn.localVariables.addAll(lvt.values());
+        Collections.sort(mn.localVariables, new Comparator<LocalVariableNode>()
+        {
+            @Override
+            public int compare(LocalVariableNode o1, LocalVariableNode o2)
+            {
+                return (o1.index < o2.index ? -1 : (o1.index == o2.index ? 0 : 1));
+            }
+        });
+
         return mn;
     }
 }
diff --git a/src/main/java/de/oceanlabs/mcp/mcinjector/adaptors/LVTFernflower.java b/src/main/java/de/oceanlabs/mcp/mcinjector/adaptors/LVTFernflower.java
@@ -0,0 +1,55 @@
+package de.oceanlabs.mcp.mcinjector.adaptors;
+
+import java.util.logging.Logger;
+
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.tree.LocalVariableNode;
+import org.objectweb.asm.tree.MethodNode;
+
+import de.oceanlabs.mcp.mcinjector.MCInjectorImpl;
+
+public class LVTFernflower extends ClassVisitor
+{
+    private static final Logger log = Logger.getLogger("MCInjector");
+    //private MCInjectorImpl mci;
+    String className;
+
+    public LVTFernflower(ClassVisitor cn, MCInjectorImpl mci)
+    {
+        super(Opcodes.ASM5, cn);
+        //this.mci = mci;
+    }
+
+    @Override
+    public void visit(int version, int access, String name, String signature, String superName, String[] interfaces)
+    {
+        this.className = name;
+        super.visit(version, access, name, signature, superName, interfaces);
+    }
+
+    @Override
+    public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions)
+    {
+        return new MethodVisitor(api, cv.visitMethod(access, name, desc, signature, exceptions))
+        {
+            @Override
+            public void visitEnd()
+            {
+                super.visitEnd();
+                MethodNode mn = MCInjectorImpl.getMethodNode(mv);
+                if (mn.localVariables != null && mn.localVariables.size() > 0)
+                {
+                    for (LocalVariableNode lvn : mn.localVariables)
+                    {
+                        if (0x2603 != lvn.name.charAt(0)) // Snowmen, added in 1.8.2? rename them to FF names
+                            continue;
+                        log.info("    Renaming LVT: " + lvn.index + " " + lvn.name + " " +lvn.desc + " -> " + "var" + lvn.index);
+                        lvn.name = "var" + lvn.index;
+                    }
+                }
+            }
+        };
+    }
+}
diff --git a/src/main/java/de/oceanlabs/mcp/mcinjector/adaptors/LVTStrip.java b/src/main/java/de/oceanlabs/mcp/mcinjector/adaptors/LVTStrip.java
