started adding minimal support for generics

fixed mark-as-deobfuscated issue

1 files changed, 112 insertions, 52 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);
         }
 }