11 files changed, 552 insertions, 160 deletions

diff --git a/src/cuchaz/enigma/ConvertMain.java b/src/cuchaz/enigma/ConvertMain.java
index e012f197..c3a2ad5c 100644
--- a/src/cuchaz/enigma/ConvertMain.java
+++ b/src/cuchaz/enigma/ConvertMain.java
@@ -7,12 +7,14 @@ import java.io.IOException;
 import java.util.jar.JarFile;
 
 import cuchaz.enigma.convert.ClassMatches;
-import cuchaz.enigma.convert.FieldMatches;
 import cuchaz.enigma.convert.MappingsConverter;
 import cuchaz.enigma.convert.MatchesReader;
 import cuchaz.enigma.convert.MatchesWriter;
+import cuchaz.enigma.convert.MemberMatches;
 import cuchaz.enigma.gui.ClassMatchingGui;
-import cuchaz.enigma.gui.FieldMatchingGui;
+import cuchaz.enigma.gui.MemberMatchingGui;
+import cuchaz.enigma.mapping.BehaviorEntry;
+import cuchaz.enigma.mapping.FieldEntry;
 import cuchaz.enigma.mapping.MappingParseException;
 import cuchaz.enigma.mapping.Mappings;
 import cuchaz.enigma.mapping.MappingsChecker;
