From 64c359d3c1d2347001e5c6becb1d7561457f52cc Mon Sep 17 00:00:00 2001 From: lclc98 Date: Sat, 2 Jul 2016 18:04:57 +1000 Subject: Renamed Fields --- .../enigma/analysis/BehaviorReferenceTreeNode.java | 34 ++--- .../java/cuchaz/enigma/analysis/BridgeMarker.java | 4 +- .../analysis/ClassImplementationsTreeNode.java | 20 +-- .../enigma/analysis/ClassInheritanceTreeNode.java | 18 +-- .../cuchaz/enigma/analysis/EntryReference.java | 15 +- .../java/cuchaz/enigma/analysis/EntryRenamer.java | 22 +-- .../enigma/analysis/FieldReferenceTreeNode.java | 42 +++--- .../cuchaz/enigma/analysis/JarClassIterator.java | 23 ++- src/main/java/cuchaz/enigma/analysis/JarIndex.java | 156 ++++++++++----------- .../analysis/MethodImplementationsTreeNode.java | 29 ++-- .../enigma/analysis/MethodInheritanceTreeNode.java | 38 +++-- .../java/cuchaz/enigma/analysis/SourceIndex.java | 78 +++++------ .../analysis/SourceIndexBehaviorVisitor.java | 18 +-- .../enigma/analysis/SourceIndexClassVisitor.java | 8 +- src/main/java/cuchaz/enigma/analysis/Token.java | 5 +- .../cuchaz/enigma/analysis/TranslationIndex.java | 85 ++++++----- 16 files changed, 279 insertions(+), 316 deletions(-) (limited to 'src/main/java/cuchaz/enigma/analysis') diff --git a/src/main/java/cuchaz/enigma/analysis/BehaviorReferenceTreeNode.java b/src/main/java/cuchaz/enigma/analysis/BehaviorReferenceTreeNode.java index 776f090..39ff449 100644 --- a/src/main/java/cuchaz/enigma/analysis/BehaviorReferenceTreeNode.java +++ b/src/main/java/cuchaz/enigma/analysis/BehaviorReferenceTreeNode.java @@ -31,50 +31,50 @@ public class BehaviorReferenceTreeNode extends DefaultMutableTreeNode implements private Access m_access; public BehaviorReferenceTreeNode(Translator deobfuscatingTranslator, BehaviorEntry entry) { - m_deobfuscatingTranslator = deobfuscatingTranslator; - m_entry = entry; - m_reference = null; + this.m_deobfuscatingTranslator = deobfuscatingTranslator; + this.m_entry = entry; + this.m_reference = null; } public BehaviorReferenceTreeNode(Translator deobfuscatingTranslator, EntryReference reference, Access access) { - m_deobfuscatingTranslator = deobfuscatingTranslator; - m_entry = reference.entry; - m_reference = reference; - m_access = access; + this.m_deobfuscatingTranslator = deobfuscatingTranslator; + this.m_entry = reference.entry; + this.m_reference = reference; + this.m_access = access; } @Override public BehaviorEntry getEntry() { - return m_entry; + return this.m_entry; } @Override public EntryReference getReference() { - return m_reference; + return this.m_reference; } @Override public String toString() { - if (m_reference != null) { - return String.format("%s (%s)", m_deobfuscatingTranslator.translateEntry(m_reference.context), m_access); + if (this.m_reference != null) { + return String.format("%s (%s)", this.m_deobfuscatingTranslator.translateEntry(this.m_reference.context), this.m_access); } - return m_deobfuscatingTranslator.translateEntry(m_entry).toString(); + return this.m_deobfuscatingTranslator.translateEntry(this.m_entry).toString(); } public void load(JarIndex index, boolean recurse) { // get all the child nodes - for (EntryReference reference : index.getBehaviorReferences(m_entry)) { - add(new BehaviorReferenceTreeNode(m_deobfuscatingTranslator, reference, index.getAccess(m_entry))); + for (EntryReference reference : index.getBehaviorReferences(this.m_entry)) { + add(new BehaviorReferenceTreeNode(this.m_deobfuscatingTranslator, reference, index.getAccess(this.m_entry))); } - if (recurse && children != null) { - for (Object child : children) { + if (recurse && this.children != null) { + for (Object child : this.children) { if (child instanceof BehaviorReferenceTreeNode) { BehaviorReferenceTreeNode node = (BehaviorReferenceTreeNode) child; // don't recurse into ancestor Set ancestors = Sets.newHashSet(); - TreeNode n = (TreeNode) node; + TreeNode n = node; while (n.getParent() != null) { n = n.getParent(); if (n instanceof BehaviorReferenceTreeNode) { diff --git a/src/main/java/cuchaz/enigma/analysis/BridgeMarker.java b/src/main/java/cuchaz/enigma/analysis/BridgeMarker.java index 1df7625..cd18584 100644 --- a/src/main/java/cuchaz/enigma/analysis/BridgeMarker.java +++ b/src/main/java/cuchaz/enigma/analysis/BridgeMarker.java @@ -21,7 +21,7 @@ public class BridgeMarker { private JarIndex m_jarIndex; public BridgeMarker(JarIndex jarIndex) { - m_jarIndex = jarIndex; + this.m_jarIndex = jarIndex; } public void markBridges(CtClass c) { @@ -30,7 +30,7 @@ public class BridgeMarker { MethodEntry methodEntry = EntryFactory.getMethodEntry(method); // is this a bridge method? - MethodEntry bridgedMethodEntry = m_jarIndex.getBridgedMethod(methodEntry); + MethodEntry bridgedMethodEntry = this.m_jarIndex.getBridgedMethod(methodEntry); if (bridgedMethodEntry != null) { // it's a bridge method! add the bridge flag diff --git a/src/main/java/cuchaz/enigma/analysis/ClassImplementationsTreeNode.java b/src/main/java/cuchaz/enigma/analysis/ClassImplementationsTreeNode.java index 8f8986c..3420cd6 100644 --- a/src/main/java/cuchaz/enigma/analysis/ClassImplementationsTreeNode.java +++ b/src/main/java/cuchaz/enigma/analysis/ClassImplementationsTreeNode.java @@ -24,27 +24,27 @@ public class ClassImplementationsTreeNode extends DefaultMutableTreeNode { private static final long serialVersionUID = 3112703459157851912L; - private Translator m_deobfuscatingTranslator; - private ClassEntry m_entry; + private Translator deobfuscatingTranslator; + private ClassEntry entry; public ClassImplementationsTreeNode(Translator deobfuscatingTranslator, ClassEntry entry) { - m_deobfuscatingTranslator = deobfuscatingTranslator; - m_entry = entry; + this.deobfuscatingTranslator = deobfuscatingTranslator; + this.entry = entry; } public ClassEntry getClassEntry() { - return m_entry; + return this.entry; } public String getDeobfClassName() { - return m_deobfuscatingTranslator.translateClass(m_entry.getClassName()); + return this.deobfuscatingTranslator.translateClass(this.entry.getClassName()); } @Override public String toString() { String className = getDeobfClassName(); if (className == null) { - className = m_entry.getClassName(); + className = this.entry.getClassName(); } return className; } @@ -52,8 +52,8 @@ public class ClassImplementationsTreeNode extends DefaultMutableTreeNode { public void load(JarIndex index) { // get all method implementations List nodes = Lists.newArrayList(); - for (String implementingClassName : index.getImplementingClasses(m_entry.getClassName())) { - nodes.add(new ClassImplementationsTreeNode(m_deobfuscatingTranslator, new ClassEntry(implementingClassName))); + for (String implementingClassName : index.getImplementingClasses(this.entry.getClassName())) { + nodes.add(new ClassImplementationsTreeNode(this.deobfuscatingTranslator, new ClassEntry(implementingClassName))); } // add them to this node @@ -62,7 +62,7 @@ public class ClassImplementationsTreeNode extends DefaultMutableTreeNode { public static ClassImplementationsTreeNode findNode(ClassImplementationsTreeNode node, MethodEntry entry) { // is this the node? - if (node.m_entry.equals(entry)) { + if (node.entry.equals(entry)) { return node; } diff --git a/src/main/java/cuchaz/enigma/analysis/ClassInheritanceTreeNode.java b/src/main/java/cuchaz/enigma/analysis/ClassInheritanceTreeNode.java index ca2b821..beac9d5 100644 --- a/src/main/java/cuchaz/enigma/analysis/ClassInheritanceTreeNode.java +++ b/src/main/java/cuchaz/enigma/analysis/ClassInheritanceTreeNode.java @@ -23,20 +23,20 @@ public class ClassInheritanceTreeNode extends DefaultMutableTreeNode { private static final long serialVersionUID = 4432367405826178490L; - private Translator m_deobfuscatingTranslator; - private String m_obfClassName; + private Translator deobfuscatingTranslator; + private String obfClassName; public ClassInheritanceTreeNode(Translator deobfuscatingTranslator, String obfClassName) { - m_deobfuscatingTranslator = deobfuscatingTranslator; - m_obfClassName = obfClassName; + this.deobfuscatingTranslator = deobfuscatingTranslator; + this.obfClassName = obfClassName; } public String getObfClassName() { - return m_obfClassName; + return this.obfClassName; } public String getDeobfClassName() { - return m_deobfuscatingTranslator.translateClass(m_obfClassName); + return this.deobfuscatingTranslator.translateClass(this.obfClassName); } @Override @@ -45,14 +45,14 @@ public class ClassInheritanceTreeNode extends DefaultMutableTreeNode { if (deobfClassName != null) { return deobfClassName; } - return m_obfClassName; + return this.obfClassName; } public void load(TranslationIndex ancestries, boolean recurse) { // get all the child nodes List nodes = Lists.newArrayList(); - for (ClassEntry subclassEntry : ancestries.getSubclass(new ClassEntry(m_obfClassName))) { - nodes.add(new ClassInheritanceTreeNode(m_deobfuscatingTranslator, subclassEntry.getName())); + for (ClassEntry subclassEntry : ancestries.getSubclass(new ClassEntry(this.obfClassName))) { + nodes.add(new ClassInheritanceTreeNode(this.deobfuscatingTranslator, subclassEntry.getName())); } // add them to this node diff --git a/src/main/java/cuchaz/enigma/analysis/EntryReference.java b/src/main/java/cuchaz/enigma/analysis/EntryReference.java index eb58388..6a7a4bf 100644 --- a/src/main/java/cuchaz/enigma/analysis/EntryReference.java +++ b/src/main/java/cuchaz/enigma/analysis/EntryReference.java @@ -24,7 +24,7 @@ public class EntryReference { public E entry; public C context; - private boolean m_isNamed; + private boolean sourceName; public EntryReference(E entry, String sourceName) { this(entry, sourceName, null); @@ -38,16 +38,16 @@ public class EntryReference { this.entry = entry; this.context = context; - m_isNamed = sourceName != null && sourceName.length() > 0; + this.sourceName = sourceName != null && sourceName.length() > 0; if (entry instanceof ConstructorEntry && ConstructorNonNames.contains(sourceName)) { - m_isNamed = false; + this.sourceName = false; } } public EntryReference(E entry, C context, EntryReference other) { this.entry = entry; this.context = context; - m_isNamed = other.m_isNamed; + this.sourceName = other.sourceName; } public ClassEntry getLocationClassEntry() { @@ -58,7 +58,7 @@ public class EntryReference { } public boolean isNamed() { - return m_isNamed; + return this.sourceName; } public Entry getNameableEntry() { @@ -91,10 +91,7 @@ public class EntryReference { @Override public boolean equals(Object other) { - if (other instanceof EntryReference) { - return equals((EntryReference) other); - } - return false; + return other instanceof EntryReference && equals((EntryReference) other); } public boolean equals(EntryReference other) { diff --git a/src/main/java/cuchaz/enigma/analysis/EntryRenamer.java b/src/main/java/cuchaz/enigma/analysis/EntryRenamer.java index b99537c..9c3d051 100644 --- a/src/main/java/cuchaz/enigma/analysis/EntryRenamer.java +++ b/src/main/java/cuchaz/enigma/analysis/EntryRenamer.java @@ -36,7 +36,7 @@ public class EntryRenamer { // for each key/value pair... Set> entriesToAdd = Sets.newHashSet(); for (Map.Entry entry : map.entrySet()) { - entriesToAdd.add(new AbstractMap.SimpleEntry( + entriesToAdd.add(new AbstractMap.SimpleEntry<>( renameClassesInThing(renames, entry.getKey()), renameClassesInThing(renames, entry.getValue()) )); @@ -51,7 +51,7 @@ public class EntryRenamer { // for each key/value pair... Set> entriesToAdd = Sets.newHashSet(); for (Map.Entry entry : map.entries()) { - entriesToAdd.add(new AbstractMap.SimpleEntry( + entriesToAdd.add(new AbstractMap.SimpleEntry<>( renameClassesInThing(renames, entry.getKey()), renameClassesInThing(renames, entry.getValue()) )); @@ -66,7 +66,7 @@ public class EntryRenamer { // for each key/value pair... Set> entriesToAdd = Sets.newHashSet(); for (Map.Entry entry : map.entries()) { - entriesToAdd.add(new AbstractMap.SimpleEntry( + entriesToAdd.add(new AbstractMap.SimpleEntry<>( renameMethodsInThing(renames, entry.getKey()), renameMethodsInThing(renames, entry.getValue()) )); @@ -81,7 +81,7 @@ public class EntryRenamer { // for each key/value pair... Set> entriesToAdd = Sets.newHashSet(); for (Map.Entry entry : map.entrySet()) { - entriesToAdd.add(new AbstractMap.SimpleEntry( + entriesToAdd.add(new AbstractMap.SimpleEntry<>( renameMethodsInThing(renames, entry.getKey()), renameMethodsInThing(renames, entry.getValue()) )); @@ -164,19 +164,9 @@ public class EntryRenamer { reference.context = renameClassesInThing(renames, reference.context); return thing; } else if (thing instanceof Signature) { - return (T) new Signature((Signature) thing, new ClassNameReplacer() { - @Override - public String replace(String className) { - return renameClassesInThing(renames, className); - } - }); + return (T) new Signature((Signature) thing, className -> renameClassesInThing(renames, className)); } else if (thing instanceof Type) { - return (T) new Type((Type) thing, new ClassNameReplacer() { - @Override - public String replace(String className) { - return renameClassesInThing(renames, className); - } - }); + return (T) new Type((Type) thing, className -> renameClassesInThing(renames, className)); } return thing; diff --git a/src/main/java/cuchaz/enigma/analysis/FieldReferenceTreeNode.java b/src/main/java/cuchaz/enigma/analysis/FieldReferenceTreeNode.java index 4b302e0..05d9c13 100644 --- a/src/main/java/cuchaz/enigma/analysis/FieldReferenceTreeNode.java +++ b/src/main/java/cuchaz/enigma/analysis/FieldReferenceTreeNode.java @@ -20,51 +20,51 @@ public class FieldReferenceTreeNode extends DefaultMutableTreeNode implements Re private static final long serialVersionUID = -7934108091928699835L; - private Translator m_deobfuscatingTranslator; - private FieldEntry m_entry; - private EntryReference m_reference; - private Access m_access; + private Translator deobfuscatingTranslator; + private FieldEntry entry; + private EntryReference reference; + private Access access; public FieldReferenceTreeNode(Translator deobfuscatingTranslator, FieldEntry entry) { - m_deobfuscatingTranslator = deobfuscatingTranslator; - m_entry = entry; - m_reference = null; + this.deobfuscatingTranslator = deobfuscatingTranslator; + this.entry = entry; + this.reference = null; } private FieldReferenceTreeNode(Translator deobfuscatingTranslator, EntryReference reference, Access access) { - m_deobfuscatingTranslator = deobfuscatingTranslator; - m_entry = reference.entry; - m_reference = reference; - m_access = access; + this.deobfuscatingTranslator = deobfuscatingTranslator; + this.entry = reference.entry; + this.reference = reference; + this.access = access; } @Override public FieldEntry getEntry() { - return m_entry; + return this.entry; } @Override public EntryReference getReference() { - return m_reference; + return this.reference; } @Override public String toString() { - if (m_reference != null) { - return String.format("%s (%s)", m_deobfuscatingTranslator.translateEntry(m_reference.context), m_access); + if (this.reference != null) { + return String.format("%s (%s)", this.deobfuscatingTranslator.translateEntry(this.reference.context), this.access); } - return m_deobfuscatingTranslator.translateEntry(m_entry).toString(); + return this.deobfuscatingTranslator.translateEntry(this.entry).toString(); } public void load(JarIndex index, boolean recurse) { // get all the child nodes - if (m_reference == null) { - for (EntryReference reference : index.getFieldReferences(m_entry)) { - add(new FieldReferenceTreeNode(m_deobfuscatingTranslator, reference, index.getAccess(m_entry))); + if (this.reference == null) { + for (EntryReference reference : index.getFieldReferences(this.entry)) { + add(new FieldReferenceTreeNode(this.deobfuscatingTranslator, reference, index.getAccess(this.entry))); } } else { - for (EntryReference reference : index.getBehaviorReferences(m_reference.context)) { - add(new BehaviorReferenceTreeNode(m_deobfuscatingTranslator, reference, index.getAccess(m_reference.context))); + for (EntryReference reference : index.getBehaviorReferences(this.reference.context)) { + add(new BehaviorReferenceTreeNode(this.deobfuscatingTranslator, reference, index.getAccess(this.reference.context))); } } diff --git a/src/main/java/cuchaz/enigma/analysis/JarClassIterator.java b/src/main/java/cuchaz/enigma/analysis/JarClassIterator.java index 17a1715..0400427 100644 --- a/src/main/java/cuchaz/enigma/analysis/JarClassIterator.java +++ b/src/main/java/cuchaz/enigma/analysis/JarClassIterator.java @@ -31,15 +31,15 @@ import javassist.bytecode.Descriptor; public class JarClassIterator implements Iterator { - private JarFile m_jar; - private Iterator m_iter; + private JarFile jar; + private Iterator iter; public JarClassIterator(JarFile jar) { - m_jar = jar; + this.jar = jar; // get the jar entries that correspond to classes List classEntries = Lists.newArrayList(); - Enumeration entries = m_jar.entries(); + Enumeration entries = this.jar.entries(); while (entries.hasMoreElements()) { JarEntry entry = entries.nextElement(); @@ -48,19 +48,19 @@ public class JarClassIterator implements Iterator { classEntries.add(entry); } } - m_iter = classEntries.iterator(); + this.iter = classEntries.iterator(); } @Override public boolean hasNext() { - return m_iter.hasNext(); + return this.iter.hasNext(); } @Override public CtClass next() { - JarEntry entry = m_iter.next(); + JarEntry entry = this.iter.next(); try { - return getClass(m_jar, entry); + return getClass(this.jar, entry); } catch (IOException | NotFoundException ex) { throw new Error("Unable to load class: " + entry.getName()); } @@ -86,12 +86,7 @@ public class JarClassIterator implements Iterator { } public static Iterable classes(final JarFile jar) { - return new Iterable() { - @Override - public Iterator iterator() { - return new JarClassIterator(jar); - } - }; + return () -> new JarClassIterator(jar); } public static CtClass getClass(JarFile jar, ClassEntry classEntry) { 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) { diff --git a/src/main/java/cuchaz/enigma/analysis/MethodImplementationsTreeNode.java b/src/main/java/cuchaz/enigma/analysis/MethodImplementationsTreeNode.java index 2ee3ec1..1cf80d9 100644 --- a/src/main/java/cuchaz/enigma/analysis/MethodImplementationsTreeNode.java +++ b/src/main/java/cuchaz/enigma/analysis/MethodImplementationsTreeNode.java @@ -24,40 +24,40 @@ public class MethodImplementationsTreeNode extends DefaultMutableTreeNode { private static final long serialVersionUID = 3781080657461899915L; - private Translator m_deobfuscatingTranslator; - private MethodEntry m_entry; + private Translator deobfuscatingTranslator; + private MethodEntry entry; public MethodImplementationsTreeNode(Translator deobfuscatingTranslator, MethodEntry entry) { if (entry == null) { - throw new IllegalArgumentException("entry cannot be null!"); + throw new IllegalArgumentException("Entry cannot be null!"); } - m_deobfuscatingTranslator = deobfuscatingTranslator; - m_entry = entry; + this.deobfuscatingTranslator = deobfuscatingTranslator; + this.entry = entry; } public MethodEntry getMethodEntry() { - return m_entry; + return this.entry; } public String getDeobfClassName() { - return m_deobfuscatingTranslator.translateClass(m_entry.getClassName()); + return this.deobfuscatingTranslator.translateClass(this.entry.getClassName()); } public String getDeobfMethodName() { - return m_deobfuscatingTranslator.translate(m_entry); + return this.deobfuscatingTranslator.translate(this.entry); } @Override public String toString() { String className = getDeobfClassName(); if (className == null) { - className = m_entry.getClassName(); + className = this.entry.getClassName(); } String methodName = getDeobfMethodName(); if (methodName == null) { - methodName = m_entry.getName(); + methodName = this.entry.getName(); } return className + "." + methodName + "()"; } @@ -66,14 +66,11 @@ public class MethodImplementationsTreeNode extends DefaultMutableTreeNode { // get all method implementations List nodes = Lists.newArrayList(); - for (String implementingClassName : index.getImplementingClasses(m_entry.getClassName())) { - MethodEntry methodEntry = new MethodEntry( - new ClassEntry(implementingClassName), - m_entry.getName(), - m_entry.getSignature() + for (String implementingClassName : index.getImplementingClasses(this.entry.getClassName())) { + MethodEntry methodEntry = new MethodEntry(new ClassEntry(implementingClassName), this.entry.getName(), this.entry.getSignature() ); if (index.containsObfBehavior(methodEntry)) { - nodes.add(new MethodImplementationsTreeNode(m_deobfuscatingTranslator, methodEntry)); + nodes.add(new MethodImplementationsTreeNode(this.deobfuscatingTranslator, methodEntry)); } } diff --git a/src/main/java/cuchaz/enigma/analysis/MethodInheritanceTreeNode.java b/src/main/java/cuchaz/enigma/analysis/MethodInheritanceTreeNode.java index cf42ac7..a3bed6e 100644 --- a/src/main/java/cuchaz/enigma/analysis/MethodInheritanceTreeNode.java +++ b/src/main/java/cuchaz/enigma/analysis/MethodInheritanceTreeNode.java @@ -24,45 +24,45 @@ public class MethodInheritanceTreeNode extends DefaultMutableTreeNode { private static final long serialVersionUID = 1096677030991810007L; - private Translator m_deobfuscatingTranslator; - private MethodEntry m_entry; - private boolean m_isImplemented; + private Translator deobfuscatingTranslator; + private MethodEntry entry; + private boolean isImplemented; public MethodInheritanceTreeNode(Translator deobfuscatingTranslator, MethodEntry entry, boolean isImplemented) { - m_deobfuscatingTranslator = deobfuscatingTranslator; - m_entry = entry; - m_isImplemented = isImplemented; + this.deobfuscatingTranslator = deobfuscatingTranslator; + this.entry = entry; + this.isImplemented = isImplemented; } public MethodEntry getMethodEntry() { - return m_entry; + return this.entry; } public String getDeobfClassName() { - return m_deobfuscatingTranslator.translateClass(m_entry.getClassName()); + return this.deobfuscatingTranslator.translateClass(this.entry.getClassName()); } public String getDeobfMethodName() { - return m_deobfuscatingTranslator.translate(m_entry); + return this.deobfuscatingTranslator.translate(this.entry); } public boolean isImplemented() { - return m_isImplemented; + return this.isImplemented; } @Override public String toString() { String className = getDeobfClassName(); if (className == null) { - className = m_entry.getClassName(); + className = this.entry.getClassName(); } - if (!m_isImplemented) { + if (!this.isImplemented) { return className; } else { String methodName = getDeobfMethodName(); if (methodName == null) { - methodName = m_entry.getName(); + methodName = this.entry.getName(); } return className + "." + methodName + "()"; } @@ -71,16 +71,10 @@ public class MethodInheritanceTreeNode extends DefaultMutableTreeNode { public void load(JarIndex index, boolean recurse) { // get all the child nodes List nodes = Lists.newArrayList(); - for (ClassEntry subclassEntry : index.getTranslationIndex().getSubclass(m_entry.getClassEntry())) { - MethodEntry methodEntry = new MethodEntry( - subclassEntry, - m_entry.getName(), - m_entry.getSignature() + for (ClassEntry subclassEntry : index.getTranslationIndex().getSubclass(this.entry.getClassEntry())) { + MethodEntry methodEntry = new MethodEntry(subclassEntry, this.entry.getName(), this.entry.getSignature() ); - nodes.add(new MethodInheritanceTreeNode( - m_deobfuscatingTranslator, - methodEntry, - index.containsObfBehavior(methodEntry) + nodes.add(new MethodInheritanceTreeNode(this.deobfuscatingTranslator, methodEntry, index.containsObfBehavior(methodEntry) )); } diff --git a/src/main/java/cuchaz/enigma/analysis/SourceIndex.java b/src/main/java/cuchaz/enigma/analysis/SourceIndex.java index a20fbb4..cbc2945 100644 --- a/src/main/java/cuchaz/enigma/analysis/SourceIndex.java +++ b/src/main/java/cuchaz/enigma/analysis/SourceIndex.java @@ -28,36 +28,36 @@ import cuchaz.enigma.mapping.Entry; public class SourceIndex { - private String m_source; - private TreeMap> m_tokenToReference; - private Multimap, Token> m_referenceToTokens; - private Map m_declarationToToken; - private List m_lineOffsets; - private boolean m_ignoreBadTokens; + private String source; + private TreeMap> tokenToReference; + private Multimap, Token> referenceToTokens; + private Map declarationToToken; + private List lineOffsets; + private boolean ignoreBadTokens; public SourceIndex(String source) { this(source, true); } public SourceIndex(String source, boolean ignoreBadTokens) { - m_source = source; - m_ignoreBadTokens = ignoreBadTokens; - m_tokenToReference = Maps.newTreeMap(); - m_referenceToTokens = HashMultimap.create(); - m_declarationToToken = Maps.newHashMap(); - m_lineOffsets = Lists.newArrayList(); + this.source = source; + this.ignoreBadTokens = ignoreBadTokens; + this.tokenToReference = Maps.newTreeMap(); + this.referenceToTokens = HashMultimap.create(); + this.declarationToToken = Maps.newHashMap(); + this.lineOffsets = Lists.newArrayList(); // count the lines - m_lineOffsets.add(0); + this.lineOffsets.add(0); for (int i = 0; i < source.length(); i++) { if (source.charAt(i) == '\n') { - m_lineOffsets.add(i + 1); + this.lineOffsets.add(i + 1); } } } public String getSource() { - return m_source; + return this.source; } public Token getToken(AstNode node) { @@ -75,11 +75,7 @@ public class SourceIndex { System.err.println(String.format("WARNING: %s \"%s\" has invalid region: %s", node.getNodeType(), name, region)); return null; } - Token token = new Token( - toPos(region.getBeginLine(), region.getBeginColumn()), - toPos(region.getEndLine(), region.getEndColumn()), - m_source - ); + Token token = new Token(toPos(region.getBeginLine(), region.getBeginColumn()), toPos(region.getEndLine(), region.getEndColumn()), this.source); if (token.start == 0) { // DEBUG System.err.println(String.format("WARNING: %s \"%s\" has invalid start: %s", node.getNodeType(), name, region)); @@ -90,7 +86,7 @@ public class SourceIndex { // System.out.println( String.format( "%s \"%s\" region: %s", node.getNodeType(), name, region ) ); // if the token has a $ in it, something's wrong. Ignore this token - if (name.lastIndexOf('$') >= 0 && m_ignoreBadTokens) { + if (name.lastIndexOf('$') >= 0 && this.ignoreBadTokens) { // DEBUG System.err.println(String.format("WARNING: %s \"%s\" is probably a bad token. It was ignored", node.getNodeType(), name)); return null; @@ -103,8 +99,8 @@ public class SourceIndex { Token token = getToken(node); if (token != null) { EntryReference deobfReference = new EntryReference(deobfEntry, token.text, deobfContext); - m_tokenToReference.put(token, deobfReference); - m_referenceToTokens.put(deobfReference, token); + this.tokenToReference.put(token, deobfReference); + this.referenceToTokens.put(deobfReference, token); } } @@ -112,14 +108,14 @@ public class SourceIndex { Token token = getToken(node); if (token != null) { EntryReference reference = new EntryReference(deobfEntry, token.text); - m_tokenToReference.put(token, reference); - m_referenceToTokens.put(reference, token); - m_declarationToToken.put(deobfEntry, token); + this.tokenToReference.put(token, reference); + this.referenceToTokens.put(reference, token); + this.declarationToToken.put(deobfEntry, token); } } public Token getReferenceToken(int pos) { - Token token = m_tokenToReference.floorKey(new Token(pos, pos, null)); + Token token = this.tokenToReference.floorKey(new Token(pos, pos, null)); if (token != null && token.contains(pos)) { return token; } @@ -127,44 +123,44 @@ public class SourceIndex { } public Collection getReferenceTokens(EntryReference deobfReference) { - return m_referenceToTokens.get(deobfReference); + return this.referenceToTokens.get(deobfReference); } public EntryReference getDeobfReference(Token token) { if (token == null) { return null; } - return m_tokenToReference.get(token); + return this.tokenToReference.get(token); } public void replaceDeobfReference(Token token, EntryReference newDeobfReference) { - EntryReference oldDeobfReference = m_tokenToReference.get(token); - m_tokenToReference.put(token, newDeobfReference); - Collection tokens = m_referenceToTokens.get(oldDeobfReference); - m_referenceToTokens.removeAll(oldDeobfReference); - m_referenceToTokens.putAll(newDeobfReference, tokens); + EntryReference oldDeobfReference = this.tokenToReference.get(token); + this.tokenToReference.put(token, newDeobfReference); + Collection tokens = this.referenceToTokens.get(oldDeobfReference); + this.referenceToTokens.removeAll(oldDeobfReference); + this.referenceToTokens.putAll(newDeobfReference, tokens); } public Iterable referenceTokens() { - return m_tokenToReference.keySet(); + return this.tokenToReference.keySet(); } public Iterable declarationTokens() { - return m_declarationToToken.values(); + return this.declarationToToken.values(); } public Iterable declarations() { - return m_declarationToToken.keySet(); + return this.declarationToToken.keySet(); } public Token getDeclarationToken(Entry deobfEntry) { - return m_declarationToToken.get(deobfEntry); + return this.declarationToToken.get(deobfEntry); } public int getLineNumber(int pos) { // line number is 1-based int line = 0; - for (Integer offset : m_lineOffsets) { + for (Integer offset : this.lineOffsets) { if (offset > pos) { break; } @@ -175,11 +171,11 @@ public class SourceIndex { public int getColumnNumber(int pos) { // column number is 1-based - return pos - m_lineOffsets.get(getLineNumber(pos) - 1) + 1; + return pos - this.lineOffsets.get(getLineNumber(pos) - 1) + 1; } private int toPos(int line, int col) { // line and col are 1-based - return m_lineOffsets.get(line - 1) + col - 1; + return this.lineOffsets.get(line - 1) + col - 1; } } diff --git a/src/main/java/cuchaz/enigma/analysis/SourceIndexBehaviorVisitor.java b/src/main/java/cuchaz/enigma/analysis/SourceIndexBehaviorVisitor.java index e2b567e..4a468e7 100644 --- a/src/main/java/cuchaz/enigma/analysis/SourceIndexBehaviorVisitor.java +++ b/src/main/java/cuchaz/enigma/analysis/SourceIndexBehaviorVisitor.java @@ -14,16 +14,16 @@ import com.strobel.assembler.metadata.*; import com.strobel.decompiler.languages.TextLocation; import com.strobel.decompiler.languages.java.ast.*; -import cuchaz.enigma.mapping.*; - import java.lang.Error; +import cuchaz.enigma.mapping.*; + public class SourceIndexBehaviorVisitor extends SourceIndexVisitor { - private BehaviorEntry m_behaviorEntry; + private BehaviorEntry behaviorEntry; public SourceIndexBehaviorVisitor(BehaviorEntry behaviorEntry) { - m_behaviorEntry = behaviorEntry; + this.behaviorEntry = behaviorEntry; } @Override @@ -54,7 +54,7 @@ public class SourceIndexBehaviorVisitor extends SourceIndexVisitor { tokenNode = node.getTarget(); } if (tokenNode != null) { - index.addReference(tokenNode, behaviorEntry, m_behaviorEntry); + index.addReference(tokenNode, behaviorEntry, this.behaviorEntry); } } @@ -72,7 +72,7 @@ public class SourceIndexBehaviorVisitor extends SourceIndexVisitor { ClassEntry classEntry = new ClassEntry(ref.getDeclaringType().getInternalName()); FieldEntry fieldEntry = new FieldEntry(classEntry, ref.getName(), new Type(ref.getErasedSignature())); - index.addReference(node.getMemberNameToken(), fieldEntry, m_behaviorEntry); + index.addReference(node.getMemberNameToken(), fieldEntry, this.behaviorEntry); } return recurse(node, index); @@ -83,7 +83,7 @@ public class SourceIndexBehaviorVisitor extends SourceIndexVisitor { TypeReference ref = node.getUserData(Keys.TYPE_REFERENCE); if (node.getIdentifierToken().getStartLocation() != TextLocation.EMPTY) { ClassEntry classEntry = new ClassEntry(ref.getInternalName()); - index.addReference(node.getIdentifierToken(), classEntry, m_behaviorEntry); + index.addReference(node.getIdentifierToken(), classEntry, this.behaviorEntry); } return recurse(node, index); @@ -108,7 +108,7 @@ public class SourceIndexBehaviorVisitor extends SourceIndexVisitor { if (ref != null) { ClassEntry classEntry = new ClassEntry(ref.getDeclaringType().getInternalName()); FieldEntry fieldEntry = new FieldEntry(classEntry, ref.getName(), new Type(ref.getErasedSignature())); - index.addReference(node.getIdentifierToken(), fieldEntry, m_behaviorEntry); + index.addReference(node.getIdentifierToken(), fieldEntry, this.behaviorEntry); } return recurse(node, index); @@ -122,7 +122,7 @@ public class SourceIndexBehaviorVisitor extends SourceIndexVisitor { ConstructorEntry constructorEntry = new ConstructorEntry(classEntry, new Signature(ref.getErasedSignature())); if (node.getType() instanceof SimpleType) { SimpleType simpleTypeNode = (SimpleType) node.getType(); - index.addReference(simpleTypeNode.getIdentifierToken(), constructorEntry, m_behaviorEntry); + index.addReference(simpleTypeNode.getIdentifierToken(), constructorEntry, this.behaviorEntry); } } diff --git a/src/main/java/cuchaz/enigma/analysis/SourceIndexClassVisitor.java b/src/main/java/cuchaz/enigma/analysis/SourceIndexClassVisitor.java index 0a3bad5..06ce042 100644 --- a/src/main/java/cuchaz/enigma/analysis/SourceIndexClassVisitor.java +++ b/src/main/java/cuchaz/enigma/analysis/SourceIndexClassVisitor.java @@ -21,10 +21,10 @@ import cuchaz.enigma.mapping.*; public class SourceIndexClassVisitor extends SourceIndexVisitor { - private ClassEntry m_classEntry; + private ClassEntry classEntry; public SourceIndexClassVisitor(ClassEntry classEntry) { - m_classEntry = classEntry; + this.classEntry = classEntry; } @Override @@ -32,7 +32,7 @@ public class SourceIndexClassVisitor extends SourceIndexVisitor { // is this this class, or a subtype? TypeDefinition def = node.getUserData(Keys.TYPE_DEFINITION); ClassEntry classEntry = new ClassEntry(def.getInternalName()); - if (!classEntry.equals(m_classEntry)) { + if (!classEntry.equals(this.classEntry)) { // it's a sub-type, recurse index.addDeclaration(node.getNameToken(), classEntry); return node.acceptVisitor(new SourceIndexClassVisitor(classEntry), index); @@ -46,7 +46,7 @@ public class SourceIndexClassVisitor extends SourceIndexVisitor { TypeReference ref = node.getUserData(Keys.TYPE_REFERENCE); if (node.getIdentifierToken().getStartLocation() != TextLocation.EMPTY) { ClassEntry classEntry = new ClassEntry(ref.getInternalName()); - index.addReference(node.getIdentifierToken(), classEntry, m_classEntry); + index.addReference(node.getIdentifierToken(), classEntry, this.classEntry); } return recurse(node, index); diff --git a/src/main/java/cuchaz/enigma/analysis/Token.java b/src/main/java/cuchaz/enigma/analysis/Token.java index 0103df2..575c373 100644 --- a/src/main/java/cuchaz/enigma/analysis/Token.java +++ b/src/main/java/cuchaz/enigma/analysis/Token.java @@ -39,10 +39,7 @@ public class Token implements Comparable { @Override public boolean equals(Object other) { - if (other instanceof Token) { - return equals((Token) other); - } - return false; + return other instanceof Token && equals((Token) other); } public boolean equals(Token other) { diff --git a/src/main/java/cuchaz/enigma/analysis/TranslationIndex.java b/src/main/java/cuchaz/enigma/analysis/TranslationIndex.java index 0261a96..f020ae2 100644 --- a/src/main/java/cuchaz/enigma/analysis/TranslationIndex.java +++ b/src/main/java/cuchaz/enigma/analysis/TranslationIndex.java @@ -30,50 +30,47 @@ public class TranslationIndex implements Serializable { private static final long serialVersionUID = 738687982126844179L; - private Map m_superclasses; - private Multimap m_fieldEntries; - private Multimap m_behaviorEntries; - private Multimap m_interfaces; + private Map superclasses; + private Multimap fieldEntries; + private Multimap behaviorEntries; + private Multimap interfaces; public TranslationIndex() { - m_superclasses = Maps.newHashMap(); - m_fieldEntries = HashMultimap.create(); - m_behaviorEntries = HashMultimap.create(); - m_interfaces = HashMultimap.create(); + this.superclasses = Maps.newHashMap(); + this.fieldEntries = HashMultimap.create(); + this.behaviorEntries = HashMultimap.create(); + this.interfaces = HashMultimap.create(); } public TranslationIndex(TranslationIndex other, Translator translator) { // translate the superclasses - m_superclasses = Maps.newHashMap(); - for (Map.Entry mapEntry : other.m_superclasses.entrySet()) { - m_superclasses.put( - translator.translateEntry(mapEntry.getKey()), - translator.translateEntry(mapEntry.getValue()) - ); + this.superclasses = Maps.newHashMap(); + for (Map.Entry mapEntry : other.superclasses.entrySet()) { + this.superclasses.put(translator.translateEntry(mapEntry.getKey()), translator.translateEntry(mapEntry.getValue())); } // translate the interfaces - m_interfaces = HashMultimap.create(); - for (Map.Entry mapEntry : other.m_interfaces.entries()) { - m_interfaces.put( + this.interfaces = HashMultimap.create(); + for (Map.Entry mapEntry : other.interfaces.entries()) { + this.interfaces.put( translator.translateEntry(mapEntry.getKey()), translator.translateEntry(mapEntry.getValue()) ); } // translate the fields - m_fieldEntries = HashMultimap.create(); - for (Map.Entry mapEntry : other.m_fieldEntries.entries()) { - m_fieldEntries.put( + this.fieldEntries = HashMultimap.create(); + for (Map.Entry mapEntry : other.fieldEntries.entries()) { + this.fieldEntries.put( translator.translateEntry(mapEntry.getKey()), translator.translateEntry(mapEntry.getValue()) ); } - m_behaviorEntries = HashMultimap.create(); - for (Map.Entry mapEntry : other.m_behaviorEntries.entries()) { - m_behaviorEntries.put( + this.behaviorEntries = HashMultimap.create(); + for (Map.Entry mapEntry : other.behaviorEntries.entries()) { + this.behaviorEntries.put( translator.translateEntry(mapEntry.getKey()), translator.translateEntry(mapEntry.getValue()) ); @@ -94,14 +91,14 @@ public class TranslationIndex implements Serializable { // add the superclass ClassEntry superclassEntry = EntryFactory.getSuperclassEntry(c); if (superclassEntry != null) { - m_superclasses.put(classEntry, superclassEntry); + this.superclasses.put(classEntry, superclassEntry); } // add the interfaces for (String interfaceClassName : c.getClassFile().getInterfaces()) { ClassEntry interfaceClassEntry = new ClassEntry(Descriptor.toJvmName(interfaceClassName)); if (!isJre(interfaceClassEntry)) { - m_interfaces.put(classEntry, interfaceClassEntry); + this.interfaces.put(classEntry, interfaceClassEntry); } } @@ -109,25 +106,25 @@ public class TranslationIndex implements Serializable { // add fields for (CtField field : c.getDeclaredFields()) { FieldEntry fieldEntry = EntryFactory.getFieldEntry(field); - m_fieldEntries.put(fieldEntry.getClassEntry(), fieldEntry); + this.fieldEntries.put(fieldEntry.getClassEntry(), fieldEntry); } // add behaviors for (CtBehavior behavior : c.getDeclaredBehaviors()) { BehaviorEntry behaviorEntry = EntryFactory.getBehaviorEntry(behavior); - m_behaviorEntries.put(behaviorEntry.getClassEntry(), behaviorEntry); + this.behaviorEntries.put(behaviorEntry.getClassEntry(), behaviorEntry); } } } public void renameClasses(Map renames) { - EntryRenamer.renameClassesInMap(renames, m_superclasses); - EntryRenamer.renameClassesInMultimap(renames, m_fieldEntries); - EntryRenamer.renameClassesInMultimap(renames, m_behaviorEntries); + EntryRenamer.renameClassesInMap(renames, this.superclasses); + EntryRenamer.renameClassesInMultimap(renames,this.fieldEntries); + EntryRenamer.renameClassesInMultimap(renames, this.behaviorEntries); } public ClassEntry getSuperclass(ClassEntry classEntry) { - return m_superclasses.get(classEntry); + return this.superclasses.get(classEntry); } public List getAncestry(ClassEntry classEntry) { @@ -145,7 +142,7 @@ public class TranslationIndex implements Serializable { // linear search is fast enough for now List subclasses = Lists.newArrayList(); - for (Map.Entry entry : m_superclasses.entrySet()) { + for (Map.Entry entry : this.superclasses.entrySet()) { ClassEntry subclass = entry.getKey(); ClassEntry superclass = entry.getValue(); if (classEntry.equals(superclass)) { @@ -170,15 +167,15 @@ public class TranslationIndex implements Serializable { } public Collection> getClassInterfaces() { - return m_interfaces.entries(); + return this.interfaces.entries(); } public Collection getInterfaces(ClassEntry classEntry) { - return m_interfaces.get(classEntry); + return this.interfaces.get(classEntry); } public boolean isInterface(ClassEntry classEntry) { - return m_interfaces.containsValue(classEntry); + return this.interfaces.containsValue(classEntry); } public boolean entryExists(Entry entry) { @@ -193,11 +190,11 @@ public class TranslationIndex implements Serializable { } public boolean fieldExists(FieldEntry fieldEntry) { - return m_fieldEntries.containsEntry(fieldEntry.getClassEntry(), fieldEntry); + return this.fieldEntries.containsEntry(fieldEntry.getClassEntry(), fieldEntry); } public boolean behaviorExists(BehaviorEntry behaviorEntry) { - return m_behaviorEntries.containsEntry(behaviorEntry.getClassEntry(), behaviorEntry); + return this.behaviorEntries.containsEntry(behaviorEntry.getClassEntry(), behaviorEntry); } public ClassEntry resolveEntryClass(Entry entry) { @@ -243,7 +240,7 @@ public class TranslationIndex implements Serializable { // the interfaces for any class is a forest // so let's look at all the trees - for (ClassEntry interfaceEntry : m_interfaces.get(entry.getClassEntry())) { + for (ClassEntry interfaceEntry : this.interfaces.get(entry.getClassEntry())) { ClassEntry resolvedClassEntry = resolveSuperclass(entry.cloneToNewClass(interfaceEntry)); if (resolvedClassEntry != null) { return resolvedClassEntry; @@ -261,9 +258,9 @@ public class TranslationIndex implements Serializable { throws IOException { GZIPOutputStream gzipout = new GZIPOutputStream(out); ObjectOutputStream oout = new ObjectOutputStream(gzipout); - oout.writeObject(m_superclasses); - oout.writeObject(m_fieldEntries); - oout.writeObject(m_behaviorEntries); + oout.writeObject(this.superclasses); + oout.writeObject(this.fieldEntries); + oout.writeObject(this.behaviorEntries); gzipout.finish(); } @@ -272,9 +269,9 @@ public class TranslationIndex implements Serializable { throws IOException { try { ObjectInputStream oin = new ObjectInputStream(new GZIPInputStream(in)); - m_superclasses = (HashMap) oin.readObject(); - m_fieldEntries = (HashMultimap) oin.readObject(); - m_behaviorEntries = (HashMultimap) oin.readObject(); + this.superclasses = (HashMap) oin.readObject(); + this.fieldEntries = (HashMultimap) oin.readObject(); + this.behaviorEntries = (HashMultimap) oin.readObject(); } catch (ClassNotFoundException ex) { throw new Error(ex); } -- cgit v1.2.3