switch all classes to new signature/type system

1 files changed, 406 insertions, 0 deletions

diff --git a/src/cuchaz/enigma/convert/ClassMatcher.java b/src/cuchaz/enigma/convert/ClassMatcher.java
new file mode 100644
index 0000000..ccf6b78
--- /dev/null
+++ b/src/cuchaz/enigma/convert/ClassMatcher.java
@@ -0,0 +1,406 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.convert;
+
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.jar.JarFile;
+
+import javassist.CtBehavior;
+import javassist.CtClass;
+
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.BiMap;
+import com.google.common.collect.HashBiMap;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Sets;
+
+import cuchaz.enigma.TranslatingTypeLoader;
+import cuchaz.enigma.analysis.JarIndex;
+import cuchaz.enigma.convert.ClassNamer.SidedClassNamer;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.ClassMapping;
+import cuchaz.enigma.mapping.JavassistUtil;
+import cuchaz.enigma.mapping.MappingParseException;
+import cuchaz.enigma.mapping.Mappings;
+import cuchaz.enigma.mapping.MappingsReader;
+import cuchaz.enigma.mapping.MappingsWriter;
+import cuchaz.enigma.mapping.MethodEntry;
+import cuchaz.enigma.mapping.MethodMapping;
+
+public class ClassMatcher {
+        
+        public static void main(String[] args) throws IOException, MappingParseException {
+                // TEMP
+                JarFile sourceJar = new JarFile(new File("input/1.8-pre3.jar"));
+                JarFile destJar = new JarFile(new File("input/1.8.jar"));
+                File inMappingsFile = new File("../Enigma Mappings/1.8-pre3.mappings");
+                File outMappingsFile = new File("../Enigma Mappings/1.8.mappings");
+                
+                // define a matching to use when the automated system cannot find a match
+                Map<String,String> fallbackMatching = Maps.newHashMap();
+                fallbackMatching.put("none/ayb", "none/ayf");
+                fallbackMatching.put("none/ayd", "none/ayd");
+                fallbackMatching.put("none/bgk", "unknown/bgk");
+                
+                // do the conversion
+                Mappings mappings = new MappingsReader().read(new FileReader(inMappingsFile));
+                convertMappings(sourceJar, destJar, mappings, fallbackMatching);
+                
+                // write out the converted mappings
+                FileWriter writer = new FileWriter(outMappingsFile);
+                new MappingsWriter().write(writer, mappings);
+                writer.close();
+                System.out.println("Wrote converted mappings to:\n\t" + outMappingsFile.getAbsolutePath());
+        }
+        
+        private static void convertMappings(JarFile sourceJar, JarFile destJar, Mappings mappings, Map<String,String> fallbackMatching) {
+                // index jars
+                System.out.println("Indexing source jar...");
+                JarIndex sourceIndex = new JarIndex();
+                sourceIndex.indexJar(sourceJar, false);
+                System.out.println("Indexing dest jar...");
+                JarIndex destIndex = new JarIndex();
+                destIndex.indexJar(destJar, false);
+                TranslatingTypeLoader sourceLoader = new TranslatingTypeLoader(sourceJar, sourceIndex);
+                TranslatingTypeLoader destLoader = new TranslatingTypeLoader(destJar, destIndex);
+                
+                // compute the matching
+                ClassMatching matching = computeMatching(sourceIndex, sourceLoader, destIndex, destLoader);
+                Map<String,Map.Entry<ClassIdentity,List<ClassIdentity>>> matchingIndex = matching.getIndex();
+                
+                // get all the obf class names used in the mappings
+                Set<String> usedClassNames = mappings.getAllObfClassNames();
+                Set<String> allClassNames = Sets.newHashSet();
+                for (ClassEntry classEntry : sourceIndex.getObfClassEntries()) {
+                        allClassNames.add(classEntry.getName());
+                }
+                usedClassNames.retainAll(allClassNames);
+                System.out.println("Used " + usedClassNames.size() + " classes in the mappings");
+                
+                // probabilistically match the non-uniquely-matched source classes
+                for (Map.Entry<ClassIdentity,List<ClassIdentity>> entry : matchingIndex.values()) {
+                        ClassIdentity sourceClass = entry.getKey();
+                        List<ClassIdentity> destClasses = entry.getValue();
+                        
+                        // skip classes that are uniquely matched
+                        if (destClasses.size() == 1) {
+                                continue;
+                        }
+                        
+                        // skip classes that aren't used in the mappings
+                        if (!usedClassNames.contains(sourceClass.getClassEntry().getName())) {
+                                continue;
+                        }
+                        
+                        System.out.println("No exact match for source class " + sourceClass.getClassEntry());
+                        
+                        // find the closest classes
+                        Multimap<Integer,ClassIdentity> scoredMatches = ArrayListMultimap.create();
+                        for (ClassIdentity c : destClasses) {
+                                scoredMatches.put(sourceClass.getMatchScore(c), c);
+                        }
+                        List<Integer> scores = new ArrayList<Integer>(scoredMatches.keySet());
+                        Collections.sort(scores, Collections.reverseOrder());
+                        printScoredMatches(sourceClass.getMaxMatchScore(), scores, scoredMatches);
+                        
+                        // does the best match have a non-zero score and the same name?
+                        int bestScore = scores.get(0);
+                        Collection<ClassIdentity> bestMatches = scoredMatches.get(bestScore);
+                        if (bestScore > 0 && bestMatches.size() == 1) {
+                                ClassIdentity bestMatch = bestMatches.iterator().next();
+                                if (bestMatch.getClassEntry().equals(sourceClass.getClassEntry())) {
+                                        // use it
+                                        System.out.println("\tAutomatically choosing likely match: " + bestMatch.getClassEntry().getName());
+                                        destClasses.clear();
+                                        destClasses.add(bestMatch);
+                                }
+                        }
+                }
+                
+                // group the matching into unique and non-unique matches
+                BiMap<String,String> matchedClassNames = HashBiMap.create();
+                Set<String> unmatchedSourceClassNames = Sets.newHashSet();
+                for (String className : usedClassNames) {
+                        // is there a match for this class?
+                        Map.Entry<ClassIdentity,List<ClassIdentity>> entry = matchingIndex.get(className);
+                        ClassIdentity sourceClass = entry.getKey();
+                        List<ClassIdentity> matches = entry.getValue();
+                        
+                        if (matches.size() == 1) {
+                                // unique match! We're good to go!
+                                matchedClassNames.put(sourceClass.getClassEntry().getName(), matches.get(0).getClassEntry().getName());
+                        } else {
+                                // no match, check the fallback matching
+                                String fallbackMatch = fallbackMatching.get(className);
+                                if (fallbackMatch != null) {
+                                        matchedClassNames.put(sourceClass.getClassEntry().getName(), fallbackMatch);
+                                } else {
+                                        unmatchedSourceClassNames.add(className);
+                                }
+                        }
+                }
+                
+                // report unmatched classes
+                if (!unmatchedSourceClassNames.isEmpty()) {
+                        System.err.println("ERROR: there were unmatched classes!");
+                        for (String className : unmatchedSourceClassNames) {
+                                System.err.println("\t" + className);
+                        }
+                        return;
+                }
+                
+                // get the class name changes from the matched class names
+                Map<String,String> classChanges = Maps.newHashMap();
+                for (Map.Entry<String,String> entry : matchedClassNames.entrySet()) {
+                        if (!entry.getKey().equals(entry.getValue())) {
+                                classChanges.put(entry.getKey(), entry.getValue());
+                                System.out.println(String.format("Class change: %s -> %s", entry.getKey(), entry.getValue()));
+                                /* DEBUG
+                                System.out.println(String.format("\n%s\n%s",
+                                        new ClassIdentity(sourceLoader.loadClass(entry.getKey()), null, sourceIndex, false, false),
+                                        new ClassIdentity( destLoader.loadClass(entry.getValue()), null, destIndex, false, false)
+                                ));
+                                */
+                        }
+                }
+                
+                // sort the changes so classes are renamed in the correct order
+                // ie. if we have the mappings a->b, b->c, we have to apply b->c before a->b
+                LinkedHashMap<String,String> orderedClassChanges = Maps.newLinkedHashMap();
+                int numChangesLeft = classChanges.size();
+                while (!classChanges.isEmpty()) {
+                        Iterator<Map.Entry<String,String>> iter = classChanges.entrySet().iterator();
+                        while (iter.hasNext()) {
+                                Map.Entry<String,String> entry = iter.next();
+                                if (classChanges.get(entry.getValue()) == null) {
+                                        orderedClassChanges.put(entry.getKey(), entry.getValue());
+                                        iter.remove();
+                                }
+                        }
+                        
+                        // did we remove any changes?
+                        if (numChangesLeft - classChanges.size() > 0) {
+                                // keep going
+                                numChangesLeft = classChanges.size();
+                        } else {
+                                // can't sort anymore. There must be a loop
+                                break;
+                        }
+                }
+                if (classChanges.size() > 0) {
+                        throw new Error(String.format("Unable to sort %d/%d class changes!", classChanges.size(), matchedClassNames.size()));
+                }
+                
+                // convert the mappings in the correct class order
+                for (Map.Entry<String,String> entry : orderedClassChanges.entrySet()) {
+                        mappings.renameObfClass(entry.getKey(), entry.getValue());
+                }
+                
+                // check the method matches
+                System.out.println("Checking methods...");
+                for (ClassMapping classMapping : mappings.classes()) {
+                        ClassEntry classEntry = new ClassEntry(classMapping.getObfName());
+                        for (MethodMapping methodMapping : classMapping.methods()) {
+                                
+                                // skip constructors
+                                if (methodMapping.getObfName().equals("<init>")) {
+                                        continue;
+                                }
+                                
+                                MethodEntry methodEntry = new MethodEntry(
+                                        classEntry,
+                                        methodMapping.getObfName(),
+                                        methodMapping.getObfSignature()
+                                );
+                                if (!destIndex.containsObfBehavior(methodEntry)) {
+                                        System.err.println("WARNING: method doesn't match: " + methodEntry);
+                                        
+                                        // show the available methods
+                                        System.err.println("\tAvailable dest methods:");
+                                        CtClass c = destLoader.loadClass(classMapping.getObfName());
+                                        for (CtBehavior behavior : c.getDeclaredBehaviors()) {
+                                                System.err.println("\t\t" + JavassistUtil.getBehaviorEntry(behavior));
+                                        }
+                                        
+                                        System.err.println("\tAvailable source methods:");
+                                        c = sourceLoader.loadClass(matchedClassNames.inverse().get(classMapping.getObfName()));
+                                        for (CtBehavior behavior : c.getDeclaredBehaviors()) {
+                                                System.err.println("\t\t" + JavassistUtil.getBehaviorEntry(behavior));
+                                        }
+                                }
+                        }
+                }
+                
+                System.out.println("Done!");
+        }
+        
+        public static ClassMatching computeMatching(JarIndex sourceIndex, TranslatingTypeLoader sourceLoader, JarIndex destIndex, TranslatingTypeLoader destLoader) {
+                
+                System.out.println("Matching classes...");
+                
+                ClassMatching matching = null;
+                for (boolean useReferences : Arrays.asList(false, true)) {
+                        int numMatches = 0;
+                        do {
+                                SidedClassNamer sourceNamer = null;
+                                SidedClassNamer destNamer = null;
+                                if (matching != null) {
+                                        // build a class namer
+                                        ClassNamer namer = new ClassNamer(matching.getUniqueMatches());
+                                        sourceNamer = namer.getSourceNamer();
+                                        destNamer = namer.getDestNamer();
+                                        
+                                        // note the number of matches
+                                        numMatches = matching.getUniqueMatches().size();
+                                }
+                                
+                                // get the entries left to match
+                                Set<ClassEntry> sourceClassEntries = Sets.newHashSet();
+                                Set<ClassEntry> destClassEntries = Sets.newHashSet();
+                                if (matching == null) {
+                                        sourceClassEntries.addAll(sourceIndex.getObfClassEntries());
+                                        destClassEntries.addAll(destIndex.getObfClassEntries());
+                                        matching = new ClassMatching();
+                                } else {
+                                        for (Map.Entry<List<ClassIdentity>,List<ClassIdentity>> entry : matching.getAmbiguousMatches().entrySet()) {
+                                                for (ClassIdentity c : entry.getKey()) {
+                                                        sourceClassEntries.add(c.getClassEntry());
+                                                        matching.removeSource(c);
+                                                }
+                                                for (ClassIdentity c : entry.getValue()) {
+                                                        destClassEntries.add(c.getClassEntry());
+                                                        matching.removeDest(c);
+                                                }
+                                        }
+                                        for (ClassIdentity c : matching.getUnmatchedSourceClasses()) {
+                                                sourceClassEntries.add(c.getClassEntry());
+                                                matching.removeSource(c);
+                                        }
+                                        for (ClassIdentity c : matching.getUnmatchedDestClasses()) {
+                                                destClassEntries.add(c.getClassEntry());
+                                                matching.removeDest(c);
+                                        }
+                                }
+                                
+                                // compute a matching for the classes
+                                for (ClassEntry classEntry : sourceClassEntries) {
+                                        CtClass c = sourceLoader.loadClass(classEntry.getName());
+                                        ClassIdentity sourceClass = new ClassIdentity(c, sourceNamer, sourceIndex, useReferences);
+                                        matching.addSource(sourceClass);
+                                }
+                                for (ClassEntry classEntry : destClassEntries) {
+                                        CtClass c = destLoader.loadClass(classEntry.getName());
+                                        ClassIdentity destClass = new ClassIdentity(c, destNamer, destIndex, useReferences);
+                                        matching.matchDestClass(destClass);
+                                }
+                                
+                                // TEMP
+                                System.out.println(matching);
+                        } while (matching.getUniqueMatches().size() - numMatches > 0);
+                }
+                
+                // check the class matches
+                System.out.println("Checking class matches...");
+                ClassNamer namer = new ClassNamer(matching.getUniqueMatches());
+                SidedClassNamer sourceNamer = namer.getSourceNamer();
+                SidedClassNamer destNamer = namer.getDestNamer();
+                for (Map.Entry<ClassIdentity,ClassIdentity> entry : matching.getUniqueMatches().entrySet()) {
+                        
+                        // check source
+                        ClassIdentity sourceClass = entry.getKey();
+                        CtClass sourceC = sourceLoader.loadClass(sourceClass.getClassEntry().getName());
+                        assert (sourceC != null) : "Unable to load source class " + sourceClass.getClassEntry();
+                        assert (sourceClass.matches(sourceC)) : "Source " + sourceClass + " doesn't match " + new ClassIdentity(sourceC, sourceNamer, sourceIndex, false);
+                        
+                        // check dest
+                        ClassIdentity destClass = entry.getValue();
+                        CtClass destC = destLoader.loadClass(destClass.getClassEntry().getName());
+                        assert (destC != null) : "Unable to load dest class " + destClass.getClassEntry();
+                        assert (destClass.matches(destC)) : "Dest " + destClass + " doesn't match " + new ClassIdentity(destC, destNamer, destIndex, false);
+                }
+                
+                // warn about the ambiguous matchings
+                List<Map.Entry<List<ClassIdentity>,List<ClassIdentity>>> ambiguousMatches = new ArrayList<Map.Entry<List<ClassIdentity>,List<ClassIdentity>>>(matching.getAmbiguousMatches().entrySet());
+                Collections.sort(ambiguousMatches, new Comparator<Map.Entry<List<ClassIdentity>,List<ClassIdentity>>>() {
+                        @Override
+                        public int compare(Map.Entry<List<ClassIdentity>,List<ClassIdentity>> a, Map.Entry<List<ClassIdentity>,List<ClassIdentity>> b) {
+                                String aName = a.getKey().get(0).getClassEntry().getName();
+                                String bName = b.getKey().get(0).getClassEntry().getName();
+                                return aName.compareTo(bName);
+                        }
+                });
+                for (Map.Entry<List<ClassIdentity>,List<ClassIdentity>> entry : ambiguousMatches) {
+                        System.out.println("Ambiguous matching:");
+                        System.out.println("\tSource: " + getClassNames(entry.getKey()));
+                        System.out.println("\tDest:   " + getClassNames(entry.getValue()));
+                }
+                
+                /* DEBUG
+                Map.Entry<List<ClassIdentity>,List<ClassIdentity>> entry = ambiguousMatches.get( 7 );
+                for (ClassIdentity c : entry.getKey()) {
+                        System.out.println(c);
+                }
+                for(ClassIdentity c : entry.getKey()) {
+                        System.out.println(decompile(sourceLoader, c.getClassEntry())); 
+                }
+                */
+                
+                return matching;
+        }
+        
+        private static void printScoredMatches(int maxScore, List<Integer> scores, Multimap<Integer,ClassIdentity> scoredMatches) {
+                int numScoredMatchesShown = 0;
+                for (int score : scores) {
+                        for (ClassIdentity scoredMatch : scoredMatches.get(score)) {
+                                System.out.println(String.format("\tScore: %3d %3.0f%%   %s", score, 100.0 * score / maxScore, scoredMatch.getClassEntry().getName()));
+                                if (numScoredMatchesShown++ > 10) {
+                                        return;
+                                }
+                        }
+                }
+        }
+        
+        private static List<String> getClassNames(Collection<ClassIdentity> classes) {
+                List<String> out = Lists.newArrayList();
+                for (ClassIdentity c : classes) {
+                        out.add(c.getClassEntry().getName());
+                }
+                Collections.sort(out);
+                return out;
+        }
+        
+        /* DEBUG
+        private static String decompile(TranslatingTypeLoader loader, ClassEntry classEntry) {
+                PlainTextOutput output = new PlainTextOutput();
+                DecompilerSettings settings = DecompilerSettings.javaDefaults();
+                settings.setForceExplicitImports(true);
+                settings.setShowSyntheticMembers(true);
+                settings.setTypeLoader(loader);
+                Decompiler.decompile(classEntry.getName(), output, settings);
+                return output.toString();
+        }
+        */
+}