@@ -34,13 +36,21 @@ public class ConvertMain {
                 Mappings mappings = new MappingsReader().read(new FileReader(inMappingsFile));
                 File classMatchesFile = new File(inMappingsFile.getName() + ".class.matches");
                 File fieldMatchesFile = new File(inMappingsFile.getName() + ".field.matches");
+                File methodMatchesFile = new File(inMappingsFile.getName() + ".method.matches");
 
+                // match classes
                 //computeClassMatches(classMatchesFile, sourceJar, destJar, mappings);
-                editClasssMatches(classMatchesFile, sourceJar, destJar, mappings);
+                //editClasssMatches(classMatchesFile, sourceJar, destJar, mappings);
                 //convertMappings(outMappingsFile, sourceJar, destJar, mappings, classMatchesFile);
+                
+                // match fields
                 //computeFieldMatches(fieldMatchesFile, destJar, outMappingsFile, classMatchesFile);
                 //editFieldMatches(sourceJar, destJar, outMappingsFile, mappings, classMatchesFile, fieldMatchesFile);
                 
+                // match methods/constructors
+                //computeMethodMatches(methodMatchesFile, destJar, outMappingsFile, classMatchesFile);
+                editMethodMatches(sourceJar, destJar, outMappingsFile, mappings, classMatchesFile, methodMatchesFile);
+                
                 /* TODO
                 // write out the converted mappings
                 FileWriter writer = new FileWriter(outMappingsFile);
@@ -91,7 +101,7 @@ public class ConvertMain {
                 System.out.println("Write converted mappings to: " + outMappingsFile.getAbsolutePath());
         }
         
-        private static void computeFieldMatches(File fieldMatchesFile, JarFile destJar, File destMappingsFile, File classMatchesFile)
+        private static void computeFieldMatches(File memberMatchesFile, JarFile destJar, File destMappingsFile, File classMatchesFile)
         throws IOException, MappingParseException {
                 
                 System.out.println("Reading class matches...");
@@ -101,13 +111,13 @@ public class ConvertMain {
                 System.out.println("Indexing dest jar...");
                 Deobfuscator destDeobfuscator = new Deobfuscator(destJar);
                 
-                System.out.println("Writing field matches...");
+                System.out.println("Writing matches...");
                 
-                // get the matched and unmatched field mappings
-                FieldMatches fieldMatches = MappingsConverter.computeFieldMatches(destDeobfuscator, destMappings, classMatches);
+                // get the matched and unmatched mappings
+                MemberMatches<FieldEntry> fieldMatches = MappingsConverter.computeFieldMatches(destDeobfuscator, destMappings, classMatches);
                 
-                MatchesWriter.writeFields(fieldMatches, fieldMatchesFile);
-                System.out.println("Wrote:\n\t" + fieldMatchesFile.getAbsolutePath());
+                MatchesWriter.writeMembers(fieldMatches, memberMatchesFile);
+                System.out.println("Wrote:\n\t" + memberMatchesFile.getAbsolutePath());
         }
         
         private static void editFieldMatches(JarFile sourceJar, JarFile destJar, File destMappingsFile, Mappings sourceMappings, File classMatchesFile, final File fieldMatchesFile)
@@ -115,7 +125,7 @@ public class ConvertMain {
                 
                 System.out.println("Reading matches...");
                 ClassMatches classMatches = MatchesReader.readClasses(classMatchesFile);
-                FieldMatches fieldMatches = MatchesReader.readFields(fieldMatchesFile);
+                MemberMatches<FieldEntry> fieldMatches = MatchesReader.readMembers(fieldMatchesFile);
                 
                 // prep deobfuscators
                 Deobfuscators deobfuscators = new Deobfuscators(sourceJar, destJar);
@@ -125,18 +135,64 @@ public class ConvertMain {
                 checker.dropBrokenMappings(destMappings);
                 deobfuscators.dest.setMappings(destMappings);
                 
-                new FieldMatchingGui(classMatches, fieldMatches, deobfuscators.source, deobfuscators.dest).setSaveListener(new FieldMatchingGui.SaveListener() {
+                new MemberMatchingGui<FieldEntry>(classMatches, fieldMatches, deobfuscators.source, deobfuscators.dest).setSaveListener(new MemberMatchingGui.SaveListener<FieldEntry>() {
                         @Override
-                        public void save(FieldMatches matches) {
+                        public void save(MemberMatches<FieldEntry> matches) {
                                 try {
-                                        MatchesWriter.writeFields(matches, fieldMatchesFile);
+                                        MatchesWriter.writeMembers(matches, fieldMatchesFile);
                                 } catch (IOException ex) {
                                         throw new Error(ex);
                                 }
                         }
                 });
         }
+
+        private static void computeMethodMatches(File methodMatchesFile, JarFile destJar, File destMappingsFile, File classMatchesFile)
+        throws IOException, MappingParseException {
+                
+                System.out.println("Reading class matches...");
+                ClassMatches classMatches = MatchesReader.readClasses(classMatchesFile);
+                System.out.println("Reading mappings...");
+                Mappings destMappings = new MappingsReader().read(new FileReader(destMappingsFile));
+                System.out.println("Indexing dest jar...");
+                Deobfuscator destDeobfuscator = new Deobfuscator(destJar);
+                
+                System.out.println("Writing method matches...");
+                
+                // get the matched and unmatched mappings
+                MemberMatches<BehaviorEntry> methodMatches = MappingsConverter.computeBehaviorMatches(destDeobfuscator, destMappings, classMatches);
+                
+                MatchesWriter.writeMembers(methodMatches, methodMatchesFile);
+                System.out.println("Wrote:\n\t" + methodMatchesFile.getAbsolutePath());
+        }
         
+        private static void editMethodMatches(JarFile sourceJar, JarFile destJar, File destMappingsFile, Mappings sourceMappings, File classMatchesFile, final File methodMatchesFile)
+        throws IOException, MappingParseException {
+                
+                System.out.println("Reading matches...");
+                ClassMatches classMatches = MatchesReader.readClasses(classMatchesFile);
+                MemberMatches<BehaviorEntry> methodMatches = MatchesReader.readMembers(methodMatchesFile);
+                
+                // prep deobfuscators
+                Deobfuscators deobfuscators = new Deobfuscators(sourceJar, destJar);
+                deobfuscators.source.setMappings(sourceMappings);
+                Mappings destMappings = new MappingsReader().read(new FileReader(destMappingsFile));
+                MappingsChecker checker = new MappingsChecker(deobfuscators.dest.getJarIndex());
+                checker.dropBrokenMappings(destMappings);
+                deobfuscators.dest.setMappings(destMappings);
+                
+                new MemberMatchingGui<BehaviorEntry>(classMatches, methodMatches, deobfuscators.source, deobfuscators.dest).setSaveListener(new MemberMatchingGui.SaveListener<BehaviorEntry>() {
+                        @Override
+                        public void save(MemberMatches<BehaviorEntry> matches) {
+                                try {
+                                        MatchesWriter.writeMembers(matches, methodMatchesFile);
+                                } catch (IOException ex) {
+                                        throw new Error(ex);
+                                }
+                        }
+                });
+        }
+
         private static class Deobfuscators {
                 
                 public Deobfuscator source;
diff --git a/src/cuchaz/enigma/convert/MappingsConverter.java b/src/cuchaz/enigma/convert/MappingsConverter.java
index 9ab1baa3..2987ea08 100644
--- a/src/cuchaz/enigma/convert/MappingsConverter.java
+++ b/src/cuchaz/enigma/convert/MappingsConverter.java
@@ -11,12 +11,12 @@
 package cuchaz.enigma.convert;
 
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.Map.Entry;
 import java.util.Set;
 import java.util.jar.JarFile;
 
@@ -30,15 +30,20 @@ import com.google.common.collect.Sets;
 import cuchaz.enigma.Deobfuscator;
 import cuchaz.enigma.analysis.JarIndex;
 import cuchaz.enigma.convert.ClassNamer.SidedClassNamer;
+import cuchaz.enigma.mapping.BehaviorEntry;
 import cuchaz.enigma.mapping.ClassEntry;
 import cuchaz.enigma.mapping.ClassMapping;
 import cuchaz.enigma.mapping.ClassNameReplacer;
-import cuchaz.enigma.mapping.EntryFactory;
+import cuchaz.enigma.mapping.ConstructorEntry;
+import cuchaz.enigma.mapping.Entry;
 import cuchaz.enigma.mapping.FieldEntry;
 import cuchaz.enigma.mapping.FieldMapping;
 import cuchaz.enigma.mapping.Mappings;
 import cuchaz.enigma.mapping.MappingsChecker;
+import cuchaz.enigma.mapping.MemberMapping;
+import cuchaz.enigma.mapping.MethodEntry;
 import cuchaz.enigma.mapping.MethodMapping;
+import cuchaz.enigma.mapping.Signature;
 import cuchaz.enigma.mapping.Type;
 
 public class MappingsConverter {
@@ -124,8 +129,8 @@ public class MappingsConverter {
         public static Mappings newMappings(ClassMatches matches, Mappings oldMappings, Deobfuscator sourceDeobfuscator, Deobfuscator destDeobfuscator) {
                 
                 // sort the unique matches by size of inner class chain
-                Multimap<Integer,Entry<ClassEntry,ClassEntry>> matchesByDestChainSize = HashMultimap.create();
-                for (Entry<ClassEntry,ClassEntry> match : matches.getUniqueMatches().entrySet()) {
+                Multimap<Integer,java.util.Map.Entry<ClassEntry,ClassEntry>> matchesByDestChainSize = HashMultimap.create();
+                for (java.util.Map.Entry<ClassEntry,ClassEntry> match : matches.getUniqueMatches().entrySet()) {
                         int chainSize = destDeobfuscator.getJarIndex().getObfClassChain(match.getValue()).size();
                         matchesByDestChainSize.put(chainSize, match);
                 }
@@ -135,7 +140,7 @@ public class MappingsConverter {
                 List<Integer> chainSizes = Lists.newArrayList(matchesByDestChainSize.keySet());
                 Collections.sort(chainSizes);
                 for (int chainSize : chainSizes) {
-                        for (Entry<ClassEntry,ClassEntry> match : matchesByDestChainSize.get(chainSize)) {
+                        for (java.util.Map.Entry<ClassEntry,ClassEntry> match : matchesByDestChainSize.get(chainSize)) {
                                 
                                 // get class info
                                 ClassEntry obfSourceClassEntry = match.getKey();
@@ -251,89 +256,172 @@ public class MappingsConverter {
                         mappings.renameObfClass(entry.getKey().getName(), entry.getValue().getName());
                 }
         }
+        
+        public static interface Doer<T extends Entry> {
+                Collection<T> getDroppedEntries(MappingsChecker checker);
+                Collection<T> getObfEntries(JarIndex jarIndex);
+                Collection<? extends MemberMapping<T>> getMappings(ClassMapping destClassMapping);
+                Set<T> filterEntries(Collection<T> obfEntries, T obfSourceEntry, ClassMatches classMatches);
+        }
+        
+        public static MemberMatches<FieldEntry> computeFieldMatches(Deobfuscator destDeobfuscator, Mappings destMappings, ClassMatches classMatches) {
+                return computeMemberMatches(destDeobfuscator, destMappings, classMatches, new Doer<FieldEntry>() {
+
+                        @Override
+                        public Collection<FieldEntry> getDroppedEntries(MappingsChecker checker) {
+                                return checker.getDroppedFieldMappings().keySet();
+                        }
+
+                        @Override
+                        public Collection<FieldEntry> getObfEntries(JarIndex jarIndex) {
+                                return jarIndex.getObfFieldEntries();
+                        }
+
+                        @Override
+                        public Collection<? extends MemberMapping<FieldEntry>> getMappings(ClassMapping destClassMapping) {
+                                return (Collection<? extends MemberMapping<FieldEntry>>)destClassMapping.fields();
+                        }
+
+                        @Override
+                        public Set<FieldEntry> filterEntries(Collection<FieldEntry> obfDestFields, FieldEntry obfSourceField, ClassMatches classMatches) {
+                                Set<FieldEntry> out = Sets.newHashSet();
+                                for (FieldEntry obfDestField : obfDestFields) {
+                                        Type translatedDestType = translate(obfDestField.getType(), classMatches.getUniqueMatches().inverse());
+                                        if (translatedDestType.equals(obfSourceField.getType())) {
+                                                out.add(obfDestField);
+                                        }
+                                }
+                                return out;
+                        }
+                });
+        }
+        
+        public static MemberMatches<BehaviorEntry> computeBehaviorMatches(Deobfuscator destDeobfuscator, Mappings destMappings, ClassMatches classMatches) {
+                return computeMemberMatches(destDeobfuscator, destMappings, classMatches, new Doer<BehaviorEntry>() {
+
+                        @Override
+                        public Collection<BehaviorEntry> getDroppedEntries(MappingsChecker checker) {
+                                return checker.getDroppedMethodMappings().keySet();
+                        }
+
+                        @Override
+                        public Collection<BehaviorEntry> getObfEntries(JarIndex jarIndex) {
+                                return jarIndex.getObfBehaviorEntries();
+                        }
 
-        public static FieldMatches computeFieldMatches(Deobfuscator destDeobfuscator, Mappings destMappings, ClassMatches classMatches) {
+                        @Override
+                        public Collection<? extends MemberMapping<BehaviorEntry>> getMappings(ClassMapping destClassMapping) {
+                                return (Collection<? extends MemberMapping<BehaviorEntry>>)destClassMapping.methods();
+                        }
+
+                        @Override
+                        public Set<BehaviorEntry> filterEntries(Collection<BehaviorEntry> obfDestFields, BehaviorEntry obfSourceField, ClassMatches classMatches) {
+                                Set<BehaviorEntry> out = Sets.newHashSet();
+                                for (BehaviorEntry obfDestField : obfDestFields) {
+                                        Signature translatedDestSignature = translate(obfDestField.getSignature(), classMatches.getUniqueMatches().inverse());
+                                        if (translatedDestSignature == null && obfSourceField.getSignature() == null) {
+                                                out.add(obfDestField);
+                                        } else if (translatedDestSignature == null || obfSourceField.getSignature() == null) {
+                                                // skip it
+                                        } else if (translatedDestSignature.equals(obfSourceField.getSignature())) {
+                                                out.add(obfDestField);
+                                        }
+                                }
+                                return out;
+                        }
+                });
+        }
+        
+        public static <T extends Entry> MemberMatches<T> computeMemberMatches(Deobfuscator destDeobfuscator, Mappings destMappings, ClassMatches classMatches, Doer<T> doer) {
                 
-                FieldMatches fieldMatches = new FieldMatches();
+                MemberMatches<T> memberMatches = new MemberMatches<T>();
                 
                 // unmatched source fields are easy
                 MappingsChecker checker = new MappingsChecker(destDeobfuscator.getJarIndex());
                 checker.dropBrokenMappings(destMappings);
-                for (FieldEntry destObfField : checker.getDroppedFieldMappings().keySet()) {
-                        FieldEntry srcObfField = translate(destObfField, classMatches.getUniqueMatches().inverse());
-                        fieldMatches.addUnmatchedSourceField(srcObfField);
+                for (T destObfEntry : doer.getDroppedEntries(checker)) {
+                        T srcObfEntry = translate(destObfEntry, classMatches.getUniqueMatches().inverse());
+                        memberMatches.addUnmatchedSourceEntry(srcObfEntry);
                 }
                 
                 // get matched fields (anything that's left after the checks/drops is matched(
                 for (ClassMapping classMapping : destMappings.classes()) {
-                        collectMatchedFields(fieldMatches, classMapping, classMatches);
+                        collectMatchedFields(memberMatches, classMapping, classMatches, doer);
                 }
                 
                 // get unmatched dest fields
-                for (FieldEntry destFieldEntry : destDeobfuscator.getJarIndex().getObfFieldEntries()) {
-                        if (!fieldMatches.isMatchedDestField(destFieldEntry)) {
-                                fieldMatches.addUnmatchedDestField(destFieldEntry);
+                for (T destEntry : doer.getObfEntries(destDeobfuscator.getJarIndex())) {
+                        if (!memberMatches.isMatchedDestEntry(destEntry)) {
+                                memberMatches.addUnmatchedDestEntry(destEntry);
                         }
                 }
 
-                System.out.println("Automatching " + fieldMatches.getUnmatchedSourceFields().size() + " unmatched source fields...");
+                System.out.println("Automatching " + memberMatches.getUnmatchedSourceEntries().size() + " unmatched source entries...");
                 
                 // go through the unmatched source fields and try to pick out the easy matches
-                for (ClassEntry obfSourceClass : Lists.newArrayList(fieldMatches.getSourceClassesWithUnmatchedFields())) {
-                        for (FieldEntry obfSourceField : Lists.newArrayList(fieldMatches.getUnmatchedSourceFields(obfSourceClass))) {
+                for (ClassEntry obfSourceClass : Lists.newArrayList(memberMatches.getSourceClassesWithUnmatchedEntries())) {
+                        for (T obfSourceEntry : Lists.newArrayList(memberMatches.getUnmatchedSourceEntries(obfSourceClass))) {
                                 
                                 // get the possible dest matches
                                 ClassEntry obfDestClass = classMatches.getUniqueMatches().get(obfSourceClass);
                                 
-                                // filter by type
-                                Set<FieldEntry> obfDestFields = Sets.newHashSet();
-                                for (FieldEntry obfDestField : fieldMatches.getUnmatchedDestFields(obfDestClass)) {
-                                        Type translatedDestType = translate(obfDestField.getType(), classMatches.getUniqueMatches().inverse());
-                                        if (translatedDestType.equals(obfSourceField.getType())) {
-                                                obfDestFields.add(obfDestField);
-                                        }
-                                }
+                                // filter by type/signature
+                                Set<T> obfDestEntries = doer.filterEntries(memberMatches.getUnmatchedDestEntries(obfDestClass), obfSourceEntry, classMatches);
                                 
-                                if (obfDestFields.size() == 1) {
+                                if (obfDestEntries.size() == 1) {
                                         // make the easy match
-                                        FieldEntry obfDestField = obfDestFields.iterator().next();
-                                        fieldMatches.makeMatch(obfSourceField, obfDestField);
-                                } else if (obfDestFields.isEmpty()) {
+                                        memberMatches.makeMatch(obfSourceEntry, obfDestEntries.iterator().next());
+                                } else if (obfDestEntries.isEmpty()) {
                                         // no match is possible =(
-                                        fieldMatches.makeSourceUnmatchable(obfSourceField);
+                                        memberMatches.makeSourceUnmatchable(obfSourceEntry);
                                 }
                         }
                 }
                 
-                System.out.println(String.format("Ended up with %d ambiguous and %d unmatchable source fields",
-                        fieldMatches.getUnmatchedSourceFields().size(),
-                        fieldMatches.getUnmatchableSourceFields().size()
+                System.out.println(String.format("Ended up with %d ambiguous and %d unmatchable source entries",
+                        memberMatches.getUnmatchedSourceEntries().size(),
+                        memberMatches.getUnmatchableSourceEntries().size()
                 ));
                 
-                return fieldMatches;
+                return memberMatches;
         }
         
-        private static void collectMatchedFields(FieldMatches fieldMatches, ClassMapping destClassMapping, ClassMatches classMatches) {
+        private static <T extends Entry> void collectMatchedFields(MemberMatches<T> memberMatches, ClassMapping destClassMapping, ClassMatches classMatches, Doer<T> doer) {
                 
                 // get the fields for this class
-                for (FieldMapping destFieldMapping : destClassMapping.fields()) {
-                        FieldEntry destObfField = EntryFactory.getObfFieldEntry(destClassMapping, destFieldMapping);
-                        FieldEntry srcObfField = translate(destObfField, classMatches.getUniqueMatches().inverse());
-                        fieldMatches.addMatch(srcObfField, destObfField);
+                for (MemberMapping<T> destEntryMapping : doer.getMappings(destClassMapping)) {
+                        T destObfField = destEntryMapping.getObfEntry(destClassMapping.getObfEntry());
+                        T srcObfField = translate(destObfField, classMatches.getUniqueMatches().inverse());
+                        memberMatches.addMatch(srcObfField, destObfField);
                 }
                 
                 // recurse
                 for (ClassMapping destInnerClassMapping : destClassMapping.innerClasses()) {
-                        collectMatchedFields(fieldMatches, destInnerClassMapping, classMatches);
+                        collectMatchedFields(memberMatches, destInnerClassMapping, classMatches, doer);
                 }
         }
 
-        private static FieldEntry translate(FieldEntry in, BiMap<ClassEntry,ClassEntry> map) {
-                return new FieldEntry(
-                        map.get(in.getClassEntry()),
-                        in.getName(),
-                        translate(in.getType(), map)
-                );
+        @SuppressWarnings("unchecked")
+        private static <T extends Entry> T translate(T in, BiMap<ClassEntry,ClassEntry> map) {
+                if (in instanceof FieldEntry) {
+                        return (T)new FieldEntry(
+                                map.get(in.getClassEntry()),
+                                in.getName(),
+                                translate(((FieldEntry)in).getType(), map)
+                        );
+                } else if (in instanceof MethodEntry) {
+                        return (T)new MethodEntry(
+                                map.get(in.getClassEntry()),
+                                in.getName(),
+                                translate(((MethodEntry)in).getSignature(), map)
+                        );
+                } else if (in instanceof ConstructorEntry) {
+                        return (T)new ConstructorEntry(
+                                map.get(in.getClassEntry()),
+                                translate(((ConstructorEntry)in).getSignature(), map)
+                        );
+                }
+                throw new Error("Unhandled entry type: " + in.getClass());
         }
 
         private static Type translate(Type type, final BiMap<ClassEntry,ClassEntry> map) {
@@ -348,4 +436,20 @@ public class MappingsConverter {
                         }
                 });
         }
+        
+        private static Signature translate(Signature signature, final BiMap<ClassEntry,ClassEntry> map) {
+                if (signature == null) {
+                        return null;
+                }
+                return new Signature(signature, new ClassNameReplacer() {
+                        @Override
+                        public String replace(String inClassName) {
+                                ClassEntry outClassEntry = map.get(new ClassEntry(inClassName));
+                                if (outClassEntry == null) {
+                                        return null;
+                                }
+                                return outClassEntry.getName();
+                        }
+                });
+        }
 }
diff --git a/src/cuchaz/enigma/convert/MatchesReader.java b/src/cuchaz/enigma/convert/MatchesReader.java
index 921ab1d0..dac2f057 100644
--- a/src/cuchaz/enigma/convert/MatchesReader.java
+++ b/src/cuchaz/enigma/convert/MatchesReader.java
@@ -10,6 +10,8 @@ import java.util.List;
 import com.beust.jcommander.internal.Lists;
 
 import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.Entry;
+import cuchaz.enigma.mapping.EntryFactory;
 import cuchaz.enigma.mapping.FieldEntry;
 import cuchaz.enigma.mapping.Type;
 
@@ -45,45 +47,57 @@ public class MatchesReader {
                 return entries;
         }
 
-        public static FieldMatches readFields(File file)
+        public static <T extends Entry> MemberMatches<T> readMembers(File file)
         throws IOException {
                 try (BufferedReader in = new BufferedReader(new FileReader(file))) {
-                        FieldMatches matches = new FieldMatches();
+                        MemberMatches<T> matches = new MemberMatches<T>();
                         String line = null;
                         while ((line = in.readLine()) != null) {
-                                readFieldMatch(matches, line);
+                                readMemberMatch(matches, line);
                         }
                         return matches;
                 }
         }
 
-        private static void readFieldMatch(FieldMatches matches, String line) {
+        private static <T extends Entry> void readMemberMatch(MemberMatches<T> matches, String line) {
                 if (line.startsWith("!")) {
-                        matches.addUnmatchableSourceField(readField(line.substring(1)));
+                        T source = readEntry(line.substring(1));
+                        matches.addUnmatchableSourceEntry(source);
                 } else {
                         String[] parts = line.split(":", 2);
-                        FieldEntry source = readField(parts[0]);
-                        FieldEntry dest = readField(parts[1]);
+                        T source = readEntry(parts[0]);
+                        T dest = readEntry(parts[1]);
                         if (source != null && dest != null) {
                                 matches.addMatch(source, dest);
                         } else if (source != null) {
-                                matches.addUnmatchedSourceField(source);
+                                matches.addUnmatchedSourceEntry(source);
                         } else if (dest != null) {
-                                matches.addUnmatchedDestField(dest);
+                                matches.addUnmatchedDestEntry(dest);
                         }
                 }
         }
 
-        private static FieldEntry readField(String in) {
+        @SuppressWarnings("unchecked")
+        private static <T extends Entry> T readEntry(String in) {
                 if (in.length() <= 0) {
                         return null;
                 }
                 String[] parts = in.split(" ");
-                assert(parts.length == 3);
-                return new FieldEntry(
-                        new ClassEntry(parts[0]),
-                        parts[1],
-                        new Type(parts[2])
-                );
+                if (parts.length == 3 && parts[2].indexOf('(') < 0) {
+                        return (T)new FieldEntry(
+                                new ClassEntry(parts[0]),
+                                parts[1],
+                                new Type(parts[2])
+                        );
+                } else {
+                        assert(parts.length == 2 || parts.length == 3);
+                        if (parts.length == 2) {
+                                return (T)EntryFactory.getBehaviorEntry(parts[0], parts[1]);
+                        } else if (parts.length == 3) {
+                                return (T)EntryFactory.getBehaviorEntry(parts[0], parts[1], parts[2]);
+                        } else {
+                                throw new Error("Malformed behavior entry: " + in);
+                        }
+                }
         }
 }
diff --git a/src/cuchaz/enigma/convert/MatchesWriter.java b/src/cuchaz/enigma/convert/MatchesWriter.java
index 2118dd08..9e9ead02 100644
--- a/src/cuchaz/enigma/convert/MatchesWriter.java
+++ b/src/cuchaz/enigma/convert/MatchesWriter.java
@@ -5,7 +5,9 @@ import java.io.FileWriter;
 import java.io.IOException;
 import java.util.Map;
 
+import cuchaz.enigma.mapping.BehaviorEntry;
 import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.Entry;
 import cuchaz.enigma.mapping.FieldEntry;
 
 
@@ -41,43 +43,52 @@ public class MatchesWriter {
                 }
         }
 
-        public static void writeFields(FieldMatches fieldMatches, File file)
+        public static <T extends Entry> void writeMembers(MemberMatches<T> matches, File file)
         throws IOException {
                 try (FileWriter out = new FileWriter(file)) {
-                        for (Map.Entry<FieldEntry,FieldEntry> match : fieldMatches.matches().entrySet()) {
-                                writeFieldMatch(out, match.getKey(), match.getValue());
+                        for (Map.Entry<T,T> match : matches.matches().entrySet()) {
+                                writeMemberMatch(out, match.getKey(), match.getValue());
                         }
-                        for (FieldEntry fieldEntry : fieldMatches.getUnmatchedSourceFields()) {
-                                writeFieldMatch(out, fieldEntry, null);
+                        for (T entry : matches.getUnmatchedSourceEntries()) {
+                                writeMemberMatch(out, entry, null);
                         }
-                        for (FieldEntry fieldEntry : fieldMatches.getUnmatchedDestFields()) {
-                                writeFieldMatch(out, null, fieldEntry);
+                        for (T entry : matches.getUnmatchedDestEntries()) {
+                                writeMemberMatch(out, null, entry);
                         }
-                        for (FieldEntry fieldEntry : fieldMatches.getUnmatchableSourceFields()) {
-                                writeUnmatchableField(out, fieldEntry);
+                        for (T entry : matches.getUnmatchableSourceEntries()) {
+                                writeUnmatchableEntry(out, entry);
                         }
                 }
         }
 
-        private static void writeFieldMatch(FileWriter out, FieldEntry source, FieldEntry dest)
+        private static <T extends Entry> void writeMemberMatch(FileWriter out, T source, T dest)
         throws IOException {
                 if (source != null) {
-                        writeField(out, source);
+                        writeEntry(out, source);
                 }
                 out.write(":");
                 if (dest != null) {
-                        writeField(out, dest);
+                        writeEntry(out, dest);
                 }
                 out.write("\n");
         }
         
-        private static void writeUnmatchableField(FileWriter out, FieldEntry fieldEntry)
+        private static <T extends Entry> void writeUnmatchableEntry(FileWriter out, T entry)
         throws IOException {
                 out.write("!");
-                writeField(out, fieldEntry);
+                writeEntry(out, entry);
                 out.write("\n");
         }
         
+        private static <T extends Entry> void writeEntry(FileWriter out, T entry)
+        throws IOException {
+                if (entry instanceof FieldEntry) {
+                        writeField(out, (FieldEntry)entry);
+                } else if (entry instanceof BehaviorEntry) {
+                        writeBehavior(out, (BehaviorEntry)entry);
+                }
+        }
+        
         private static void writeField(FileWriter out, FieldEntry fieldEntry)
         throws IOException {
                 out.write(fieldEntry.getClassName());
@@ -86,4 +97,15 @@ public class MatchesWriter {
                 out.write(" ");
                 out.write(fieldEntry.getType().toString());
         }
+        
+        private static void writeBehavior(FileWriter out, BehaviorEntry behaviorEntry)
+        throws IOException {
+                out.write(behaviorEntry.getClassName());
+                out.write(" ");
+                out.write(behaviorEntry.getName());
+                out.write(" ");
+                if (behaviorEntry.getSignature() != null) {
+                        out.write(behaviorEntry.getSignature().toString());
+                }
+        }
 }
diff --git a/src/cuchaz/enigma/convert/MemberMatches.java b/src/cuchaz/enigma/convert/MemberMatches.java
new file mode 100644
index 00000000..1078ab75
--- /dev/null
+++ b/src/cuchaz/enigma/convert/MemberMatches.java
@@ -0,0 +1,145 @@
+package cuchaz.enigma.convert;
+
+import java.util.Collection;
+import java.util.Set;
+
+import com.google.common.collect.BiMap;
+import com.google.common.collect.HashBiMap;
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Sets;
+
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.Entry;
+
+
+public class MemberMatches<T extends Entry> {
+
+        private BiMap<T,T> m_matches;
+        private Multimap<ClassEntry,T> m_matchedSourceEntries;
+        private Multimap<ClassEntry,T> m_unmatchedSourceEntries;
+        private Multimap<ClassEntry,T> m_unmatchedDestEntries;
+        private Multimap<ClassEntry,T> m_unmatchableSourceEntries;
+        
+        public MemberMatches() {
+                m_matches = HashBiMap.create();
+                m_matchedSourceEntries = HashMultimap.create();
+                m_unmatchedSourceEntries = HashMultimap.create();
+                m_unmatchedDestEntries = HashMultimap.create();
+                m_unmatchableSourceEntries = HashMultimap.create();
+        }
+        
+        public void addMatch(T srcEntry, T destEntry) {
+                boolean wasAdded = m_matches.put(srcEntry, destEntry) == null;
+                assert (wasAdded);
+                wasAdded = m_matchedSourceEntries.put(srcEntry.getClassEntry(), srcEntry);
+                assert (wasAdded);
+        }
+        
+        public void addUnmatchedSourceEntry(T sourceEntry) {
+                boolean wasAdded = m_unmatchedSourceEntries.put(sourceEntry.getClassEntry(), sourceEntry);
+                assert (wasAdded);
+        }
+        
+        public void addUnmatchedSourceEntries(Iterable<T> sourceEntries) {
+                for (T sourceEntry : sourceEntries) {
+                        addUnmatchedSourceEntry(sourceEntry);
+                }
+        }
+        
+        public void addUnmatchedDestEntry(T destEntry) {
+                boolean wasAdded = m_unmatchedDestEntries.put(destEntry.getClassEntry(), destEntry);
+                assert (wasAdded);
+        }
+        
+        public void addUnmatchedDestEntries(Iterable<T> destEntriesntries) {
+                for (T entry : destEntriesntries) {
+                        addUnmatchedDestEntry(entry);
+                }
+        }
+        
+        public void addUnmatchableSourceEntry(T sourceEntry) {
+                boolean wasAdded = m_unmatchableSourceEntries.put(sourceEntry.getClassEntry(), sourceEntry);
+                assert (wasAdded);
+        }
+        
+        public Set<ClassEntry> getSourceClassesWithUnmatchedEntries() {
+                return m_unmatchedSourceEntries.keySet();
+        }
+        
+        public Collection<ClassEntry> getSourceClassesWithoutUnmatchedEntries() {
+                Set<ClassEntry> out = Sets.newHashSet();
+                out.addAll(m_matchedSourceEntries.keySet());
+                out.removeAll(m_unmatchedSourceEntries.keySet());
+                return out;
+        }
+
+        public Collection<T> getUnmatchedSourceEntries() {
+                return m_unmatchedSourceEntries.values();
+        }
+
+        public Collection<T> getUnmatchedSourceEntries(ClassEntry sourceClass) {
+                return m_unmatchedSourceEntries.get(sourceClass);
+        }
+
+        public Collection<T> getUnmatchedDestEntries() {
+                return m_unmatchedDestEntries.values();
+        }
+
+        public Collection<T> getUnmatchedDestEntries(ClassEntry destClass) {
+                return m_unmatchedDestEntries.get(destClass);
+        }
+        
+        public Collection<T> getUnmatchableSourceEntries() {
+                return m_unmatchableSourceEntries.values();
+        }
+
+        public boolean hasSource(T sourceEntry) {
+                return m_matches.containsKey(sourceEntry) || m_unmatchedSourceEntries.containsValue(sourceEntry);
+        }
+        
+        public boolean hasDest(T destEntry) {
+                return m_matches.containsValue(destEntry) || m_unmatchedDestEntries.containsValue(destEntry);
+        }
+
+        public BiMap<T,T> matches() {
+                return m_matches;
+        }
+        
+        public boolean isMatchedSourceEntry(T sourceEntry) {
+                return m_matches.containsKey(sourceEntry);
+        }
+
+        public boolean isMatchedDestEntry(T destEntry) {
+                return m_matches.containsValue(destEntry);
+        }
+
+        public void makeMatch(T sourceEntry, T destEntry) {
+                boolean wasRemoved = m_unmatchedSourceEntries.remove(sourceEntry.getClassEntry(), sourceEntry);
+                assert (wasRemoved);
+                wasRemoved = m_unmatchedDestEntries.remove(destEntry.getClassEntry(), destEntry);
+                assert (wasRemoved);
+                addMatch(sourceEntry, destEntry);
+        }
+
+        public boolean isMatched(T sourceEntry, T destEntry) {
+                T match = m_matches.get(sourceEntry);
+                return match != null && match.equals(destEntry);
+        }
+
+        public void unmakeMatch(T sourceEntry, T destEntry) {
+                boolean wasRemoved = m_matches.remove(sourceEntry) != null;
+                assert (wasRemoved);
+                wasRemoved = m_matchedSourceEntries.remove(sourceEntry.getClassEntry(), sourceEntry);
+                assert (wasRemoved);
+                addUnmatchedSourceEntry(sourceEntry);
+                addUnmatchedDestEntry(destEntry);
+        }
+        
+        public void makeSourceUnmatchable(T sourceEntry) {
+                assert(!isMatchedSourceEntry(sourceEntry));
+                boolean wasRemoved = m_unmatchedSourceEntries.remove(sourceEntry.getClassEntry(), sourceEntry);
+                assert (wasRemoved);
+                addUnmatchableSourceEntry(sourceEntry);
+        }
+}
diff --git a/src/cuchaz/enigma/gui/FieldMatchingGui.java b/src/cuchaz/enigma/gui/MemberMatchingGui.java
index 3f4a378c..52545b33 100644
--- a/src/cuchaz/enigma/gui/FieldMatchingGui.java
+++ b/src/cuchaz/enigma/gui/MemberMatchingGui.java
@@ -33,29 +33,28 @@ import cuchaz.enigma.analysis.EntryReference;
 import cuchaz.enigma.analysis.SourceIndex;
 import cuchaz.enigma.analysis.Token;
 import cuchaz.enigma.convert.ClassMatches;
-import cuchaz.enigma.convert.FieldMatches;
+import cuchaz.enigma.convert.MemberMatches;
 import cuchaz.enigma.gui.ClassSelector.ClassSelectionListener;
 import cuchaz.enigma.mapping.ClassEntry;
 import cuchaz.enigma.mapping.Entry;
-import cuchaz.enigma.mapping.FieldEntry;
 import de.sciss.syntaxpane.DefaultSyntaxKit;
 
 
-public class FieldMatchingGui {
+public class MemberMatchingGui<T extends Entry> {
         
         private static enum SourceType {
                 Matched {
                         
                         @Override
-                        public Collection<ClassEntry> getObfSourceClasses(FieldMatches matches) {
-                                return matches.getSourceClassesWithoutUnmatchedFields();
+                        public <T extends Entry> Collection<ClassEntry> getObfSourceClasses(MemberMatches<T> matches) {
+                                return matches.getSourceClassesWithoutUnmatchedEntries();
                         }
                 },
                 Unmatched {
                         
                         @Override
-                        public Collection<ClassEntry> getObfSourceClasses(FieldMatches matches) {
-                                return matches.getSourceClassesWithUnmatchedFields();
+                        public <T extends Entry> Collection<ClassEntry> getObfSourceClasses(MemberMatches<T> matches) {
+                                return matches.getSourceClassesWithUnmatchedEntries();
                         }
                 };
                 
@@ -67,15 +66,15 @@ public class FieldMatchingGui {
                         return button;
                 }
                 
-                public abstract Collection<ClassEntry> getObfSourceClasses(FieldMatches matches);
+                public abstract <T extends Entry> Collection<ClassEntry> getObfSourceClasses(MemberMatches<T> matches);
                 
                 public static SourceType getDefault() {
                         return values()[0];
                 }
         }
         
-        public static interface SaveListener {
-                public void save(FieldMatches matches);
+        public static interface SaveListener<T extends Entry> {
+                public void save(MemberMatches<T> matches);
         }
         
         // controls
@@ -92,25 +91,25 @@ public class FieldMatchingGui {
         private HighlightPainter m_matchedHighlightPainter;
 
         private ClassMatches m_classMatches;
-        private FieldMatches m_fieldMatches;
+        private MemberMatches<T> m_memberMatches;
         private Deobfuscator m_sourceDeobfuscator;
         private Deobfuscator m_destDeobfuscator;
-        private SaveListener m_saveListener;
+        private SaveListener<T> m_saveListener;
         private SourceType m_sourceType;
         private ClassEntry m_obfSourceClass;
         private ClassEntry m_obfDestClass;
-        private FieldEntry m_obfSourceField;
-        private FieldEntry m_obfDestField;
+        private T m_obfSourceEntry;
+        private T m_obfDestEntry;
 
-        public FieldMatchingGui(ClassMatches classMatches, FieldMatches fieldMatches, Deobfuscator sourceDeobfuscator, Deobfuscator destDeobfuscator) {
+        public MemberMatchingGui(ClassMatches classMatches, MemberMatches<T> fieldMatches, Deobfuscator sourceDeobfuscator, Deobfuscator destDeobfuscator) {
                 
                 m_classMatches = classMatches;
-                m_fieldMatches = fieldMatches;
+                m_memberMatches = fieldMatches;
                 m_sourceDeobfuscator = sourceDeobfuscator;
                 m_destDeobfuscator = destDeobfuscator;
                 
                 // init frame
-                m_frame = new JFrame(Constants.Name + " - Field Matcher");
+                m_frame = new JFrame(Constants.Name + " - Member Matcher");
                 final Container pane = m_frame.getContentPane();
                 pane.setLayout(new BorderLayout());
                 
@@ -225,8 +224,8 @@ public class FieldMatchingGui {
                 m_saveListener = null;
                 m_obfSourceClass = null;
                 m_obfDestClass = null;
-                m_obfSourceField = null;
-                m_obfDestField = null;
+                m_obfSourceEntry = null;
+                m_obfDestEntry = null;
                 setSourceType(SourceType.getDefault());
                 updateButtons();
         }
@@ -236,7 +235,7 @@ public class FieldMatchingGui {
                 updateSourceClasses();
         }
 
-        public void setSaveListener(SaveListener val) {
+        public void setSaveListener(SaveListener<T> val) {
                 m_saveListener = val;
         }
         
@@ -245,7 +244,7 @@ public class FieldMatchingGui {
                 String selectedPackage = m_sourceClasses.getSelectedPackage();
                 
                 List<ClassEntry> deobfClassEntries = Lists.newArrayList();
-                for (ClassEntry entry : m_sourceType.getObfSourceClasses(m_fieldMatches)) {
+                for (ClassEntry entry : m_sourceType.getObfSourceClasses(m_memberMatches)) {
                         deobfClassEntries.add(m_sourceDeobfuscator.deobfuscateEntry(entry));
                 }
                 m_sourceClasses.setClasses(deobfClassEntries);
@@ -256,7 +255,7 @@ public class FieldMatchingGui {
                 
                 for (SourceType sourceType : SourceType.values()) {
                         m_sourceTypeButtons.get(sourceType).setText(String.format("%s (%d)",
-                                sourceType.name(), sourceType.getObfSourceClasses(m_fieldMatches).size()
+                                sourceType.name(), sourceType.getObfSourceClasses(m_memberMatches).size()
                         ));
                 }
         }
@@ -284,30 +283,30 @@ public class FieldMatchingGui {
         }
         
         protected void updateSourceHighlights() {
-                highlightFields(m_sourceReader, m_sourceDeobfuscator, m_fieldMatches.matches().keySet(), m_fieldMatches.getUnmatchedSourceFields());
+                highlightEntries(m_sourceReader, m_sourceDeobfuscator, m_memberMatches.matches().keySet(), m_memberMatches.getUnmatchedSourceEntries());
         }
 
         protected void updateDestHighlights() {
-                highlightFields(m_destReader, m_destDeobfuscator, m_fieldMatches.matches().values(), m_fieldMatches.getUnmatchedDestFields());
+                highlightEntries(m_destReader, m_destDeobfuscator, m_memberMatches.matches().values(), m_memberMatches.getUnmatchedDestEntries());
         }
         
-        private void highlightFields(CodeReader reader, Deobfuscator deobfuscator, Collection<FieldEntry> obfMatchedFields, Collection<FieldEntry> obfUnmatchedFields) {
+        private void highlightEntries(CodeReader reader, Deobfuscator deobfuscator, Collection<T> obfMatchedEntries, Collection<T> obfUnmatchedEntries) {
                 reader.clearHighlights();
                 SourceIndex index = reader.getSourceIndex();
                 
                 // matched fields
-                for (FieldEntry obfFieldEntry : obfMatchedFields) {
-                        FieldEntry deobfFieldEntry = deobfuscator.deobfuscateEntry(obfFieldEntry);
-                        Token token = index.getDeclarationToken(deobfFieldEntry);
+                for (T obfT : obfMatchedEntries) {
+                        T deobfT = deobfuscator.deobfuscateEntry(obfT);
+                        Token token = index.getDeclarationToken(deobfT);
                         if (token != null) {
                                 reader.setHighlightedToken(token, m_matchedHighlightPainter);
                         }
                 }
                 
                 // unmatched fields
-                for (FieldEntry obfFieldEntry : obfUnmatchedFields) {
-                        FieldEntry deobfFieldEntry = deobfuscator.deobfuscateEntry(obfFieldEntry);
-                        Token token = index.getDeclarationToken(deobfFieldEntry);
+                for (T obfT : obfUnmatchedEntries) {
+                        T deobfT = deobfuscator.deobfuscateEntry(obfT);
+                        Token token = index.getDeclarationToken(deobfT);
                         if (token != null) {
                                 reader.setHighlightedToken(token, m_unmatchedHighlightPainter);
                         }
@@ -315,8 +314,8 @@ public class FieldMatchingGui {
         }
         
         private boolean isSelectionMatched() {
-                return m_obfSourceField != null && m_obfDestField != null
-                        && m_fieldMatches.isMatched(m_obfSourceField, m_obfDestField);
+                return m_obfSourceEntry != null && m_obfDestEntry != null
+                        && m_memberMatches.isMatched(m_obfSourceEntry, m_obfDestEntry);
         }
         
         protected void onSelectSource(Entry source) {
@@ -328,16 +327,22 @@ public class FieldMatchingGui {
                 setSource(null);
                 
                 // then look for a valid source selection
-                if (source != null && source instanceof FieldEntry) {
-                        FieldEntry sourceField = (FieldEntry)source;
-                        FieldEntry obfSourceField = m_sourceDeobfuscator.obfuscateEntry(sourceField);
-                        if (m_fieldMatches.hasSource(obfSourceField)) {
-                                setSource(obfSourceField);
+                if (source != null) {
+                        
+                        // this looks really scary, but it's actually ok
+                        // Deobfuscator.obfuscateEntry can handle all implementations of Entry
+                        // and MemberMatches.hasSource() will only pass entries that actually match T
+                        @SuppressWarnings("unchecked")
+                        T sourceEntry = (T)source;
+
+                        T obfSourceEntry = m_sourceDeobfuscator.obfuscateEntry(sourceEntry);
+                        if (m_memberMatches.hasSource(obfSourceEntry)) {
+                                setSource(obfSourceEntry);
                                 
                                 // look for a matched dest too
-                                FieldEntry obfDestField = m_fieldMatches.matches().get(obfSourceField);
-                                if (obfDestField != null) {
-                                        setDest(obfDestField);
+                                T obfDestEntry = m_memberMatches.matches().get(obfSourceEntry);
+                                if (obfDestEntry != null) {
+                                        setDest(obfDestEntry);
                                 }
                         }
                 }
@@ -354,16 +359,22 @@ public class FieldMatchingGui {
                 setDest(null);
 
                 // then look for a valid dest selection
-                if (dest != null && dest instanceof FieldEntry) {
-                        FieldEntry destField = (FieldEntry)dest;
-                        FieldEntry obfDestField = m_destDeobfuscator.obfuscateEntry(destField);
-                        if (m_fieldMatches.hasDest(obfDestField)) {
-                                setDest(obfDestField);
+                if (dest != null) {
+                        
+                        // this looks really scary, but it's actually ok
+                        // Deobfuscator.obfuscateEntry can handle all implementations of Entry
+                        // and MemberMatches.hasSource() will only pass entries that actually match T
+                        @SuppressWarnings("unchecked")
+                        T destEntry = (T)dest;
+                        
+                        T obfDestEntry = m_destDeobfuscator.obfuscateEntry(destEntry);
+                        if (m_memberMatches.hasDest(obfDestEntry)) {
+                                setDest(obfDestEntry);
 
                                 // look for a matched source too
-                                FieldEntry obfSourceField = m_fieldMatches.matches().inverse().get(obfDestField);
-                                if (obfSourceField != null) {
-                                        setSource(obfSourceField);
+                                T obfSourceEntry = m_memberMatches.matches().inverse().get(obfDestEntry);
+                                if (obfSourceEntry != null) {
+                                        setSource(obfSourceEntry);
                                 }
                         }
                 }
@@ -371,42 +382,46 @@ public class FieldMatchingGui {
                 updateButtons();
         }
         
-        private void setSource(FieldEntry obfField) {
-                if (obfField == null) {
-                        m_obfSourceField = obfField;
+        private void setSource(T obfEntry) {
+                if (obfEntry == null) {
+                        m_obfSourceEntry = obfEntry;
                         m_sourceLabel.setText("");
                 } else {
-                        m_obfSourceField = obfField;
-                        FieldEntry deobfField = m_sourceDeobfuscator.deobfuscateEntry(obfField);
-                        m_sourceLabel.setText(deobfField.getName() + " " + deobfField.getType().toString());
+                        m_obfSourceEntry = obfEntry;
+                        m_sourceLabel.setText(getEntryLabel(obfEntry, m_sourceDeobfuscator));
                 }
         }
         
-        private void setDest(FieldEntry obfField) {
-                if (obfField == null) {
-                        m_obfDestField = obfField;
+        private void setDest(T obfEntry) {
+                if (obfEntry == null) {
+                        m_obfDestEntry = obfEntry;
                         m_destLabel.setText("");
                 } else {
-                        m_obfDestField = obfField;
-                        FieldEntry deobfField = m_destDeobfuscator.deobfuscateEntry(obfField);
-                        m_destLabel.setText(deobfField.getName() + " " + deobfField.getType().toString());
+                        m_obfDestEntry = obfEntry;
+                        m_destLabel.setText(getEntryLabel(obfEntry, m_destDeobfuscator));
                 }
         }
 
+        private String getEntryLabel(T obfEntry, Deobfuscator deobfuscator) {
+                // deobfuscate, then take off the class name
+                T deobfEntry = deobfuscator.deobfuscateEntry(obfEntry);
+                return deobfEntry.toString().substring(deobfEntry.getClassName().length() + 1);
+        }
+
         private void updateButtons() {
                 
                 GuiTricks.deactivateButton(m_matchButton);
                 GuiTricks.deactivateButton(m_unmatchableButton);
                 
-                if (m_obfSourceField != null && m_obfDestField != null) {
-                        if (m_fieldMatches.isMatched(m_obfSourceField, m_obfDestField)) {
+                if (m_obfSourceEntry != null && m_obfDestEntry != null) {
+                        if (m_memberMatches.isMatched(m_obfSourceEntry, m_obfDestEntry)) {
                                 GuiTricks.activateButton(m_matchButton, "Unmatch", new ActionListener() {
                                         @Override
                                         public void actionPerformed(ActionEvent event) {
                                                 unmatch();
                                         }
                                 });
-                        } else if (!m_fieldMatches.isMatchedSourceField(m_obfSourceField) && !m_fieldMatches.isMatchedDestField(m_obfDestField)) {
+                        } else if (!m_memberMatches.isMatchedSourceEntry(m_obfSourceEntry) && !m_memberMatches.isMatchedDestEntry(m_obfDestEntry)) {
                                 GuiTricks.activateButton(m_matchButton, "Match", new ActionListener() {
                                         @Override
                                         public void actionPerformed(ActionEvent event) {
@@ -414,7 +429,7 @@ public class FieldMatchingGui {
                                         }
                                 });
                         }
-                } else if (m_obfSourceField != null) {
+                } else if (m_obfSourceEntry != null) {
                         GuiTricks.activateButton(m_unmatchableButton, "Set Unmatchable", new ActionListener() {
                                 @Override
                                 public void actionPerformed(ActionEvent event) {
@@ -427,7 +442,7 @@ public class FieldMatchingGui {
         protected void match() {
                 
                 // update the field matches
-                m_fieldMatches.makeMatch(m_obfSourceField, m_obfDestField);
+                m_memberMatches.makeMatch(m_obfSourceEntry, m_obfDestEntry);
                 save();
 
                 // update the ui
@@ -441,7 +456,7 @@ public class FieldMatchingGui {
         protected void unmatch() {
                 
                 // update the field matches
-                m_fieldMatches.unmakeMatch(m_obfSourceField, m_obfDestField);
+                m_memberMatches.unmakeMatch(m_obfSourceEntry, m_obfDestEntry);
                 save();
 
                 // update the ui
@@ -455,7 +470,7 @@ public class FieldMatchingGui {
         protected void unmatchable() {
                 
                 // update the field matches
-                m_fieldMatches.makeSourceUnmatchable(m_obfSourceField);
+                m_memberMatches.makeSourceUnmatchable(m_obfSourceEntry);
                 save();
                 
                 // update the ui
@@ -468,7 +483,7 @@ public class FieldMatchingGui {
 
         private void save() {
                 if (m_saveListener != null) {
-                        m_saveListener.save(m_fieldMatches);
+                        m_saveListener.save(m_memberMatches);
                 }
         }
 }
diff --git a/src/cuchaz/enigma/mapping/ClassMapping.java b/src/cuchaz/enigma/mapping/ClassMapping.java
index 43605e59..07fed32a 100644
--- a/src/cuchaz/enigma/mapping/ClassMapping.java
+++ b/src/cuchaz/enigma/mapping/ClassMapping.java
@@ -434,4 +434,8 @@ public class ClassMapping implements Serializable, Comparable<ClassMapping> {
         public static boolean isSimpleClassName(String name) {
                 return name.indexOf('/') < 0 && name.indexOf('$') < 0;
         }
+
+        public ClassEntry getObfEntry() {
+                return new ClassEntry(m_obfFullName);
+        }
 }
diff --git a/src/cuchaz/enigma/mapping/EntryFactory.java b/src/cuchaz/enigma/mapping/EntryFactory.java
index 333bb09b..7bc61839 100644
--- a/src/cuchaz/enigma/mapping/EntryFactory.java
+++ b/src/cuchaz/enigma/mapping/EntryFactory.java
@@ -138,6 +138,10 @@ public class EntryFactory {
         public static BehaviorEntry getBehaviorEntry(String className, String behaviorName, String behaviorSignature) {
                 return getBehaviorEntry(new ClassEntry(className), behaviorName, new Signature(behaviorSignature));
         }
+
+        public static BehaviorEntry getBehaviorEntry(String className, String behaviorName) {
+                return getBehaviorEntry(new ClassEntry(className), behaviorName);
+        }
         
         public static BehaviorEntry getBehaviorEntry(ClassEntry classEntry, String behaviorName, Signature behaviorSignature) {
                 if (behaviorName.equals("<init>")) {
@@ -149,6 +153,14 @@ public class EntryFactory {
                 }
         }
         
+        public static BehaviorEntry getBehaviorEntry(ClassEntry classEntry, String behaviorName) {
+                if(behaviorName.equals("<clinit>")) {
+                        return new ConstructorEntry(classEntry);
+                } else {
+                        throw new IllegalArgumentException("Only class initializers don't have signatures");
+                }
+        }
+        
         public static BehaviorEntry getBehaviorEntry(MethodDefinition def) {
                 if (def.isConstructor() || def.isTypeInitializer()) {
                         return getConstructorEntry(def);
diff --git a/src/cuchaz/enigma/mapping/FieldMapping.java b/src/cuchaz/enigma/mapping/FieldMapping.java
index 55b0a195..1289351d 100644
--- a/src/cuchaz/enigma/mapping/FieldMapping.java
+++ b/src/cuchaz/enigma/mapping/FieldMapping.java
@@ -12,7 +12,7 @@ package cuchaz.enigma.mapping;
 
 import java.io.Serializable;
 
-public class FieldMapping implements Serializable, Comparable<FieldMapping> {
+public class FieldMapping implements Serializable, Comparable<FieldMapping>, MemberMapping<FieldEntry> {
         
         private static final long serialVersionUID = 8610742471440861315L;
         
@@ -72,4 +72,9 @@ public class FieldMapping implements Serializable, Comparable<FieldMapping> {
                 }
                 return false;
         }
+
+        @Override
+        public FieldEntry getObfEntry(ClassEntry classEntry) {
+                return new FieldEntry(classEntry, m_obfName, new Type(m_obfType));
+        }
 }
diff --git a/src/cuchaz/enigma/mapping/MemberMapping.java b/src/cuchaz/enigma/mapping/MemberMapping.java
new file mode 100644
index 00000000..d62a7c10
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/MemberMapping.java
@@ -0,0 +1,6 @@
+package cuchaz.enigma.mapping;
+
+
+public interface MemberMapping<T extends Entry> {
+        T getObfEntry(ClassEntry classEntry);
+}
diff --git a/src/cuchaz/enigma/mapping/MethodMapping.java b/src/cuchaz/enigma/mapping/MethodMapping.java
index bf8a94f3..bf6dacca 100644
--- a/src/cuchaz/enigma/mapping/MethodMapping.java
+++ b/src/cuchaz/enigma/mapping/MethodMapping.java
@@ -16,7 +16,7 @@ import java.util.Map.Entry;
 
 import com.google.common.collect.Maps;
 
-public class MethodMapping implements Serializable, Comparable<MethodMapping> {
+public class MethodMapping implements Serializable, Comparable<MethodMapping>, MemberMapping<BehaviorEntry> {
         
         private static final long serialVersionUID = -4409570216084263978L;
         
@@ -170,4 +170,13 @@ public class MethodMapping implements Serializable, Comparable<MethodMapping> {
                 }
                 return false;
         }
+
+        @Override
+        public BehaviorEntry getObfEntry(ClassEntry classEntry) {
+                if (isConstructor()) {
+                        return new ConstructorEntry(classEntry, m_obfSignature);
+                } else {
+                        return new MethodEntry(classEntry, m_obfName, m_obfSignature);
+                }
+        }
 }