started adding minimal support for generics

fixed mark-as-deobfuscated issue

2 files changed, 124 insertions, 82 deletions

diff --git a/src/cuchaz/enigma/bytecode/ClassRenamer.java b/src/cuchaz/enigma/bytecode/ClassRenamer.java
index e9cdea3..8bc084d 100644
--- a/src/cuchaz/enigma/bytecode/ClassRenamer.java
+++ b/src/cuchaz/enigma/bytecode/ClassRenamer.java
@@ -23,60 +23,100 @@ import com.google.common.collect.Maps;
 import com.google.common.collect.Sets;
 
 import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.ClassNameReplacer;
+import cuchaz.enigma.mapping.ParameterizedType;
+import cuchaz.enigma.mapping.Translator;
+import cuchaz.enigma.mapping.Type;
 
 public class ClassRenamer {
         
-        public static void renameClasses(CtClass c, Map<ClassEntry,ClassEntry> map) {
-                
-                // build the map used by javassist
-                ClassMap nameMap = new ClassMap();
-                for (Map.Entry<ClassEntry,ClassEntry> entry : map.entrySet()) {
-                        nameMap.put(entry.getKey().getName(), entry.getValue().getName());
-                }
-                
-                c.replaceClassName(nameMap);
-                
-                // replace simple names in the InnerClasses attribute too
-                ConstPool constants = c.getClassFile().getConstPool();
-                InnerClassesAttribute attr = (InnerClassesAttribute)c.getClassFile().getAttribute(InnerClassesAttribute.tag);
-                if (attr != null) {
-                        for (int i = 0; i < attr.tableLength(); i++) {
-                                ClassEntry classEntry = new ClassEntry(Descriptor.toJvmName(attr.innerClass(i)));
-                                if (attr.innerNameIndex(i) != 0) {
-                                        attr.setInnerNameIndex(i, constants.addUtf8Info(classEntry.getInnermostClassName()));
+        public static void renameClasses(CtClass c, final Translator translator) {
+                renameClasses(c, new ClassNameReplacer() {
+                        @Override
+                        public String replace(String className) {
+                                ClassEntry entry = translator.translateEntry(new ClassEntry(className));
+                                if (entry != null) {
+                                        return entry.getName();
                                 }
-                                
-                                /* DEBUG
-                                System.out.println(String.format("\tDEOBF: %s-> ATTR: %s,%s,%s", classEntry, attr.outerClass(i), attr.innerClass(i), attr.innerName(i)));
-                                */
+                                return null;
                         }
-                }
+                });
         }
         
-        public static Set<ClassEntry> getAllClassEntries(final CtClass c) {
+        public static void moveAllClassesOutOfDefaultPackage(CtClass c, final String newPackageName) {
+                renameClasses(c, new ClassNameReplacer() {
+                        @Override
+                        public String replace(String className) {
+                                ClassEntry entry = new ClassEntry(className);
+                                if (entry.isInDefaultPackage()) {
+                                        return newPackageName + "/" + entry.getName();
+                                }
+                                return null;
+                        }
+                });
+        }
+        
+        public static void moveAllClassesIntoDefaultPackage(CtClass c, final String oldPackageName) {
+                renameClasses(c, new ClassNameReplacer() {
+                        @Override
+                        public String replace(String className) {
+                                ClassEntry entry = new ClassEntry(className);
+                                if (entry.getPackageName().equals(oldPackageName)) {
+                                        return entry.getSimpleName();
+                                }
+                                return null;
+                        }
+                });
+        }
+        
+        public static void renameClasses(CtClass c, ClassNameReplacer replacer) {
+                Map<ParameterizedType,ParameterizedType> map = Maps.newHashMap();
+                for (ParameterizedType type : ClassRenamer.getAllClassTypes(c)) {
+                        ParameterizedType renamedType = new ParameterizedType(type, replacer);
+                        if (!type.equals(renamedType)) {
+                                map.put(type, renamedType);
+                        }
+                }
+                renameTypes(c, map);
+        }
+
+        public static Set<ParameterizedType> getAllClassTypes(final CtClass c) {
                 
-                // get the classes that javassist knows about
-                final Set<ClassEntry> entries = Sets.newHashSet();
+                // TODO: might have to scan SignatureAttributes directly because javassist is buggy
+                
+                // get the class types that javassist knows about
+                final Set<ParameterizedType> types = Sets.newHashSet();
                 ClassMap map = new ClassMap() {
                         @Override
                         public Object get(Object obj) {
                                 if (obj instanceof String) {
                                         String str = (String)obj;
                                         
-                                        // javassist throws a lot of weird things at this map
-                                        // I either have to implement my on class scanner, or just try to filter out the weirdness
-                                        // I'm opting to filter out the weirdness for now
+                                        // sometimes javasist gives us dot-separated classes... whadda hell?
+                                        str = str.replace('.', '/');
                                         
-                                        // skip anything with generic arguments
-                                        if (str.indexOf('<') >= 0 || str.indexOf('>') >= 0 || str.indexOf(';') >= 0) {
+                                        // skip weird types
+                                        boolean hasNestedParams = str.indexOf('<') >= 0 && str.indexOf('<', str.indexOf('<')+1) >= 0;
+                                        boolean hasWeirdChars = str.indexOf('*') >= 0 || str.indexOf('-') >= 0 || str.indexOf('+') >= 0;
+                                        if (hasNestedParams || hasWeirdChars) {
+                                                // TEMP
+                                                System.out.println("Skipped translating: " + str);
                                                 return null;
                                         }
                                         
-                                        // convert path/to/class.inner to path/to/class$inner
-                                        str = str.replace('.', '$');
+                                        ParameterizedType type = new ParameterizedType(new Type("L" + str + ";"));
+                                        assert(type.isClass());
+                                        // TEMP
+                                        try {
+                                                type.getClassEntry();
+                                        } catch (Throwable t) {
+                                                // bad type
+                                                // TEMP
+                                                System.out.println("Skipped translating: " + str);
+                                                return null;
+                                        }
                                         
-                                        // remember everything else
-                                        entries.add(new ClassEntry(str));
+                                        types.add(type);
                                 }
                                 return null;
                         }
@@ -85,26 +125,46 @@ public class ClassRenamer {
                 };
                 c.replaceClassName(map);
                 
-                return entries;
+                return types;
         }
-        
-        public static void moveAllClassesOutOfDefaultPackage(CtClass c, String newPackageName) {
-                Map<ClassEntry,ClassEntry> map = Maps.newHashMap();
-                for (ClassEntry classEntry : ClassRenamer.getAllClassEntries(c)) {
-                        if (classEntry.isInDefaultPackage()) {
-                                map.put(classEntry, new ClassEntry(newPackageName + "/" + classEntry.getName()));
-                        }
+
+        public static void renameTypes(CtClass c, Map<ParameterizedType,ParameterizedType> map) {
+                
+                // convert the type map to a javassist class map
+                ClassMap nameMap = new ClassMap();
+                for (Map.Entry<ParameterizedType,ParameterizedType> entry : map.entrySet()) {
+                        String source = entry.getKey().toString();
+                        String dest = entry.getValue().toString();
+                        
+                        // don't forget to chop off the L ... ;
+                        // javassist doesn't want it there
+                        source = source.substring(1, source.length() - 1);
+                        dest = dest.substring(1, dest.length() - 1);
+                        
+                        nameMap.put(source, dest);
                 }
-                ClassRenamer.renameClasses(c, map);
-        }
-        
-        public static void moveAllClassesIntoDefaultPackage(CtClass c, String oldPackageName) {
-                Map<ClassEntry,ClassEntry> map = Maps.newHashMap();
-                for (ClassEntry classEntry : ClassRenamer.getAllClassEntries(c)) {
-                        if (classEntry.getPackageName().equals(oldPackageName)) {
-                                map.put(classEntry, new ClassEntry(classEntry.getSimpleName()));
+                
+                // replace!!
+                c.replaceClassName(nameMap);
+
+                // replace simple names in the InnerClasses attribute too
+                ConstPool constants = c.getClassFile().getConstPool();
+                InnerClassesAttribute attr = (InnerClassesAttribute)c.getClassFile().getAttribute(InnerClassesAttribute.tag);
+                if (attr != null) {
+                        for (int i = 0; i < attr.tableLength(); i++) {
+                                
+                                // get the inner class full name (which has already been translated)
+                                ClassEntry classEntry = new ClassEntry(Descriptor.toJvmName(attr.innerClass(i)));
+                                
+                                if (attr.innerNameIndex(i) != 0) {
+                                        // update the inner name
+                                        attr.setInnerNameIndex(i, constants.addUtf8Info(classEntry.getInnermostClassName()));
+                                }
+                                
+                                /* DEBUG
+                                System.out.println(String.format("\tDEOBF: %s-> ATTR: %s,%s,%s", classEntry, attr.outerClass(i), attr.innerClass(i), attr.innerName(i)));
+                                */
                         }
                 }
-                ClassRenamer.renameClasses(c, map);
         }
 }
diff --git a/src/cuchaz/enigma/bytecode/ClassTranslator.java b/src/cuchaz/enigma/bytecode/ClassTranslator.java
index 94ab2c4..7952577 100644
--- a/src/cuchaz/enigma/bytecode/ClassTranslator.java
+++ b/src/cuchaz/enigma/bytecode/ClassTranslator.java
@@ -10,8 +10,6 @@
  ******************************************************************************/
 package cuchaz.enigma.bytecode;
 
-import java.util.Map;
-
 import javassist.CtBehavior;
 import javassist.CtClass;
 import javassist.CtField;
@@ -19,9 +17,6 @@ import javassist.CtMethod;
 import javassist.bytecode.ConstPool;
 import javassist.bytecode.Descriptor;
 import javassist.bytecode.SourceFileAttribute;
-
-import com.google.common.collect.Maps;
-
 import cuchaz.enigma.mapping.BehaviorEntry;
 import cuchaz.enigma.mapping.ClassEntry;
 import cuchaz.enigma.mapping.EntryFactory;
@@ -50,20 +45,15 @@ public class ClassTranslator {
                                 
                                 case ConstPool.CONST_Fieldref: {
                                         
-                                        // translate the name
-                                        FieldEntry entry = new FieldEntry(
-                                                new ClassEntry(Descriptor.toJvmName(constants.getFieldrefClassName(i))),
+                                        // translate the name and type
+                                        FieldEntry entry = EntryFactory.getFieldEntry(
+                                                Descriptor.toJvmName(constants.getFieldrefClassName(i)),
                                                 constants.getFieldrefName(i),
-                                                new Type(constants.getFieldrefType(i))
+                                                constants.getFieldrefType(i)
                                         );
                                         FieldEntry translatedEntry = m_translator.translateEntry(entry);
-                                        
-                                        // translate the type
-                                        Type type = new Type(constants.getFieldrefType(i));
-                                        Type translatedType = m_translator.translateType(type);
-                                        
-                                        if (!entry.equals(translatedEntry) || !type.equals(translatedType)) {
-                                                editor.changeMemberrefNameAndType(i, translatedEntry.getName(), translatedType.toString());
+                                        if (!entry.equals(translatedEntry)) {
+                                                editor.changeMemberrefNameAndType(i, translatedEntry.getName(), translatedEntry.getType().toString());
                                         }
                                 }
                                 break;
@@ -71,15 +61,14 @@ public class ClassTranslator {
                                 case ConstPool.CONST_Methodref:
                                 case ConstPool.CONST_InterfaceMethodref: {
                                         
-                                        // translate the name and type
+                                        // translate the name and type (ie signature)
                                         BehaviorEntry entry = EntryFactory.getBehaviorEntry(
                                                 Descriptor.toJvmName(editor.getMemberrefClassname(i)),
                                                 editor.getMemberrefName(i),
                                                 editor.getMemberrefType(i)
                                         );
                                         BehaviorEntry translatedEntry = m_translator.translateEntry(entry);
-                                        
-                                        if (!entry.getName().equals(translatedEntry.getName()) || !entry.getSignature().equals(translatedEntry.getSignature())) {
+                                        if (!entry.equals(translatedEntry)) {
                                                 editor.changeMemberrefNameAndType(i, translatedEntry.getName(), translatedEntry.getSignature().toString());
                                         }
                                 }
@@ -120,25 +109,18 @@ public class ClassTranslator {
                         }
                         
                         if (entry.getSignature() != null) {
-                                // translate the type
+                                // translate the signature
                                 Signature translatedSignature = m_translator.translateSignature(entry.getSignature());
                                 behavior.getMethodInfo().setDescriptor(translatedSignature.toString());
                         }
                 }
                 
                 // translate all the class names referenced in the code
-                // the above code only changed method/field/reference names and types, but not the class names themselves
-                Map<ClassEntry,ClassEntry> map = Maps.newHashMap();
-                for (ClassEntry obfClassEntry : ClassRenamer.getAllClassEntries(c)) {
-                        ClassEntry deobfClassEntry = m_translator.translateEntry(obfClassEntry);
-                        if (!obfClassEntry.equals(deobfClassEntry)) {
-                                map.put(obfClassEntry, deobfClassEntry);
-                        }
-                }
-                ClassRenamer.renameClasses(c, map);
+                // the above code only changed method/field/reference names and types, but not the rest of the class references
+                ClassRenamer.renameClasses(c, m_translator);
                 
                 // translate the source file attribute too
-                ClassEntry deobfClassEntry = map.get(classEntry);
+                ClassEntry deobfClassEntry = m_translator.translateEntry(classEntry);
                 if (deobfClassEntry != null) {
                         String sourceFile = Descriptor.toJvmName(deobfClassEntry.getOutermostClassName()) + ".java";
                         c.getClassFile().addAttribute(new SourceFileAttribute(constants, sourceFile));