From 64c359d3c1d2347001e5c6becb1d7561457f52cc Mon Sep 17 00:00:00 2001 From: lclc98 Date: Sat, 2 Jul 2016 18:04:57 +1000 Subject: Renamed Fields --- src/main/java/cuchaz/enigma/analysis/JarIndex.java | 156 ++++++++++----------- 1 file changed, 78 insertions(+), 78 deletions(-) (limited to 'src/main/java/cuchaz/enigma/analysis/JarIndex.java') diff --git a/src/main/java/cuchaz/enigma/analysis/JarIndex.java b/src/main/java/cuchaz/enigma/analysis/JarIndex.java index 848d851..8b30f9e 100644 --- a/src/main/java/cuchaz/enigma/analysis/JarIndex.java +++ b/src/main/java/cuchaz/enigma/analysis/JarIndex.java @@ -26,32 +26,32 @@ import javassist.expr.*; public class JarIndex { - private Set m_obfClassEntries; - private TranslationIndex m_translationIndex; - private Map m_access; - private Multimap m_fields; - private Multimap m_behaviors; - private Multimap m_methodImplementations; - private Multimap> m_behaviorReferences; - private Multimap> m_fieldReferences; - private Multimap m_innerClassesByOuter; - private Map m_outerClassesByInner; - private Map m_anonymousClasses; - private Map m_bridgedMethods; + private Set obfClassEntries; + private TranslationIndex translationIndex; + private Map access; + private Multimap fields; + private Multimap behaviors; + private Multimap methodImplementations; + private Multimap> behaviorReferences; + private Multimap> fieldReferences; + private Multimap innerClassesByOuter; + private Map outerClassesByInner; + private Map anonymousClasses; + private Map bridgedMethods; public JarIndex() { - m_obfClassEntries = Sets.newHashSet(); - m_translationIndex = new TranslationIndex(); - m_access = Maps.newHashMap(); - m_fields = HashMultimap.create(); - m_behaviors = HashMultimap.create(); - m_methodImplementations = HashMultimap.create(); - m_behaviorReferences = HashMultimap.create(); - m_fieldReferences = HashMultimap.create(); - m_innerClassesByOuter = HashMultimap.create(); - m_outerClassesByInner = Maps.newHashMap(); - m_anonymousClasses = Maps.newHashMap(); - m_bridgedMethods = Maps.newHashMap(); + this.obfClassEntries = Sets.newHashSet(); + this.translationIndex = new TranslationIndex(); + this.access = Maps.newHashMap(); + this.fields = HashMultimap.create(); + this.behaviors = HashMultimap.create(); + this.methodImplementations = HashMultimap.create(); + this.behaviorReferences = HashMultimap.create(); + this.fieldReferences = HashMultimap.create(); + this.innerClassesByOuter = HashMultimap.create(); + this.outerClassesByInner = Maps.newHashMap(); + this.anonymousClasses = Maps.newHashMap(); + this.bridgedMethods = Maps.newHashMap(); } public void indexJar(JarFile jar, boolean buildInnerClasses) { @@ -62,7 +62,7 @@ public class JarIndex { // move out of default package classEntry = new ClassEntry(Constants.NonePackage + "/" + classEntry.getName()); } - m_obfClassEntries.add(classEntry); + this.obfClassEntries.add(classEntry); } // step 2: index field/method/constructor access @@ -70,20 +70,20 @@ public class JarIndex { ClassRenamer.moveAllClassesOutOfDefaultPackage(c, Constants.NonePackage); for (CtField field : c.getDeclaredFields()) { FieldEntry fieldEntry = EntryFactory.getFieldEntry(field); - m_access.put(fieldEntry, Access.get(field)); - m_fields.put(fieldEntry.getClassEntry(), fieldEntry); + this.access.put(fieldEntry, Access.get(field)); + this.fields.put(fieldEntry.getClassEntry(), fieldEntry); } for (CtBehavior behavior : c.getDeclaredBehaviors()) { BehaviorEntry behaviorEntry = EntryFactory.getBehaviorEntry(behavior); - m_access.put(behaviorEntry, Access.get(behavior)); - m_behaviors.put(behaviorEntry.getClassEntry(), behaviorEntry); + this.access.put(behaviorEntry, Access.get(behavior)); + this.behaviors.put(behaviorEntry.getClassEntry(), behaviorEntry); } } // step 3: index extends, implements, fields, and methods for (CtClass c : JarClassIterator.classes(jar)) { ClassRenamer.moveAllClassesOutOfDefaultPackage(c, Constants.NonePackage); - m_translationIndex.indexClass(c); + this.translationIndex.indexClass(c); String className = Descriptor.toJvmName(c.getName()); for (String interfaceName : c.getClassFile().getInterfaces()) { className = Descriptor.toJvmName(className); @@ -113,13 +113,13 @@ public class JarIndex { ClassEntry innerClassEntry = EntryFactory.getClassEntry(c); ClassEntry outerClassEntry = findOuterClass(c); if (outerClassEntry != null) { - m_innerClassesByOuter.put(outerClassEntry, innerClassEntry); - boolean innerWasAdded = m_outerClassesByInner.put(innerClassEntry, outerClassEntry) == null; + this.innerClassesByOuter.put(outerClassEntry, innerClassEntry); + boolean innerWasAdded = this.outerClassesByInner.put(innerClassEntry, outerClassEntry) == null; assert (innerWasAdded); BehaviorEntry enclosingBehavior = isAnonymousClass(c, outerClassEntry); if (enclosingBehavior != null) { - m_anonymousClasses.put(innerClassEntry, enclosingBehavior); + this.anonymousClasses.put(innerClassEntry, enclosingBehavior); // DEBUG //System.out.println("ANONYMOUS: " + outerClassEntry.getName() + "$" + innerClassEntry.getSimpleName()); @@ -132,7 +132,7 @@ public class JarIndex { // step 6: update other indices with inner class info Map renames = Maps.newHashMap(); - for (ClassEntry innerClassEntry : m_innerClassesByOuter.values()) { + for (ClassEntry innerClassEntry : this.innerClassesByOuter.values()) { String newName = innerClassEntry.buildClassEntry(getObfClassChain(innerClassEntry)).getName(); if (!innerClassEntry.getName().equals(newName)) { // DEBUG @@ -140,12 +140,12 @@ public class JarIndex { renames.put(innerClassEntry.getName(), newName); } } - EntryRenamer.renameClassesInSet(renames, m_obfClassEntries); - m_translationIndex.renameClasses(renames); - EntryRenamer.renameClassesInMultimap(renames, m_methodImplementations); - EntryRenamer.renameClassesInMultimap(renames, m_behaviorReferences); - EntryRenamer.renameClassesInMultimap(renames, m_fieldReferences); - EntryRenamer.renameClassesInMap(renames, m_access); + EntryRenamer.renameClassesInSet(renames, this.obfClassEntries); + this.translationIndex.renameClasses(renames); + EntryRenamer.renameClassesInMultimap(renames, this.methodImplementations); + EntryRenamer.renameClassesInMultimap(renames, this.behaviorReferences); + EntryRenamer.renameClassesInMultimap(renames, this.fieldReferences); + EntryRenamer.renameClassesInMap(renames, this.access); } } @@ -156,12 +156,12 @@ public class JarIndex { MethodEntry methodEntry = (MethodEntry) behaviorEntry; // index implementation - m_methodImplementations.put(behaviorEntry.getClassName(), methodEntry); + this.methodImplementations.put(behaviorEntry.getClassName(), methodEntry); // look for bridge and bridged methods CtMethod bridgedMethod = getBridgedMethod((CtMethod) behavior); if (bridgedMethod != null) { - m_bridgedMethods.put(methodEntry, EntryFactory.getMethodEntry(bridgedMethod)); + this.bridgedMethods.put(methodEntry, EntryFactory.getMethodEntry(bridgedMethod)); } } // looks like we don't care about constructors here @@ -175,7 +175,7 @@ public class JarIndex { @Override public void edit(MethodCall call) { MethodEntry calledMethodEntry = EntryFactory.getMethodEntry(call); - ClassEntry resolvedClassEntry = m_translationIndex.resolveEntryClass(calledMethodEntry); + ClassEntry resolvedClassEntry = translationIndex.resolveEntryClass(calledMethodEntry); if (resolvedClassEntry != null && !resolvedClassEntry.equals(calledMethodEntry.getClassEntry())) { calledMethodEntry = new MethodEntry( resolvedClassEntry, @@ -188,13 +188,13 @@ public class JarIndex { call.getMethodName(), behaviorEntry ); - m_behaviorReferences.put(calledMethodEntry, reference); + behaviorReferences.put(calledMethodEntry, reference); } @Override public void edit(FieldAccess call) { FieldEntry calledFieldEntry = EntryFactory.getFieldEntry(call); - ClassEntry resolvedClassEntry = m_translationIndex.resolveEntryClass(calledFieldEntry); + ClassEntry resolvedClassEntry = translationIndex.resolveEntryClass(calledFieldEntry); if (resolvedClassEntry != null && !resolvedClassEntry.equals(calledFieldEntry.getClassEntry())) { calledFieldEntry = new FieldEntry(calledFieldEntry, resolvedClassEntry); } @@ -203,7 +203,7 @@ public class JarIndex { call.getFieldName(), behaviorEntry ); - m_fieldReferences.put(calledFieldEntry, reference); + fieldReferences.put(calledFieldEntry, reference); } @Override @@ -214,7 +214,7 @@ public class JarIndex { call.getMethodName(), behaviorEntry ); - m_behaviorReferences.put(calledConstructorEntry, reference); + behaviorReferences.put(calledConstructorEntry, reference); } @Override @@ -225,7 +225,7 @@ public class JarIndex { call.getClassName(), behaviorEntry ); - m_behaviorReferences.put(calledConstructorEntry, reference); + behaviorReferences.put(calledConstructorEntry, reference); } }); } catch (CannotCompileException ex) { @@ -314,7 +314,7 @@ public class JarIndex { // is the entry a superclass of the context? ClassEntry calledClassEntry = reference.entry.getClassEntry(); - ClassEntry superclassEntry = m_translationIndex.getSuperclass(reference.context.getClassEntry()); + ClassEntry superclassEntry = this.translationIndex.getSuperclass(reference.context.getClassEntry()); if (superclassEntry != null && superclassEntry.equals(calledClassEntry)) { // it's a super call, skip continue; @@ -360,7 +360,7 @@ public class JarIndex { } // is the outer class in the jar? - return m_obfClassEntries.contains(outerClassEntry); + return this.obfClassEntries.contains(outerClassEntry); } @@ -500,31 +500,31 @@ public class JarIndex { } public Set getObfClassEntries() { - return m_obfClassEntries; + return this.obfClassEntries; } public Collection getObfFieldEntries() { - return m_fields.values(); + return this.fields.values(); } public Collection getObfFieldEntries(ClassEntry classEntry) { - return m_fields.get(classEntry); + return this.fields.get(classEntry); } public Collection getObfBehaviorEntries() { - return m_behaviors.values(); + return this.behaviors.values(); } public Collection getObfBehaviorEntries(ClassEntry classEntry) { - return m_behaviors.get(classEntry); + return this.behaviors.get(classEntry); } public TranslationIndex getTranslationIndex() { - return m_translationIndex; + return this.translationIndex; } public Access getAccess(Entry entry) { - return m_access.get(entry); + return this.access.get(entry); } public ClassInheritanceTreeNode getClassInheritance(Translator deobfuscatingTranslator, ClassEntry obfClassEntry) { @@ -532,7 +532,7 @@ public class JarIndex { // get the root node List ancestry = Lists.newArrayList(); ancestry.add(obfClassEntry.getName()); - for (ClassEntry classEntry : m_translationIndex.getAncestry(obfClassEntry)) { + for (ClassEntry classEntry : this.translationIndex.getAncestry(obfClassEntry)) { if (containsObfClass(classEntry)) { ancestry.add(classEntry.getName()); } @@ -543,7 +543,7 @@ public class JarIndex { ); // expand all children recursively - rootNode.load(m_translationIndex, true); + rootNode.load(this.translationIndex, true); return rootNode; } @@ -563,7 +563,7 @@ public class JarIndex { // travel to the ancestor implementation ClassEntry baseImplementationClassEntry = obfMethodEntry.getClassEntry(); - for (ClassEntry ancestorClassEntry : m_translationIndex.getAncestry(obfMethodEntry.getClassEntry())) { + for (ClassEntry ancestorClassEntry : this.translationIndex.getAncestry(obfMethodEntry.getClassEntry())) { MethodEntry ancestorMethodEntry = new MethodEntry( new ClassEntry(ancestorClassEntry), obfMethodEntry.getName(), @@ -664,13 +664,13 @@ public class JarIndex { } public Collection> getFieldReferences(FieldEntry fieldEntry) { - return m_fieldReferences.get(fieldEntry); + return this.fieldReferences.get(fieldEntry); } public Collection getReferencedFields(BehaviorEntry behaviorEntry) { // linear search is fast enough for now Set fieldEntries = Sets.newHashSet(); - for (EntryReference reference : m_fieldReferences.values()) { + for (EntryReference reference : this.fieldReferences.values()) { if (reference.context == behaviorEntry) { fieldEntries.add(reference.entry); } @@ -679,13 +679,13 @@ public class JarIndex { } public Collection> getBehaviorReferences(BehaviorEntry behaviorEntry) { - return m_behaviorReferences.get(behaviorEntry); + return this.behaviorReferences.get(behaviorEntry); } public Collection getReferencedBehaviors(BehaviorEntry behaviorEntry) { // linear search is fast enough for now Set behaviorEntries = Sets.newHashSet(); - for (EntryReference reference : m_behaviorReferences.values()) { + for (EntryReference reference : this.behaviorReferences.values()) { if (reference.context == behaviorEntry) { behaviorEntries.add(reference.entry); } @@ -694,27 +694,27 @@ public class JarIndex { } public Collection getInnerClasses(ClassEntry obfOuterClassEntry) { - return m_innerClassesByOuter.get(obfOuterClassEntry); + return this.innerClassesByOuter.get(obfOuterClassEntry); } public ClassEntry getOuterClass(ClassEntry obfInnerClassEntry) { - return m_outerClassesByInner.get(obfInnerClassEntry); + return this.outerClassesByInner.get(obfInnerClassEntry); } public boolean isAnonymousClass(ClassEntry obfInnerClassEntry) { - return m_anonymousClasses.containsKey(obfInnerClassEntry); + return this.anonymousClasses.containsKey(obfInnerClassEntry); } public BehaviorEntry getAnonymousClassCaller(ClassEntry obfInnerClassName) { - return m_anonymousClasses.get(obfInnerClassName); + return this.anonymousClasses.get(obfInnerClassName); } public Set getInterfaces(String className) { ClassEntry classEntry = new ClassEntry(className); Set interfaces = new HashSet(); - interfaces.addAll(m_translationIndex.getInterfaces(classEntry)); - for (ClassEntry ancestor : m_translationIndex.getAncestry(classEntry)) { - interfaces.addAll(m_translationIndex.getInterfaces(ancestor)); + interfaces.addAll(this.translationIndex.getInterfaces(classEntry)); + for (ClassEntry ancestor : this.translationIndex.getAncestry(classEntry)) { + interfaces.addAll(this.translationIndex.getInterfaces(ancestor)); } return interfaces; } @@ -723,31 +723,31 @@ public class JarIndex { // linear search is fast enough for now Set classNames = Sets.newHashSet(); - for (Map.Entry entry : m_translationIndex.getClassInterfaces()) { + for (Map.Entry entry : this.translationIndex.getClassInterfaces()) { ClassEntry classEntry = entry.getKey(); ClassEntry interfaceEntry = entry.getValue(); if (interfaceEntry.getName().equals(targetInterfaceName)) { classNames.add(classEntry.getClassName()); - m_translationIndex.getSubclassNamesRecursively(classNames, classEntry); + this.translationIndex.getSubclassNamesRecursively(classNames, classEntry); } } return classNames; } public boolean isInterface(String className) { - return m_translationIndex.isInterface(new ClassEntry(className)); + return this.translationIndex.isInterface(new ClassEntry(className)); } public boolean containsObfClass(ClassEntry obfClassEntry) { - return m_obfClassEntries.contains(obfClassEntry); + return this.obfClassEntries.contains(obfClassEntry); } public boolean containsObfField(FieldEntry obfFieldEntry) { - return m_access.containsKey(obfFieldEntry); + return this.access.containsKey(obfFieldEntry); } public boolean containsObfBehavior(BehaviorEntry obfBehaviorEntry) { - return m_access.containsKey(obfBehaviorEntry); + return this.access.containsKey(obfBehaviorEntry); } public boolean containsObfArgument(ArgumentEntry obfArgumentEntry) { @@ -776,7 +776,7 @@ public class JarIndex { } public MethodEntry getBridgedMethod(MethodEntry bridgeMethodEntry) { - return m_bridgedMethods.get(bridgeMethodEntry); + return this.bridgedMethods.get(bridgeMethodEntry); } public List getObfClassChain(ClassEntry obfClassEntry) { -- cgit v1.2.3