add tracking for mismatched fields/methods

1 files changed, 97 insertions, 0 deletions

diff --git a/src/cuchaz/enigma/mapping/MappingsChecker.java b/src/cuchaz/enigma/mapping/MappingsChecker.java
new file mode 100644
index 0000000..c5ff7a7
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/MappingsChecker.java
@@ -0,0 +1,97 @@
+package cuchaz.enigma.mapping;
+
+import java.util.Map;
+
+import com.beust.jcommander.internal.Maps;
+import com.google.common.collect.Lists;
+
+import cuchaz.enigma.analysis.JarIndex;
+import cuchaz.enigma.analysis.RelatedMethodChecker;
+
+
+public class MappingsChecker {
+        
+        private JarIndex m_index;
+        private RelatedMethodChecker m_relatedMethodChecker;
+        private Map<ClassEntry,ClassMapping> m_droppedClassMappings;
+        private Map<ClassEntry,ClassMapping> m_droppedInnerClassMappings;
+        private Map<FieldEntry,FieldMapping> m_droppedFieldMappings;
+        private Map<BehaviorEntry,MethodMapping> m_droppedMethodMappings;
+        
+        public MappingsChecker(JarIndex index) {
+                m_index = index;
+                m_relatedMethodChecker = new RelatedMethodChecker(m_index);
+                m_droppedClassMappings = Maps.newHashMap();
+                m_droppedInnerClassMappings = Maps.newHashMap();
+                m_droppedFieldMappings = Maps.newHashMap();
+                m_droppedMethodMappings = Maps.newHashMap();
+        }
+        
+        public RelatedMethodChecker getRelatedMethodChecker() {
+                return m_relatedMethodChecker;
+        }
+        
+        public Map<ClassEntry,ClassMapping> getDroppedClassMappings() {
+                return m_droppedClassMappings;
+        }
+        
+        public Map<ClassEntry,ClassMapping> getDroppedInnerClassMappings() {
+                return m_droppedInnerClassMappings;
+        }
+        
+        public Map<FieldEntry,FieldMapping> getDroppedFieldMappings() {
+                return m_droppedFieldMappings;
+        }
+        
+        public Map<BehaviorEntry,MethodMapping> getDroppedMethodMappings() {
+                return m_droppedMethodMappings;
+        }
+        
+        public void dropBrokenMappings(Mappings mappings) {
+                for (ClassMapping classMapping : Lists.newArrayList(mappings.classes())) {
+                        if (!checkClassMapping(classMapping)) {
+                                mappings.removeClassMapping(classMapping);
+                                m_droppedClassMappings.put(EntryFactory.getObfClassEntry(m_index, classMapping), classMapping);
+                        }
+                }
+        }
+        
+        private boolean checkClassMapping(ClassMapping classMapping) {
+                
+                // check the class
+                ClassEntry classEntry = EntryFactory.getObfClassEntry(m_index, classMapping);
+                if (!m_index.getObfClassEntries().contains(classEntry)) {
+                        return false;
+                }
+                
+                // check the fields
+                for (FieldMapping fieldMapping : Lists.newArrayList(classMapping.fields())) {
+                        FieldEntry obfFieldEntry = new FieldEntry(classEntry, fieldMapping.getObfName(), fieldMapping.getObfType());
+                        if (!m_index.containsObfField(obfFieldEntry)) {
+                                classMapping.removeFieldMapping(fieldMapping);
+                                m_droppedFieldMappings.put(obfFieldEntry, fieldMapping);
+                        }
+                }
+                
+                // check methods
+                for (MethodMapping methodMapping : Lists.newArrayList(classMapping.methods())) {
+                        BehaviorEntry obfBehaviorEntry = EntryFactory.getObfBehaviorEntry(classEntry, methodMapping);
+                        if (!m_index.containsObfBehavior(obfBehaviorEntry)) {
+                                classMapping.removeMethodMapping(methodMapping);
+                                m_droppedMethodMappings.put(obfBehaviorEntry, methodMapping);
+                        }
+                        
+                        m_relatedMethodChecker.checkMethod(classEntry, methodMapping);
+                }
+                
+                // check inner classes
+                for (ClassMapping innerClassMapping : Lists.newArrayList(classMapping.innerClasses())) {
+                        if (!checkClassMapping(innerClassMapping)) {
+                                classMapping.removeInnerClassMapping(innerClassMapping);
+                                m_droppedInnerClassMappings.put(EntryFactory.getObfClassEntry(m_index, innerClassMapping), innerClassMapping);
+                        }
+                }
+                
+                return true;
+        }
+}