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/CommandMain.java | 1 - src/main/java/cuchaz/enigma/ConvertMain.java | 8 +- src/main/java/cuchaz/enigma/Main.java | 1 + .../java/cuchaz/enigma/MainFormatConverter.java | 2 - .../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 +++++------ .../cuchaz/enigma/bytecode/CheckCastIterator.java | 48 +++--- .../java/cuchaz/enigma/bytecode/ClassRenamer.java | 4 +- .../cuchaz/enigma/bytecode/ClassTranslator.java | 24 +-- .../cuchaz/enigma/bytecode/ConstPoolEditor.java | 102 ++++++------- src/main/java/cuchaz/enigma/bytecode/InfoType.java | 20 +-- .../cuchaz/enigma/bytecode/InnerClassWriter.java | 14 +- .../enigma/bytecode/LocalVariableRenamer.java | 6 +- .../enigma/bytecode/MethodParameterWriter.java | 6 +- .../bytecode/accessors/ClassInfoAccessor.java | 40 ++--- .../bytecode/accessors/ConstInfoAccessor.java | 54 +++---- .../accessors/InvokeDynamicInfoAccessor.java | 49 +++--- .../bytecode/accessors/MemberRefInfoAccessor.java | 50 +++--- .../accessors/MethodHandleInfoAccessor.java | 50 +++--- .../bytecode/accessors/MethodTypeInfoAccessor.java | 41 ++--- .../accessors/NameAndTypeInfoAccessor.java | 50 +++--- .../bytecode/accessors/StringInfoAccessor.java | 40 ++--- .../bytecode/accessors/Utf8InfoAccessor.java | 6 +- .../java/cuchaz/enigma/convert/ClassForest.java | 18 +-- .../cuchaz/enigma/convert/ClassIdentifier.java | 28 ++-- .../java/cuchaz/enigma/convert/ClassIdentity.java | 167 ++++++++++----------- .../java/cuchaz/enigma/convert/ClassMatch.java | 8 +- .../java/cuchaz/enigma/convert/ClassMatches.java | 2 +- .../java/cuchaz/enigma/convert/ClassMatching.java | 2 +- .../java/cuchaz/enigma/convert/ClassNamer.java | 16 +- src/main/java/cuchaz/enigma/gui/GuiController.java | 1 - .../java/cuchaz/enigma/json/JsonConstructor.java | 2 +- src/main/java/cuchaz/enigma/json/JsonField.java | 8 +- .../java/cuchaz/enigma/mapping/ClassEntry.java | 5 +- .../java/cuchaz/enigma/mapping/ClassMapping.java | 6 +- .../java/cuchaz/enigma/mapping/FieldEntry.java | 5 +- .../cuchaz/enigma/mapping/MappingsChecker.java | 2 - .../java/cuchaz/enigma/mapping/MappingsReader.java | 6 +- .../java/cuchaz/enigma/mapping/MappingsWriter.java | 1 - .../java/cuchaz/enigma/mapping/MethodEntry.java | 5 +- .../java/cuchaz/enigma/mapping/MethodMapping.java | 71 +++++---- src/test/java/cuchaz/enigma/TestTranslator.java | 46 +++--- 56 files changed, 773 insertions(+), 837 deletions(-) diff --git a/src/main/java/cuchaz/enigma/CommandMain.java b/src/main/java/cuchaz/enigma/CommandMain.java index 69f56849..b715c6e2 100644 --- a/src/main/java/cuchaz/enigma/CommandMain.java +++ b/src/main/java/cuchaz/enigma/CommandMain.java @@ -11,7 +11,6 @@ package cuchaz.enigma; import java.io.File; -import java.io.FileReader; import java.util.jar.JarFile; import cuchaz.enigma.Deobfuscator.ProgressListener; diff --git a/src/main/java/cuchaz/enigma/ConvertMain.java b/src/main/java/cuchaz/enigma/ConvertMain.java index 409a2692..a68ab614 100644 --- a/src/main/java/cuchaz/enigma/ConvertMain.java +++ b/src/main/java/cuchaz/enigma/ConvertMain.java @@ -11,8 +11,6 @@ package cuchaz.enigma; import java.io.File; -import java.io.FileReader; -import java.io.FileWriter; import java.io.IOException; import java.util.jar.JarFile; @@ -42,7 +40,7 @@ public class ConvertMain { //Get the mapping files File inMappingsFile = new File(OldMappings); File outMappingsFile = new File(NewMappings); - Mappings mappings = new MappingsReader().read( inMappingsFile); + Mappings mappings = new MappingsReader().read(inMappingsFile); //Make the Match Files.. File classMatchesFile = new File(ClassMatches); File fieldMatchesFile = new File(FieldMatches); @@ -187,7 +185,7 @@ public class ConvertMain { checker.dropBrokenMappings(destMappings); deobfuscators.dest.setMappings(destMappings); - new MemberMatchingGui(classMatches, fieldMatches, deobfuscators.source, deobfuscators.dest).setSaveListener(new MemberMatchingGui.SaveListener() { + new MemberMatchingGui<>(classMatches, fieldMatches, deobfuscators.source, deobfuscators.dest).setSaveListener(new MemberMatchingGui.SaveListener() { @Override public void save(MemberMatches matches) { try { @@ -260,7 +258,7 @@ public class ConvertMain { checker.dropBrokenMappings(destMappings); deobfuscators.dest.setMappings(destMappings); - new MemberMatchingGui(classMatches, methodMatches, deobfuscators.source, deobfuscators.dest).setSaveListener(new MemberMatchingGui.SaveListener() { + new MemberMatchingGui<>(classMatches, methodMatches, deobfuscators.source, deobfuscators.dest).setSaveListener(new MemberMatchingGui.SaveListener() { @Override public void save(MemberMatches matches) { try { diff --git a/src/main/java/cuchaz/enigma/Main.java b/src/main/java/cuchaz/enigma/Main.java index b135de77..d52e390a 100644 --- a/src/main/java/cuchaz/enigma/Main.java +++ b/src/main/java/cuchaz/enigma/Main.java @@ -12,6 +12,7 @@ package cuchaz.enigma; import java.io.File; import java.util.jar.JarFile; + import javax.swing.UIManager; import cuchaz.enigma.gui.Gui; diff --git a/src/main/java/cuchaz/enigma/MainFormatConverter.java b/src/main/java/cuchaz/enigma/MainFormatConverter.java index 29e334ec..712b0f89 100644 --- a/src/main/java/cuchaz/enigma/MainFormatConverter.java +++ b/src/main/java/cuchaz/enigma/MainFormatConverter.java @@ -13,8 +13,6 @@ package cuchaz.enigma; import com.google.common.collect.Maps; import java.io.File; -import java.io.FileReader; -import java.io.FileWriter; import java.lang.reflect.Field; import java.util.Map; import java.util.jar.JarFile; diff --git a/src/main/java/cuchaz/enigma/analysis/BehaviorReferenceTreeNode.java b/src/main/java/cuchaz/enigma/analysis/BehaviorReferenceTreeNode.java index 776f0909..39ff449e 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 1df76255..cd185846 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 8f8986c1..3420cd6d 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 ca2b8215..beac9d5d 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 eb58388c..6a7a4bf0 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 b99537cc..9c3d051b 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 4b302e05..05d9c13f 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 17a17151..04004270 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 848d8511..8b30f9eb 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 2ee3ec1f..1cf80d91 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 cf42ac77..a3bed6ed 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 a20fbb44..cbc2945c 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 e2b567e8..4a468e7e 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 0a3bad51..06ce042b 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 0103df2e..575c373f 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 0261a96a..f020ae2c 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); } diff --git a/src/main/java/cuchaz/enigma/bytecode/CheckCastIterator.java b/src/main/java/cuchaz/enigma/bytecode/CheckCastIterator.java index 8058d0ea..19c39d3c 100644 --- a/src/main/java/cuchaz/enigma/bytecode/CheckCastIterator.java +++ b/src/main/java/cuchaz/enigma/bytecode/CheckCastIterator.java @@ -31,29 +31,29 @@ public class CheckCastIterator implements Iterator { } } - private ConstPool m_constants; - private CodeAttribute m_attribute; - private CodeIterator m_iter; - private CheckCast m_next; + private ConstPool constants; + private CodeAttribute attribute; + private CodeIterator iter; + private CheckCast next; public CheckCastIterator(CodeAttribute codeAttribute) throws BadBytecode { - m_constants = codeAttribute.getConstPool(); - m_attribute = codeAttribute; - m_iter = m_attribute.iterator(); + this.constants = codeAttribute.getConstPool(); + this.attribute = codeAttribute; + this.iter = this.attribute.iterator(); - m_next = getNext(); + this.next = getNext(); } @Override public boolean hasNext() { - return m_next != null; + return this.next != null; } @Override public CheckCast next() { - CheckCast out = m_next; + CheckCast out = this.next; try { - m_next = getNext(); + this.next = getNext(); } catch (BadBytecode ex) { throw new Error(ex); } @@ -67,16 +67,16 @@ public class CheckCastIterator implements Iterator { private CheckCast getNext() throws BadBytecode { int prevPos = 0; - while (m_iter.hasNext()) { - int pos = m_iter.next(); - int opcode = m_iter.byteAt(pos); + while (this.iter.hasNext()) { + int pos = this.iter.next(); + int opcode = this.iter.byteAt(pos); switch (opcode) { case Opcode.CHECKCAST: // get the type of this op code (next two bytes are a classinfo index) MethodEntry prevMethodEntry = getMethodEntry(prevPos); if (prevMethodEntry != null) { - return new CheckCast(m_constants.getClassInfo(m_iter.s16bitAt(pos + 1)), prevMethodEntry); + return new CheckCast(this.constants.getClassInfo(this.iter.s16bitAt(pos + 1)), prevMethodEntry); } break; } @@ -86,25 +86,25 @@ public class CheckCastIterator implements Iterator { } private MethodEntry getMethodEntry(int pos) { - switch (m_iter.byteAt(pos)) { + switch (this.iter.byteAt(pos)) { case Opcode.INVOKEVIRTUAL: case Opcode.INVOKESTATIC: case Opcode.INVOKEDYNAMIC: case Opcode.INVOKESPECIAL: { - int index = m_iter.s16bitAt(pos + 1); + int index = this.iter.s16bitAt(pos + 1); return new MethodEntry( - new ClassEntry(Descriptor.toJvmName(m_constants.getMethodrefClassName(index))), - m_constants.getMethodrefName(index), - new Signature(m_constants.getMethodrefType(index)) + new ClassEntry(Descriptor.toJvmName(this.constants.getMethodrefClassName(index))), + this.constants.getMethodrefName(index), + new Signature(this.constants.getMethodrefType(index)) ); } case Opcode.INVOKEINTERFACE: { - int index = m_iter.s16bitAt(pos + 1); + int index = this.iter.s16bitAt(pos + 1); return new MethodEntry( - new ClassEntry(Descriptor.toJvmName(m_constants.getInterfaceMethodrefClassName(index))), - m_constants.getInterfaceMethodrefName(index), - new Signature(m_constants.getInterfaceMethodrefType(index)) + new ClassEntry(Descriptor.toJvmName(this.constants.getInterfaceMethodrefClassName(index))), + this.constants.getInterfaceMethodrefName(index), + new Signature(this.constants.getInterfaceMethodrefType(index)) ); } } diff --git a/src/main/java/cuchaz/enigma/bytecode/ClassRenamer.java b/src/main/java/cuchaz/enigma/bytecode/ClassRenamer.java index 548bea75..d8e79711 100644 --- a/src/main/java/cuchaz/enigma/bytecode/ClassRenamer.java +++ b/src/main/java/cuchaz/enigma/bytecode/ClassRenamer.java @@ -51,8 +51,6 @@ public class ClassRenamer { private static class ReplacerClassMap extends HashMap { - private static final long serialVersionUID = 317915213205066168L; - private ClassNameReplacer m_replacer; public ReplacerClassMap(ClassNameReplacer replacer) { @@ -151,7 +149,7 @@ public class ClassRenamer { } /* DEBUG - System.out.println(String.format("\tDEOBF: %s-> ATTR: %s,%s,%s", classEntry, attr.outerClass(i), attr.innerClass(i), attr.innerName(i))); + System.out.println(String.format("\tDEOBF: %s-> ATTR: %s,%s,%s", classEntry, attr.outerClass(i), attr.innerClass(i), attr.innerName(i))); */ } } diff --git a/src/main/java/cuchaz/enigma/bytecode/ClassTranslator.java b/src/main/java/cuchaz/enigma/bytecode/ClassTranslator.java index ef197cbe..8fdd8513 100644 --- a/src/main/java/cuchaz/enigma/bytecode/ClassTranslator.java +++ b/src/main/java/cuchaz/enigma/bytecode/ClassTranslator.java @@ -22,10 +22,10 @@ import javassist.bytecode.SourceFileAttribute; public class ClassTranslator { - private Translator m_translator; + private Translator translator; public ClassTranslator(Translator translator) { - m_translator = translator; + this.translator = translator; } public void translate(CtClass c) { @@ -46,7 +46,7 @@ public class ClassTranslator { constants.getFieldrefName(i), constants.getFieldrefType(i) ); - FieldEntry translatedEntry = m_translator.translateEntry(entry); + FieldEntry translatedEntry = this.translator.translateEntry(entry); if (!entry.equals(translatedEntry)) { editor.changeMemberrefNameAndType(i, translatedEntry.getName(), translatedEntry.getType().toString()); } @@ -62,7 +62,7 @@ public class ClassTranslator { editor.getMemberrefName(i), editor.getMemberrefType(i) ); - BehaviorEntry translatedEntry = m_translator.translateEntry(entry); + BehaviorEntry translatedEntry = this.translator.translateEntry(entry); if (!entry.equals(translatedEntry)) { editor.changeMemberrefNameAndType(i, translatedEntry.getName(), translatedEntry.getSignature().toString()); } @@ -78,13 +78,13 @@ public class ClassTranslator { // translate the name FieldEntry entry = EntryFactory.getFieldEntry(field); - String translatedName = m_translator.translate(entry); + String translatedName = this.translator.translate(entry); if (translatedName != null) { field.setName(translatedName); } // translate the type - Type translatedType = m_translator.translateType(entry.getType()); + Type translatedType = this.translator.translateType(entry.getType()); field.getFieldInfo().setDescriptor(translatedType.toString()); } @@ -97,7 +97,7 @@ public class ClassTranslator { CtMethod method = (CtMethod) behavior; // translate the name - String translatedName = m_translator.translate(entry); + String translatedName = this.translator.translate(entry); if (translatedName != null) { method.setName(translatedName); } @@ -105,7 +105,7 @@ public class ClassTranslator { if (entry.getSignature() != null) { // translate the signature - Signature translatedSignature = m_translator.translateSignature(entry.getSignature()); + Signature translatedSignature = this.translator.translateSignature(entry.getSignature()); behavior.getMethodInfo().setDescriptor(translatedSignature.toString()); } } @@ -116,7 +116,7 @@ public class ClassTranslator { if (enclosingMethodAttr.methodIndex() == 0) { BehaviorEntry obfBehaviorEntry = EntryFactory.getBehaviorEntry(Descriptor.toJvmName(enclosingMethodAttr.className())); - BehaviorEntry deobfBehaviorEntry = m_translator.translateEntry(obfBehaviorEntry); + BehaviorEntry deobfBehaviorEntry = this.translator.translateEntry(obfBehaviorEntry); c.getClassFile().addAttribute(new EnclosingMethodAttribute( constants, deobfBehaviorEntry.getClassName() @@ -127,7 +127,7 @@ public class ClassTranslator { enclosingMethodAttr.methodName(), enclosingMethodAttr.methodDescriptor() ); - BehaviorEntry deobfBehaviorEntry = m_translator.translateEntry(obfBehaviorEntry); + BehaviorEntry deobfBehaviorEntry = this.translator.translateEntry(obfBehaviorEntry); c.getClassFile().addAttribute(new EnclosingMethodAttribute( constants, deobfBehaviorEntry.getClassName(), @@ -139,10 +139,10 @@ public class ClassTranslator { // translate all the class names referenced in the code // the above code only changed method/field/reference names and types, but not the rest of the class references - ClassRenamer.renameClasses(c, m_translator); + ClassRenamer.renameClasses(c, this.translator); // translate the source file attribute too - ClassEntry deobfClassEntry = m_translator.translateEntry(classEntry); + ClassEntry deobfClassEntry = this.translator.translateEntry(classEntry); if (deobfClassEntry != null) { String sourceFile = Descriptor.toJvmName(deobfClassEntry.getOutermostClassEntry().getSimpleName()) + ".java"; c.getClassFile().addAttribute(new SourceFileAttribute(constants, sourceFile)); diff --git a/src/main/java/cuchaz/enigma/bytecode/ConstPoolEditor.java b/src/main/java/cuchaz/enigma/bytecode/ConstPoolEditor.java index 0082a72c..256df61e 100644 --- a/src/main/java/cuchaz/enigma/bytecode/ConstPoolEditor.java +++ b/src/main/java/cuchaz/enigma/bytecode/ConstPoolEditor.java @@ -25,62 +25,62 @@ import javassist.bytecode.Descriptor; public class ConstPoolEditor { - private static Method m_getItem; - private static Method m_addItem; - private static Method m_addItem0; - private static Field m_items; - private static Field m_cache; - private static Field m_numItems; - private static Field m_objects; - private static Field m_elements; - private static Method m_methodWritePool; - private static Constructor m_constructorPool; + private static Method getItem; + private static Method addItem; + private static Method addItem0; + private static Field items; + private static Field cache; + private static Field numItems; + private static Field objects; + private static Field elements; + private static Method methodWritePool; + private static Constructor constructorPool; static { try { - m_getItem = ConstPool.class.getDeclaredMethod("getItem", int.class); - m_getItem.setAccessible(true); + getItem = ConstPool.class.getDeclaredMethod("getItem", int.class); + getItem.setAccessible(true); - m_addItem = ConstPool.class.getDeclaredMethod("addItem", Class.forName("javassist.bytecode.ConstInfo")); - m_addItem.setAccessible(true); + addItem = ConstPool.class.getDeclaredMethod("addItem", Class.forName("javassist.bytecode.ConstInfo")); + addItem.setAccessible(true); - m_addItem0 = ConstPool.class.getDeclaredMethod("addItem0", Class.forName("javassist.bytecode.ConstInfo")); - m_addItem0.setAccessible(true); + addItem0 = ConstPool.class.getDeclaredMethod("addItem0", Class.forName("javassist.bytecode.ConstInfo")); + addItem0.setAccessible(true); - m_items = ConstPool.class.getDeclaredField("items"); - m_items.setAccessible(true); + items = ConstPool.class.getDeclaredField("items"); + items.setAccessible(true); - m_cache = ConstPool.class.getDeclaredField("itemsCache"); - m_cache.setAccessible(true); + cache = ConstPool.class.getDeclaredField("itemsCache"); + cache.setAccessible(true); - m_numItems = ConstPool.class.getDeclaredField("numOfItems"); - m_numItems.setAccessible(true); + numItems = ConstPool.class.getDeclaredField("numOfItems"); + numItems.setAccessible(true); - m_objects = Class.forName("javassist.bytecode.LongVector").getDeclaredField("objects"); - m_objects.setAccessible(true); + objects = Class.forName("javassist.bytecode.LongVector").getDeclaredField("objects"); + objects.setAccessible(true); - m_elements = Class.forName("javassist.bytecode.LongVector").getDeclaredField("elements"); - m_elements.setAccessible(true); + elements = Class.forName("javassist.bytecode.LongVector").getDeclaredField("elements"); + elements.setAccessible(true); - m_methodWritePool = ConstPool.class.getDeclaredMethod("write", DataOutputStream.class); - m_methodWritePool.setAccessible(true); + methodWritePool = ConstPool.class.getDeclaredMethod("write", DataOutputStream.class); + methodWritePool.setAccessible(true); - m_constructorPool = ConstPool.class.getDeclaredConstructor(DataInputStream.class); - m_constructorPool.setAccessible(true); + constructorPool = ConstPool.class.getDeclaredConstructor(DataInputStream.class); + constructorPool.setAccessible(true); } catch (Exception ex) { throw new Error(ex); } } - private ConstPool m_pool; + private ConstPool pool; public ConstPoolEditor(ConstPool pool) { - m_pool = pool; + this.pool = pool; } public void writePool(DataOutputStream out) { try { - m_methodWritePool.invoke(m_pool, out); + methodWritePool.invoke(this.pool, out); } catch (Exception ex) { throw new Error(ex); } @@ -88,27 +88,27 @@ public class ConstPoolEditor { public static ConstPool readPool(DataInputStream in) { try { - return m_constructorPool.newInstance(in); + return constructorPool.newInstance(in); } catch (Exception ex) { throw new Error(ex); } } public String getMemberrefClassname(int memberrefIndex) { - return Descriptor.toJvmName(m_pool.getClassInfo(m_pool.getMemberClass(memberrefIndex))); + return Descriptor.toJvmName(this.pool.getClassInfo(this.pool.getMemberClass(memberrefIndex))); } public String getMemberrefName(int memberrefIndex) { - return m_pool.getUtf8Info(m_pool.getNameAndTypeName(m_pool.getMemberNameAndType(memberrefIndex))); + return this.pool.getUtf8Info(this.pool.getNameAndTypeName(this.pool.getMemberNameAndType(memberrefIndex))); } public String getMemberrefType(int memberrefIndex) { - return m_pool.getUtf8Info(m_pool.getNameAndTypeDescriptor(m_pool.getMemberNameAndType(memberrefIndex))); + return this.pool.getUtf8Info(this.pool.getNameAndTypeDescriptor(this.pool.getMemberNameAndType(memberrefIndex))); } public ConstInfoAccessor getItem(int index) { try { - Object entry = m_getItem.invoke(m_pool, index); + Object entry = getItem.invoke(this.pool, index); if (entry == null) { return null; } @@ -120,7 +120,7 @@ public class ConstPoolEditor { public int addItem(Object item) { try { - return (Integer) m_addItem.invoke(m_pool, item); + return (Integer) addItem.invoke(this.pool, item); } catch (Exception ex) { throw new Error(ex); } @@ -128,7 +128,7 @@ public class ConstPoolEditor { public int addItemForceNew(Object item) { try { - return (Integer) m_addItem0.invoke(m_pool, item); + return (Integer) addItem0.invoke(this.pool, item); } catch (Exception ex) { throw new Error(ex); } @@ -140,22 +140,22 @@ public class ConstPoolEditor { // remove the item from the cache HashMap cache = getCache(); if (cache != null) { - Object item = getItem(m_pool.getSize() - 1); + Object item = getItem(this.pool.getSize() - 1); cache.remove(item); } // remove the actual item // based off of LongVector.addElement() - Object items = m_items.get(m_pool); - Object[][] objects = (Object[][]) m_objects.get(items); - int numElements = (Integer) m_elements.get(items) - 1; + Object item = items.get(this.pool); + Object[][] object = (Object[][]) objects.get(items); + int numElements = (Integer) elements.get(items) - 1; int nth = numElements >> 7; int offset = numElements & (128 - 1); - objects[nth][offset] = null; + object[nth][offset] = null; // decrement the number of items - m_elements.set(items, numElements); - m_numItems.set(m_pool, (Integer) m_numItems.get(m_pool) - 1); + elements.set(item, numElements); + numItems.set(this.pool, (Integer) numItems.get(this.pool) - 1); } catch (Exception ex) { throw new Error(ex); } @@ -164,7 +164,7 @@ public class ConstPoolEditor { @SuppressWarnings("rawtypes") public HashMap getCache() { try { - return (HashMap) m_cache.get(m_pool); + return (HashMap) cache.get(this.pool); } catch (Exception ex) { throw new Error(ex); } @@ -183,7 +183,7 @@ public class ConstPoolEditor { cache.remove(item); } - new MemberRefInfoAccessor(item).setNameAndTypeIndex(m_pool.addNameAndTypeInfo(newName, newType)); + new MemberRefInfoAccessor(item).setNameAndTypeIndex(this.pool.addNameAndTypeInfo(newName, newType)); // update the cache if (cache != null) { @@ -212,7 +212,7 @@ public class ConstPoolEditor { } // add the new name and repoint the name-and-type to it - new ClassInfoAccessor(item).setNameIndex(m_pool.addUtf8Info(newName)); + new ClassInfoAccessor(item).setNameIndex(this.pool.addUtf8Info(newName)); // update the cache if (cache != null) { @@ -252,7 +252,7 @@ public class ConstPoolEditor { public String dump() { StringBuilder buf = new StringBuilder(); - for (int i = 1; i < m_pool.getSize(); i++) { + for (int i = 1; i < this.pool.getSize(); i++) { buf.append(String.format("%4d", i)); buf.append(" "); buf.append(getItem(i).toString()); diff --git a/src/main/java/cuchaz/enigma/bytecode/InfoType.java b/src/main/java/cuchaz/enigma/bytecode/InfoType.java index 89940d9e..86e57ab5 100644 --- a/src/main/java/cuchaz/enigma/bytecode/InfoType.java +++ b/src/main/java/cuchaz/enigma/bytecode/InfoType.java @@ -213,29 +213,29 @@ public enum InfoType { } }; - private static Map m_types; + private static Map types; static { - m_types = Maps.newTreeMap(); + types = Maps.newTreeMap(); for (InfoType type : values()) { - m_types.put(type.getTag(), type); + types.put(type.getTag(), type); } } - private int m_tag; - private int m_level; + private int tag; + private int level; InfoType(int tag, int level) { - m_tag = tag; - m_level = level; + this.tag = tag; + this.level = level; } public int getTag() { - return m_tag; + return this.tag; } public int getLevel() { - return m_level; + return this.level; } public void gatherIndexTree(Collection indices, ConstPoolEditor editor, ConstInfoAccessor entry) { @@ -260,7 +260,7 @@ public enum InfoType { } public static InfoType getByTag(int tag) { - return m_types.get(tag); + return types.get(tag); } public static List getByLevel(int level) { diff --git a/src/main/java/cuchaz/enigma/bytecode/InnerClassWriter.java b/src/main/java/cuchaz/enigma/bytecode/InnerClassWriter.java index 25ac7d67..6d926106 100644 --- a/src/main/java/cuchaz/enigma/bytecode/InnerClassWriter.java +++ b/src/main/java/cuchaz/enigma/bytecode/InnerClassWriter.java @@ -27,10 +27,10 @@ import javassist.bytecode.InnerClassesAttribute; public class InnerClassWriter { - private JarIndex m_index; + private JarIndex index; public InnerClassWriter(JarIndex index) { - m_index = index; + this.index = index; } public void write(CtClass c) { @@ -43,7 +43,7 @@ public class InnerClassWriter { } ClassEntry obfClassEntry = EntryFactory.getClassEntry(c); - List obfClassChain = m_index.getObfClassChain(obfClassEntry); + List obfClassChain = this.index.getObfClassChain(obfClassEntry); boolean isInnerClass = obfClassChain.size() > 1; if (isInnerClass) { @@ -51,7 +51,7 @@ public class InnerClassWriter { // it's an inner class, rename it to the fully qualified name c.setName(obfClassEntry.buildClassEntry(obfClassChain).getName()); - BehaviorEntry caller = m_index.getAnonymousClassCaller(obfClassEntry); + BehaviorEntry caller = this.index.getAnonymousClassCaller(obfClassEntry); if (caller != null) { // write the enclosing method attribute @@ -64,7 +64,7 @@ public class InnerClassWriter { } // does this class have any inner classes? - Collection obfInnerClassEntries = m_index.getInnerClasses(obfClassEntry); + Collection obfInnerClassEntries = this.index.getInnerClasses(obfClassEntry); if (isInnerClass || !obfInnerClassEntries.isEmpty()) { @@ -112,14 +112,14 @@ public class InnerClassWriter { int innerClassNameIndex = 0; int accessFlags = AccessFlag.PUBLIC; // TODO: need to figure out if we can put static or not - if (!m_index.isAnonymousClass(obfClassEntry)) { + if (!this.index.isAnonymousClass(obfClassEntry)) { innerClassNameIndex = constPool.addUtf8Info(obfInnerClassEntry.getInnermostClassName()); } attr.append(innerClassIndex, parentClassIndex, innerClassNameIndex, accessFlags); /* DEBUG - System.out.println(String.format("\tOBF: %s -> ATTR: %s,%s,%s (replace %s with %s)", + System.out.println(String.format("\tOBF: %s -> ATTR: %s,%s,%s (replace %s with %s)", obfClassEntry, attr.innerClass(attr.tableLength() - 1), attr.outerClass(attr.tableLength() - 1), diff --git a/src/main/java/cuchaz/enigma/bytecode/LocalVariableRenamer.java b/src/main/java/cuchaz/enigma/bytecode/LocalVariableRenamer.java index d0ce107f..8edea16e 100644 --- a/src/main/java/cuchaz/enigma/bytecode/LocalVariableRenamer.java +++ b/src/main/java/cuchaz/enigma/bytecode/LocalVariableRenamer.java @@ -21,10 +21,10 @@ import javassist.bytecode.*; public class LocalVariableRenamer { - private Translator m_translator; + private Translator translator; public LocalVariableRenamer(Translator translator) { - m_translator = translator; + this.translator = translator; } public void rename(CtClass c) { @@ -81,7 +81,7 @@ public class LocalVariableRenamer { numArgs = behaviorEntry.getSignature().getArgumentTypes().size(); for (int i = starti; i < starti + numArgs && i < table.tableLength(); i++) { int argi = i - starti; - String argName = m_translator.translate(new ArgumentEntry(behaviorEntry, argi, "")); + String argName = this.translator.translate(new ArgumentEntry(behaviorEntry, argi, "")); if (argName == null) { argName = "a" + (argi + 1); } diff --git a/src/main/java/cuchaz/enigma/bytecode/MethodParameterWriter.java b/src/main/java/cuchaz/enigma/bytecode/MethodParameterWriter.java index e53e8e70..17ecbbe9 100644 --- a/src/main/java/cuchaz/enigma/bytecode/MethodParameterWriter.java +++ b/src/main/java/cuchaz/enigma/bytecode/MethodParameterWriter.java @@ -21,10 +21,10 @@ import javassist.bytecode.LocalVariableAttribute; public class MethodParameterWriter { - private Translator m_translator; + private Translator translator; public MethodParameterWriter(Translator translator) { - m_translator = translator; + this.translator = translator; } public void writeMethodArguments(CtClass c) { @@ -56,7 +56,7 @@ public class MethodParameterWriter { // get the list of argument names List names = new ArrayList(numParams); for (int i = 0; i < numParams; i++) { - names.add(m_translator.translate(new ArgumentEntry(behaviorEntry, i, ""))); + names.add(this.translator.translate(new ArgumentEntry(behaviorEntry, i, ""))); } // save the mappings to the class diff --git a/src/main/java/cuchaz/enigma/bytecode/accessors/ClassInfoAccessor.java b/src/main/java/cuchaz/enigma/bytecode/accessors/ClassInfoAccessor.java index fd987f53..66f22839 100644 --- a/src/main/java/cuchaz/enigma/bytecode/accessors/ClassInfoAccessor.java +++ b/src/main/java/cuchaz/enigma/bytecode/accessors/ClassInfoAccessor.java @@ -14,32 +14,18 @@ import java.lang.reflect.Field; public class ClassInfoAccessor { - private static Class m_class; - private static Field m_nameIndex; + private Object item; - static { - try { - m_class = Class.forName("javassist.bytecode.ClassInfo"); - m_nameIndex = m_class.getDeclaredField("name"); - m_nameIndex.setAccessible(true); - } catch (Exception ex) { - throw new Error(ex); - } - } - - public static boolean isType(ConstInfoAccessor accessor) { - return m_class.isAssignableFrom(accessor.getItem().getClass()); - } - - private Object m_item; + private static Class clazz; + private static Field nameIndex; public ClassInfoAccessor(Object item) { - m_item = item; + this.item = item; } public int getNameIndex() { try { - return (Integer) m_nameIndex.get(m_item); + return (Integer) nameIndex.get(this.item); } catch (Exception ex) { throw new Error(ex); } @@ -47,7 +33,21 @@ public class ClassInfoAccessor { public void setNameIndex(int val) { try { - m_nameIndex.set(m_item, val); + nameIndex.set(this.item, val); + } catch (Exception ex) { + throw new Error(ex); + } + } + + public static boolean isType(ConstInfoAccessor accessor) { + return clazz.isAssignableFrom(accessor.getItem().getClass()); + } + + static { + try { + clazz = Class.forName("javassist.bytecode.ClassInfo"); + nameIndex = clazz.getDeclaredField("name"); + nameIndex.setAccessible(true); } catch (Exception ex) { throw new Error(ex); } diff --git a/src/main/java/cuchaz/enigma/bytecode/accessors/ConstInfoAccessor.java b/src/main/java/cuchaz/enigma/bytecode/accessors/ConstInfoAccessor.java index 2692c069..ea775e9c 100644 --- a/src/main/java/cuchaz/enigma/bytecode/accessors/ConstInfoAccessor.java +++ b/src/main/java/cuchaz/enigma/bytecode/accessors/ConstInfoAccessor.java @@ -19,29 +19,17 @@ import cuchaz.enigma.bytecode.InfoType; public class ConstInfoAccessor { - private static Class m_class; - private static Field m_index; - private static Method m_getTag; + private static Class clazz; + private static Field index; + private static Method getTag; - static { - try { - m_class = Class.forName("javassist.bytecode.ConstInfo"); - m_index = m_class.getDeclaredField("index"); - m_index.setAccessible(true); - m_getTag = m_class.getMethod("getTag"); - m_getTag.setAccessible(true); - } catch (Exception ex) { - throw new Error(ex); - } - } - - private Object m_item; + private Object item; public ConstInfoAccessor(Object item) { if (item == null) { throw new IllegalArgumentException("item cannot be null!"); } - m_item = item; + this.item = item; } public ConstInfoAccessor(DataInputStream in) throws IOException { @@ -56,7 +44,7 @@ public class ConstInfoAccessor { Constructor constructor = Class.forName(className).getConstructor(DataInputStream.class, int.class); constructor.setAccessible(true); - m_item = constructor.newInstance(in, oldIndex); + this.item = constructor.newInstance(in, oldIndex); } catch (IOException ex) { throw ex; } catch (Exception ex) { @@ -65,12 +53,12 @@ public class ConstInfoAccessor { } public Object getItem() { - return m_item; + return this.item; } public int getIndex() { try { - return (Integer) m_index.get(m_item); + return (Integer) index.get(this.item); } catch (Exception ex) { throw new Error(ex); } @@ -78,7 +66,7 @@ public class ConstInfoAccessor { public void setIndex(int val) { try { - m_index.set(m_item, val); + index.set(this.item, val); } catch (Exception ex) { throw new Error(ex); } @@ -86,7 +74,7 @@ public class ConstInfoAccessor { public int getTag() { try { - return (Integer) m_getTag.invoke(m_item); + return (Integer) getTag.invoke(this.item); } catch (Exception ex) { throw new Error(ex); } @@ -117,12 +105,12 @@ public class ConstInfoAccessor { public void write(DataOutputStream out) throws IOException { try { - out.writeUTF(m_item.getClass().getName()); + out.writeUTF(this.item.getClass().getName()); out.writeInt(getIndex()); - Method method = m_item.getClass().getMethod("write", DataOutputStream.class); + Method method = this.item.getClass().getMethod("write", DataOutputStream.class); method.setAccessible(true); - method.invoke(m_item, out); + method.invoke(this.item, out); } catch (IOException ex) { throw ex; } catch (Exception ex) { @@ -135,9 +123,9 @@ public class ConstInfoAccessor { try { ByteArrayOutputStream buf = new ByteArrayOutputStream(); PrintWriter out = new PrintWriter(buf); - Method print = m_item.getClass().getMethod("print", PrintWriter.class); + Method print = this.item.getClass().getMethod("print", PrintWriter.class); print.setAccessible(true); - print.invoke(m_item, out); + print.invoke(this.item, out); out.close(); return buf.toString().replace("\n", ""); } catch (Exception ex) { @@ -148,4 +136,16 @@ public class ConstInfoAccessor { public InfoType getType() { return InfoType.getByTag(getTag()); } + + static { + try { + clazz = Class.forName("javassist.bytecode.ConstInfo"); + index = clazz.getDeclaredField("index"); + index.setAccessible(true); + getTag = clazz.getMethod("getTag"); + getTag.setAccessible(true); + } catch (Exception ex) { + throw new Error(ex); + } + } } diff --git a/src/main/java/cuchaz/enigma/bytecode/accessors/InvokeDynamicInfoAccessor.java b/src/main/java/cuchaz/enigma/bytecode/accessors/InvokeDynamicInfoAccessor.java index 0ca82b78..69aee160 100644 --- a/src/main/java/cuchaz/enigma/bytecode/accessors/InvokeDynamicInfoAccessor.java +++ b/src/main/java/cuchaz/enigma/bytecode/accessors/InvokeDynamicInfoAccessor.java @@ -14,35 +14,20 @@ import java.lang.reflect.Field; public class InvokeDynamicInfoAccessor { - private static Class m_class; - private static Field m_bootstrapIndex; - private static Field m_nameAndTypeIndex; + private static Class clazz; + private static Field bootstrapIndex; + private static Field nameAndTypeIndex; - static { - try { - m_class = Class.forName("javassist.bytecode.InvokeDynamicInfo"); - m_bootstrapIndex = m_class.getDeclaredField("bootstrap"); - m_bootstrapIndex.setAccessible(true); - m_nameAndTypeIndex = m_class.getDeclaredField("nameAndType"); - m_nameAndTypeIndex.setAccessible(true); - } catch (Exception ex) { - throw new Error(ex); - } - } - public static boolean isType(ConstInfoAccessor accessor) { - return m_class.isAssignableFrom(accessor.getItem().getClass()); - } - - private Object m_item; + private Object item; public InvokeDynamicInfoAccessor(Object item) { - m_item = item; + this.item = item; } public int getBootstrapIndex() { try { - return (Integer) m_bootstrapIndex.get(m_item); + return (Integer) bootstrapIndex.get(this.item); } catch (Exception ex) { throw new Error(ex); } @@ -50,7 +35,7 @@ public class InvokeDynamicInfoAccessor { public void setBootstrapIndex(int val) { try { - m_bootstrapIndex.set(m_item, val); + bootstrapIndex.set(this.item, val); } catch (Exception ex) { throw new Error(ex); } @@ -58,7 +43,7 @@ public class InvokeDynamicInfoAccessor { public int getNameAndTypeIndex() { try { - return (Integer) m_nameAndTypeIndex.get(m_item); + return (Integer) nameAndTypeIndex.get(this.item); } catch (Exception ex) { throw new Error(ex); } @@ -66,7 +51,23 @@ public class InvokeDynamicInfoAccessor { public void setNameAndTypeIndex(int val) { try { - m_nameAndTypeIndex.set(m_item, val); + nameAndTypeIndex.set(this.item, val); + } catch (Exception ex) { + throw new Error(ex); + } + } + + public static boolean isType(ConstInfoAccessor accessor) { + return clazz.isAssignableFrom(accessor.getItem().getClass()); + } + + static { + try { + clazz = Class.forName("javassist.bytecode.InvokeDynamicInfo"); + bootstrapIndex = clazz.getDeclaredField("bootstrap"); + bootstrapIndex.setAccessible(true); + nameAndTypeIndex = clazz.getDeclaredField("nameAndType"); + nameAndTypeIndex.setAccessible(true); } catch (Exception ex) { throw new Error(ex); } diff --git a/src/main/java/cuchaz/enigma/bytecode/accessors/MemberRefInfoAccessor.java b/src/main/java/cuchaz/enigma/bytecode/accessors/MemberRefInfoAccessor.java index bb9d16bc..0e0297be 100644 --- a/src/main/java/cuchaz/enigma/bytecode/accessors/MemberRefInfoAccessor.java +++ b/src/main/java/cuchaz/enigma/bytecode/accessors/MemberRefInfoAccessor.java @@ -14,35 +14,19 @@ import java.lang.reflect.Field; public class MemberRefInfoAccessor { - private static Class m_class; - private static Field m_classIndex; - private static Field m_nameAndTypeIndex; + private static Class clazz; + private static Field classIndex; + private static Field nameAndTypeIndex; - static { - try { - m_class = Class.forName("javassist.bytecode.MemberrefInfo"); - m_classIndex = m_class.getDeclaredField("classIndex"); - m_classIndex.setAccessible(true); - m_nameAndTypeIndex = m_class.getDeclaredField("nameAndTypeIndex"); - m_nameAndTypeIndex.setAccessible(true); - } catch (Exception ex) { - throw new Error(ex); - } - } - - public static boolean isType(ConstInfoAccessor accessor) { - return m_class.isAssignableFrom(accessor.getItem().getClass()); - } - - private Object m_item; + private Object item; public MemberRefInfoAccessor(Object item) { - m_item = item; + this.item = item; } public int getClassIndex() { try { - return (Integer) m_classIndex.get(m_item); + return (Integer) classIndex.get(this.item); } catch (Exception ex) { throw new Error(ex); } @@ -50,7 +34,7 @@ public class MemberRefInfoAccessor { public void setClassIndex(int val) { try { - m_classIndex.set(m_item, val); + classIndex.set(this.item, val); } catch (Exception ex) { throw new Error(ex); } @@ -58,7 +42,7 @@ public class MemberRefInfoAccessor { public int getNameAndTypeIndex() { try { - return (Integer) m_nameAndTypeIndex.get(m_item); + return (Integer) nameAndTypeIndex.get(this.item); } catch (Exception ex) { throw new Error(ex); } @@ -66,7 +50,23 @@ public class MemberRefInfoAccessor { public void setNameAndTypeIndex(int val) { try { - m_nameAndTypeIndex.set(m_item, val); + nameAndTypeIndex.set(this.item, val); + } catch (Exception ex) { + throw new Error(ex); + } + } + + public static boolean isType(ConstInfoAccessor accessor) { + return clazz.isAssignableFrom(accessor.getItem().getClass()); + } + + static { + try { + clazz = Class.forName("javassist.bytecode.MemberrefInfo"); + classIndex = clazz.getDeclaredField("classIndex"); + classIndex.setAccessible(true); + nameAndTypeIndex = clazz.getDeclaredField("nameAndTypeIndex"); + nameAndTypeIndex.setAccessible(true); } catch (Exception ex) { throw new Error(ex); } diff --git a/src/main/java/cuchaz/enigma/bytecode/accessors/MethodHandleInfoAccessor.java b/src/main/java/cuchaz/enigma/bytecode/accessors/MethodHandleInfoAccessor.java index 88e42f46..9a7dd698 100644 --- a/src/main/java/cuchaz/enigma/bytecode/accessors/MethodHandleInfoAccessor.java +++ b/src/main/java/cuchaz/enigma/bytecode/accessors/MethodHandleInfoAccessor.java @@ -14,35 +14,19 @@ import java.lang.reflect.Field; public class MethodHandleInfoAccessor { - private static Class m_class; - private static Field m_kindIndex; - private static Field m_indexIndex; + private static Class clazz; + private static Field kindIndex; + private static Field indexIndex; - static { - try { - m_class = Class.forName("javassist.bytecode.MethodHandleInfo"); - m_kindIndex = m_class.getDeclaredField("refKind"); - m_kindIndex.setAccessible(true); - m_indexIndex = m_class.getDeclaredField("refIndex"); - m_indexIndex.setAccessible(true); - } catch (Exception ex) { - throw new Error(ex); - } - } - - public static boolean isType(ConstInfoAccessor accessor) { - return m_class.isAssignableFrom(accessor.getItem().getClass()); - } - - private Object m_item; + private Object item; public MethodHandleInfoAccessor(Object item) { - m_item = item; + this.item = item; } public int getTypeIndex() { try { - return (Integer) m_kindIndex.get(m_item); + return (Integer) kindIndex.get(this.item); } catch (Exception ex) { throw new Error(ex); } @@ -50,7 +34,7 @@ public class MethodHandleInfoAccessor { public void setTypeIndex(int val) { try { - m_kindIndex.set(m_item, val); + kindIndex.set(this.item, val); } catch (Exception ex) { throw new Error(ex); } @@ -58,7 +42,7 @@ public class MethodHandleInfoAccessor { public int getMethodRefIndex() { try { - return (Integer) m_indexIndex.get(m_item); + return (Integer) indexIndex.get(this.item); } catch (Exception ex) { throw new Error(ex); } @@ -66,7 +50,23 @@ public class MethodHandleInfoAccessor { public void setMethodRefIndex(int val) { try { - m_indexIndex.set(m_item, val); + indexIndex.set(this.item, val); + } catch (Exception ex) { + throw new Error(ex); + } + } + + public static boolean isType(ConstInfoAccessor accessor) { + return clazz.isAssignableFrom(accessor.getItem().getClass()); + } + + static { + try { + clazz = Class.forName("javassist.bytecode.MethodHandleInfo"); + kindIndex = clazz.getDeclaredField("refKind"); + kindIndex.setAccessible(true); + indexIndex = clazz.getDeclaredField("refIndex"); + indexIndex.setAccessible(true); } catch (Exception ex) { throw new Error(ex); } diff --git a/src/main/java/cuchaz/enigma/bytecode/accessors/MethodTypeInfoAccessor.java b/src/main/java/cuchaz/enigma/bytecode/accessors/MethodTypeInfoAccessor.java index 1d039f6c..5ec9c3b4 100644 --- a/src/main/java/cuchaz/enigma/bytecode/accessors/MethodTypeInfoAccessor.java +++ b/src/main/java/cuchaz/enigma/bytecode/accessors/MethodTypeInfoAccessor.java @@ -14,32 +14,18 @@ import java.lang.reflect.Field; public class MethodTypeInfoAccessor { - private static Class m_class; - private static Field m_descriptorIndex; + private static Class clazz; + private static Field descriptorIndex; - static { - try { - m_class = Class.forName("javassist.bytecode.MethodTypeInfo"); - m_descriptorIndex = m_class.getDeclaredField("descriptor"); - m_descriptorIndex.setAccessible(true); - } catch (Exception ex) { - throw new Error(ex); - } - } - - public static boolean isType(ConstInfoAccessor accessor) { - return m_class.isAssignableFrom(accessor.getItem().getClass()); - } - - private Object m_item; + private Object item; public MethodTypeInfoAccessor(Object item) { - m_item = item; + this.item = item; } public int getTypeIndex() { try { - return (Integer) m_descriptorIndex.get(m_item); + return (Integer) descriptorIndex.get(this.item); } catch (Exception ex) { throw new Error(ex); } @@ -47,9 +33,24 @@ public class MethodTypeInfoAccessor { public void setTypeIndex(int val) { try { - m_descriptorIndex.set(m_item, val); + descriptorIndex.set(this.item, val); } catch (Exception ex) { throw new Error(ex); } } + + public static boolean isType(ConstInfoAccessor accessor) { + return clazz.isAssignableFrom(accessor.getItem().getClass()); + } + + static { + try { + clazz = Class.forName("javassist.bytecode.MethodTypeInfo"); + descriptorIndex = clazz.getDeclaredField("descriptor"); + descriptorIndex.setAccessible(true); + } catch (Exception ex) { + throw new Error(ex); + } + } + } diff --git a/src/main/java/cuchaz/enigma/bytecode/accessors/NameAndTypeInfoAccessor.java b/src/main/java/cuchaz/enigma/bytecode/accessors/NameAndTypeInfoAccessor.java index acba7799..95df37c1 100644 --- a/src/main/java/cuchaz/enigma/bytecode/accessors/NameAndTypeInfoAccessor.java +++ b/src/main/java/cuchaz/enigma/bytecode/accessors/NameAndTypeInfoAccessor.java @@ -14,35 +14,19 @@ import java.lang.reflect.Field; public class NameAndTypeInfoAccessor { - private static Class m_class; - private static Field m_nameIndex; - private static Field m_typeIndex; + private static Class clazz; + private static Field nameIndex; + private static Field typeIndex; - static { - try { - m_class = Class.forName("javassist.bytecode.NameAndTypeInfo"); - m_nameIndex = m_class.getDeclaredField("memberName"); - m_nameIndex.setAccessible(true); - m_typeIndex = m_class.getDeclaredField("typeDescriptor"); - m_typeIndex.setAccessible(true); - } catch (Exception ex) { - throw new Error(ex); - } - } - - public static boolean isType(ConstInfoAccessor accessor) { - return m_class.isAssignableFrom(accessor.getItem().getClass()); - } - - private Object m_item; + private Object item; public NameAndTypeInfoAccessor(Object item) { - m_item = item; + this.item = item; } public int getNameIndex() { try { - return (Integer) m_nameIndex.get(m_item); + return (Integer) nameIndex.get(this.item); } catch (Exception ex) { throw new Error(ex); } @@ -50,7 +34,7 @@ public class NameAndTypeInfoAccessor { public void setNameIndex(int val) { try { - m_nameIndex.set(m_item, val); + nameIndex.set(this.item, val); } catch (Exception ex) { throw new Error(ex); } @@ -58,7 +42,7 @@ public class NameAndTypeInfoAccessor { public int getTypeIndex() { try { - return (Integer) m_typeIndex.get(m_item); + return (Integer) typeIndex.get(this.item); } catch (Exception ex) { throw new Error(ex); } @@ -66,7 +50,23 @@ public class NameAndTypeInfoAccessor { public void setTypeIndex(int val) { try { - m_typeIndex.set(m_item, val); + typeIndex.set(this.item, val); + } catch (Exception ex) { + throw new Error(ex); + } + } + + public static boolean isType(ConstInfoAccessor accessor) { + return clazz.isAssignableFrom(accessor.getItem().getClass()); + } + + static { + try { + clazz = Class.forName("javassist.bytecode.NameAndTypeInfo"); + nameIndex = clazz.getDeclaredField("memberName"); + nameIndex.setAccessible(true); + typeIndex = clazz.getDeclaredField("typeDescriptor"); + typeIndex.setAccessible(true); } catch (Exception ex) { throw new Error(ex); } diff --git a/src/main/java/cuchaz/enigma/bytecode/accessors/StringInfoAccessor.java b/src/main/java/cuchaz/enigma/bytecode/accessors/StringInfoAccessor.java index b40e0eb2..1c55a443 100644 --- a/src/main/java/cuchaz/enigma/bytecode/accessors/StringInfoAccessor.java +++ b/src/main/java/cuchaz/enigma/bytecode/accessors/StringInfoAccessor.java @@ -14,32 +14,18 @@ import java.lang.reflect.Field; public class StringInfoAccessor { - private static Class m_class; - private static Field m_stringIndex; + private static Class clazz; + private static Field stringIndex; - static { - try { - m_class = Class.forName("javassist.bytecode.StringInfo"); - m_stringIndex = m_class.getDeclaredField("string"); - m_stringIndex.setAccessible(true); - } catch (Exception ex) { - throw new Error(ex); - } - } - - public static boolean isType(ConstInfoAccessor accessor) { - return m_class.isAssignableFrom(accessor.getItem().getClass()); - } - - private Object m_item; + private Object item; public StringInfoAccessor(Object item) { - m_item = item; + this.item = item; } public int getStringIndex() { try { - return (Integer) m_stringIndex.get(m_item); + return (Integer) stringIndex.get(this.item); } catch (Exception ex) { throw new Error(ex); } @@ -47,7 +33,21 @@ public class StringInfoAccessor { public void setStringIndex(int val) { try { - m_stringIndex.set(m_item, val); + stringIndex.set(this.item, val); + } catch (Exception ex) { + throw new Error(ex); + } + } + + public static boolean isType(ConstInfoAccessor accessor) { + return clazz.isAssignableFrom(accessor.getItem().getClass()); + } + + static { + try { + clazz = Class.forName("javassist.bytecode.StringInfo"); + stringIndex = clazz.getDeclaredField("string"); + stringIndex.setAccessible(true); } catch (Exception ex) { throw new Error(ex); } diff --git a/src/main/java/cuchaz/enigma/bytecode/accessors/Utf8InfoAccessor.java b/src/main/java/cuchaz/enigma/bytecode/accessors/Utf8InfoAccessor.java index 9303b41a..7a2cb667 100644 --- a/src/main/java/cuchaz/enigma/bytecode/accessors/Utf8InfoAccessor.java +++ b/src/main/java/cuchaz/enigma/bytecode/accessors/Utf8InfoAccessor.java @@ -12,17 +12,17 @@ package cuchaz.enigma.bytecode.accessors; public class Utf8InfoAccessor { - private static Class m_class; + private static Class clazz; static { try { - m_class = Class.forName("javassist.bytecode.Utf8Info"); + clazz = Class.forName("javassist.bytecode.Utf8Info"); } catch (Exception ex) { throw new Error(ex); } } public static boolean isType(ConstInfoAccessor accessor) { - return m_class.isAssignableFrom(accessor.getItem().getClass()); + return clazz.isAssignableFrom(accessor.getItem().getClass()); } } diff --git a/src/main/java/cuchaz/enigma/convert/ClassForest.java b/src/main/java/cuchaz/enigma/convert/ClassForest.java index 7123bbfb..b08d48fb 100644 --- a/src/main/java/cuchaz/enigma/convert/ClassForest.java +++ b/src/main/java/cuchaz/enigma/convert/ClassForest.java @@ -20,12 +20,12 @@ import cuchaz.enigma.mapping.ClassEntry; public class ClassForest { - private ClassIdentifier m_identifier; - private Multimap m_forest; + private ClassIdentifier identifier; + private Multimap forest; public ClassForest(ClassIdentifier identifier) { - m_identifier = identifier; - m_forest = HashMultimap.create(); + this.identifier = identifier; + this.forest = HashMultimap.create(); } public void addAll(Iterable entries) { @@ -36,25 +36,25 @@ public class ClassForest { public void add(ClassEntry entry) { try { - m_forest.put(m_identifier.identify(entry), entry); + this.forest.put(this.identifier.identify(entry), entry); } catch (ClassNotFoundException ex) { throw new Error("Unable to find class " + entry.getName()); } } public Collection identities() { - return m_forest.keySet(); + return this.forest.keySet(); } public Collection classes() { - return m_forest.values(); + return this.forest.values(); } public Collection getClasses(ClassIdentity identity) { - return m_forest.get(identity); + return this.forest.get(identity); } public boolean containsIdentity(ClassIdentity identity) { - return m_forest.containsKey(identity); + return this.forest.containsKey(identity); } } diff --git a/src/main/java/cuchaz/enigma/convert/ClassIdentifier.java b/src/main/java/cuchaz/enigma/convert/ClassIdentifier.java index e1153a6d..cc7f25b8 100644 --- a/src/main/java/cuchaz/enigma/convert/ClassIdentifier.java +++ b/src/main/java/cuchaz/enigma/convert/ClassIdentifier.java @@ -24,30 +24,30 @@ import javassist.CtClass; public class ClassIdentifier { - private JarIndex m_index; - private SidedClassNamer m_namer; - private boolean m_useReferences; - private TranslatingTypeLoader m_loader; - private Map m_cache; + private JarIndex index; + private SidedClassNamer namer; + private boolean useReferences; + private TranslatingTypeLoader loader; + private Map cache; public ClassIdentifier(JarFile jar, JarIndex index, SidedClassNamer namer, boolean useReferences) { - m_index = index; - m_namer = namer; - m_useReferences = useReferences; - m_loader = new TranslatingTypeLoader(jar, index); - m_cache = Maps.newHashMap(); + this.index = index; + this.namer = namer; + this.useReferences = useReferences; + this.loader = new TranslatingTypeLoader(jar, index); + this.cache = Maps.newHashMap(); } public ClassIdentity identify(ClassEntry classEntry) throws ClassNotFoundException { - ClassIdentity identity = m_cache.get(classEntry); + ClassIdentity identity = this.cache.get(classEntry); if (identity == null) { - CtClass c = m_loader.loadClass(classEntry.getName()); + CtClass c = this.loader.loadClass(classEntry.getName()); if (c == null) { throw new ClassNotFoundException(classEntry.getName()); } - identity = new ClassIdentity(c, m_namer, m_index, m_useReferences); - m_cache.put(classEntry, identity); + identity = new ClassIdentity(c, this.namer, this.index, this.useReferences); + this.cache.put(classEntry, identity); } return identity; } diff --git a/src/main/java/cuchaz/enigma/convert/ClassIdentity.java b/src/main/java/cuchaz/enigma/convert/ClassIdentity.java index 76c48ab6..2317a3d9 100644 --- a/src/main/java/cuchaz/enigma/convert/ClassIdentity.java +++ b/src/main/java/cuchaz/enigma/convert/ClassIdentity.java @@ -36,18 +36,18 @@ import javassist.expr.*; public class ClassIdentity { - private ClassEntry m_classEntry; - private SidedClassNamer m_namer; - private Multiset m_fields; - private Multiset m_methods; - private Multiset m_constructors; - private String m_staticInitializer; - private String m_extends; - private Multiset m_implements; - private Set m_stringLiterals; - private Multiset m_implementations; - private Multiset m_references; - private String m_outer; + private ClassEntry classEntry; + private SidedClassNamer namer; + private Multiset fields; + private Multiset methods; + private Multiset constructors; + private String staticInitializer; + private String extendz; + private Multiset implementz; + private Set stringLiterals; + private Multiset implementations; + private Multiset references; + private String outer; private final ClassNameReplacer m_classNameReplacer = new ClassNameReplacer() { @@ -63,13 +63,13 @@ public class ClassIdentity { } // is this class ourself? - if (className.equals(m_classEntry.getName())) { + if (className.equals(classEntry.getName())) { return "CSelf"; } // try the namer - if (m_namer != null) { - String newName = m_namer.getName(className); + if (namer != null) { + String newName = namer.getName(className); if (newName != null) { return newName; } @@ -88,58 +88,58 @@ public class ClassIdentity { }; public ClassIdentity(CtClass c, SidedClassNamer namer, JarIndex index, boolean useReferences) { - m_namer = namer; + this.namer = namer; // stuff from the bytecode - m_classEntry = EntryFactory.getClassEntry(c); - m_fields = HashMultiset.create(); + this.classEntry = EntryFactory.getClassEntry(c); + this.fields = HashMultiset.create(); for (CtField field : c.getDeclaredFields()) { - m_fields.add(scrubType(field.getSignature())); + this.fields.add(scrubType(field.getSignature())); } - m_methods = HashMultiset.create(); + this.methods = HashMultiset.create(); for (CtMethod method : c.getDeclaredMethods()) { - m_methods.add(scrubSignature(method.getSignature()) + "0x" + getBehaviorSignature(method)); + this.methods.add(scrubSignature(method.getSignature()) + "0x" + getBehaviorSignature(method)); } - m_constructors = HashMultiset.create(); + this.constructors = HashMultiset.create(); for (CtConstructor constructor : c.getDeclaredConstructors()) { - m_constructors.add(scrubSignature(constructor.getSignature()) + "0x" + getBehaviorSignature(constructor)); + this.constructors.add(scrubSignature(constructor.getSignature()) + "0x" + getBehaviorSignature(constructor)); } - m_staticInitializer = ""; + this.staticInitializer = ""; if (c.getClassInitializer() != null) { - m_staticInitializer = getBehaviorSignature(c.getClassInitializer()); + this.staticInitializer = getBehaviorSignature(c.getClassInitializer()); } - m_extends = ""; + this.extendz = ""; if (c.getClassFile().getSuperclass() != null) { - m_extends = scrubClassName(Descriptor.toJvmName(c.getClassFile().getSuperclass())); + this.extendz = scrubClassName(Descriptor.toJvmName(c.getClassFile().getSuperclass())); } - m_implements = HashMultiset.create(); + this.implementz = HashMultiset.create(); for (String interfaceName : c.getClassFile().getInterfaces()) { - m_implements.add(scrubClassName(Descriptor.toJvmName(interfaceName))); + this.implementz.add(scrubClassName(Descriptor.toJvmName(interfaceName))); } - m_stringLiterals = Sets.newHashSet(); + this.stringLiterals = Sets.newHashSet(); ConstPool constants = c.getClassFile().getConstPool(); for (int i = 1; i < constants.getSize(); i++) { if (constants.getTag(i) == ConstPool.CONST_String) { - m_stringLiterals.add(constants.getStringInfo(i)); + this.stringLiterals.add(constants.getStringInfo(i)); } } // stuff from the jar index - m_implementations = HashMultiset.create(); - ClassImplementationsTreeNode implementationsNode = index.getClassImplementations(null, m_classEntry); + this.implementations = HashMultiset.create(); + ClassImplementationsTreeNode implementationsNode = index.getClassImplementations(null, this.classEntry); if (implementationsNode != null) { @SuppressWarnings("unchecked") Enumeration implementations = implementationsNode.children(); while (implementations.hasMoreElements()) { ClassImplementationsTreeNode node = implementations.nextElement(); - m_implementations.add(scrubClassName(node.getClassEntry().getName())); + this.implementations.add(scrubClassName(node.getClassEntry().getName())); } } - m_references = HashMultiset.create(); + this.references = HashMultiset.create(); if (useReferences) { for (CtField field : c.getDeclaredFields()) { FieldEntry fieldEntry = EntryFactory.getFieldEntry(field); @@ -151,79 +151,79 @@ public class ClassIdentity { } } - m_outer = null; - if (m_classEntry.isInnerClass()) { - m_outer = m_classEntry.getOuterClassName(); + this.outer = null; + if (this.classEntry.isInnerClass()) { + this.outer = this.classEntry.getOuterClassName(); } } private void addReference(EntryReference reference) { if (reference.context.getSignature() != null) { - m_references.add(String.format("%s_%s", + this.references.add(String.format("%s_%s", scrubClassName(reference.context.getClassName()), scrubSignature(reference.context.getSignature()) )); } else { - m_references.add(String.format("%s_", + this.references.add(String.format("%s_", scrubClassName(reference.context.getClassName()) )); } } public ClassEntry getClassEntry() { - return m_classEntry; + return this.classEntry; } @Override public String toString() { StringBuilder buf = new StringBuilder(); buf.append("class: "); - buf.append(m_classEntry.getName()); + buf.append(this.classEntry.getName()); buf.append(" "); buf.append(hashCode()); buf.append("\n"); - for (String field : m_fields) { + for (String field : this.fields) { buf.append("\tfield "); buf.append(field); buf.append("\n"); } - for (String method : m_methods) { + for (String method : this.methods) { buf.append("\tmethod "); buf.append(method); buf.append("\n"); } - for (String constructor : m_constructors) { + for (String constructor : this.constructors) { buf.append("\tconstructor "); buf.append(constructor); buf.append("\n"); } - if (m_staticInitializer.length() > 0) { + if (this.staticInitializer.length() > 0) { buf.append("\tinitializer "); - buf.append(m_staticInitializer); + buf.append(this.staticInitializer); buf.append("\n"); } - if (m_extends.length() > 0) { + if (this.extendz.length() > 0) { buf.append("\textends "); - buf.append(m_extends); + buf.append(this.extendz); buf.append("\n"); } - for (String interfaceName : m_implements) { + for (String interfaceName : this.implementz) { buf.append("\timplements "); buf.append(interfaceName); buf.append("\n"); } - for (String implementation : m_implementations) { + for (String implementation : this.implementations) { buf.append("\timplemented by "); buf.append(implementation); buf.append("\n"); } - for (String reference : m_references) { + for (String reference : this.references) { buf.append("\treference "); buf.append(reference); buf.append("\n"); } buf.append("\touter "); - buf.append(m_outer); + buf.append(this.outer); buf.append("\n"); return buf.toString(); } @@ -253,7 +253,7 @@ public class ClassIdentity { } private boolean isClassMatchedUniquely(String className) { - return m_namer != null && m_namer.getName(Descriptor.toJvmName(className)) != null; + return this.namer != null && this.namer.getName(Descriptor.toJvmName(className)) != null; } private String getBehaviorSignature(CtBehavior behavior) { @@ -361,56 +361,53 @@ public class ClassIdentity { @Override public boolean equals(Object other) { - if (other instanceof ClassIdentity) { - return equals((ClassIdentity) other); - } - return false; + return other instanceof ClassIdentity && equals((ClassIdentity) other); } public boolean equals(ClassIdentity other) { - return m_fields.equals(other.m_fields) - && m_methods.equals(other.m_methods) - && m_constructors.equals(other.m_constructors) - && m_staticInitializer.equals(other.m_staticInitializer) - && m_extends.equals(other.m_extends) - && m_implements.equals(other.m_implements) - && m_implementations.equals(other.m_implementations) - && m_references.equals(other.m_references); + return this.fields.equals(other.fields) + && this.methods.equals(other.methods) + && this.constructors.equals(other.constructors) + && this.staticInitializer.equals(other.staticInitializer) + && this.extendz.equals(other.extendz) + && this.implementz.equals(other.implementz) + && this.implementations.equals(other.implementations) + && this.references.equals(other.references); } @Override public int hashCode() { List objs = Lists.newArrayList(); - objs.addAll(m_fields); - objs.addAll(m_methods); - objs.addAll(m_constructors); - objs.add(m_staticInitializer); - objs.add(m_extends); - objs.addAll(m_implements); - objs.addAll(m_implementations); - objs.addAll(m_references); + objs.addAll(this.fields); + objs.addAll(this.methods); + objs.addAll(this.constructors); + objs.add(this.staticInitializer); + objs.add(this.extendz); + objs.addAll(this.implementz); + objs.addAll(this.implementations); + objs.addAll(this.references); return Util.combineHashesOrdered(objs); } public int getMatchScore(ClassIdentity other) { - return 2 * getNumMatches(m_extends, other.m_extends) - + 2 * getNumMatches(m_outer, other.m_outer) - + 2 * getNumMatches(m_implements, other.m_implements) - + getNumMatches(m_stringLiterals, other.m_stringLiterals) - + getNumMatches(m_fields, other.m_fields) - + getNumMatches(m_methods, other.m_methods) - + getNumMatches(m_constructors, other.m_constructors); + return 2 * getNumMatches(this.extendz, other.extendz) + + 2 * getNumMatches(this.outer, other.outer) + + 2 * getNumMatches(this.implementz, other.implementz) + + getNumMatches(this.stringLiterals, other.stringLiterals) + + getNumMatches(this.fields, other.fields) + + getNumMatches(this.methods, other.methods) + + getNumMatches(this.constructors, other.constructors); } public int getMaxMatchScore() { - return 2 + 2 + 2 * m_implements.size() + m_stringLiterals.size() + m_fields.size() + m_methods.size() + m_constructors.size(); + return 2 + 2 + 2 * this.implementz.size() + this.stringLiterals.size() + this.fields.size() + this.methods.size() + this.constructors.size(); } public boolean matches(CtClass c) { // just compare declaration counts - return m_fields.size() == c.getDeclaredFields().length - && m_methods.size() == c.getDeclaredMethods().length - && m_constructors.size() == c.getDeclaredConstructors().length; + return this.fields.size() == c.getDeclaredFields().length + && this.methods.size() == c.getDeclaredMethods().length + && this.constructors.size() == c.getDeclaredConstructors().length; } private int getNumMatches(Set a, Set b) { diff --git a/src/main/java/cuchaz/enigma/convert/ClassMatch.java b/src/main/java/cuchaz/enigma/convert/ClassMatch.java index f3530ed4..422529ec 100644 --- a/src/main/java/cuchaz/enigma/convert/ClassMatch.java +++ b/src/main/java/cuchaz/enigma/convert/ClassMatch.java @@ -75,14 +75,10 @@ public class ClassMatch { @Override public boolean equals(Object other) { - if (other instanceof ClassMatch) { - return equals((ClassMatch) other); - } - return false; + return other instanceof ClassMatch && equals((ClassMatch) other); } public boolean equals(ClassMatch other) { - return this.sourceClasses.equals(other.sourceClasses) - && this.destClasses.equals(other.destClasses); + return this.sourceClasses.equals(other.sourceClasses) && this.destClasses.equals(other.destClasses); } } diff --git a/src/main/java/cuchaz/enigma/convert/ClassMatches.java b/src/main/java/cuchaz/enigma/convert/ClassMatches.java index 2c5f6a57..3a254357 100644 --- a/src/main/java/cuchaz/enigma/convert/ClassMatches.java +++ b/src/main/java/cuchaz/enigma/convert/ClassMatches.java @@ -32,7 +32,7 @@ public class ClassMatches implements Iterable { Set m_unmatchedDestClasses; public ClassMatches() { - this(new ArrayList()); + this(new ArrayList<>()); } public ClassMatches(Collection matches) { diff --git a/src/main/java/cuchaz/enigma/convert/ClassMatching.java b/src/main/java/cuchaz/enigma/convert/ClassMatching.java index 14f8e2a3..9350ea7f 100644 --- a/src/main/java/cuchaz/enigma/convert/ClassMatching.java +++ b/src/main/java/cuchaz/enigma/convert/ClassMatching.java @@ -69,7 +69,7 @@ public class ClassMatching { for (ClassIdentity identity : m_destClasses.identities()) { if (!m_sourceClasses.containsIdentity(identity)) { matches.add(new ClassMatch( - new ArrayList(), + new ArrayList<>(), m_destClasses.getClasses(identity) )); } diff --git a/src/main/java/cuchaz/enigma/convert/ClassNamer.java b/src/main/java/cuchaz/enigma/convert/ClassNamer.java index f1d98200..e471c7dd 100644 --- a/src/main/java/cuchaz/enigma/convert/ClassNamer.java +++ b/src/main/java/cuchaz/enigma/convert/ClassNamer.java @@ -23,27 +23,27 @@ public class ClassNamer { String getName(String name); } - private Map m_sourceNames; - private Map m_destNames; + private Map sourceNames; + private Map destNames; public ClassNamer(BiMap mappings) { // convert the identity mappings to name maps - m_sourceNames = Maps.newHashMap(); - m_destNames = Maps.newHashMap(); + this.sourceNames = Maps.newHashMap(); + this.destNames = Maps.newHashMap(); int i = 0; for (Map.Entry entry : mappings.entrySet()) { String name = String.format("M%04d", i++); - m_sourceNames.put(entry.getKey().getName(), name); - m_destNames.put(entry.getValue().getName(), name); + this.sourceNames.put(entry.getKey().getName(), name); + this.destNames.put(entry.getValue().getName(), name); } } public String getSourceName(String name) { - return m_sourceNames.get(name); + return this.sourceNames.get(name); } public String getDestName(String name) { - return m_destNames.get(name); + return this.destNames.get(name); } public SidedClassNamer getSourceNamer() { diff --git a/src/main/java/cuchaz/enigma/gui/GuiController.java b/src/main/java/cuchaz/enigma/gui/GuiController.java index aa6acdc5..a6a2ec52 100644 --- a/src/main/java/cuchaz/enigma/gui/GuiController.java +++ b/src/main/java/cuchaz/enigma/gui/GuiController.java @@ -17,7 +17,6 @@ import com.strobel.decompiler.languages.java.ast.CompilationUnit; import java.io.File; import java.io.FileReader; -import java.io.FileWriter; import java.io.IOException; import java.util.Collection; import java.util.Deque; diff --git a/src/main/java/cuchaz/enigma/json/JsonConstructor.java b/src/main/java/cuchaz/enigma/json/JsonConstructor.java index cfac372a..8cbecf7b 100644 --- a/src/main/java/cuchaz/enigma/json/JsonConstructor.java +++ b/src/main/java/cuchaz/enigma/json/JsonConstructor.java @@ -8,7 +8,7 @@ public class JsonConstructor { private boolean statics; public JsonConstructor(String signature, List args, boolean statics) { - this.signature=signature; + this.signature = signature; this.args = args; this.statics = statics; } diff --git a/src/main/java/cuchaz/enigma/json/JsonField.java b/src/main/java/cuchaz/enigma/json/JsonField.java index 195f2874..c55a5e93 100644 --- a/src/main/java/cuchaz/enigma/json/JsonField.java +++ b/src/main/java/cuchaz/enigma/json/JsonField.java @@ -8,18 +8,18 @@ public class JsonField { public JsonField(String obf, String name, String type) { this.obf = obf; this.name = name; - this.type=type; + this.type = type; } public String getObf() { - return obf; + return this.obf; } public String getName() { - return name; + return this.name; } public String getType() { - return type; + return this.type; } } diff --git a/src/main/java/cuchaz/enigma/mapping/ClassEntry.java b/src/main/java/cuchaz/enigma/mapping/ClassEntry.java index 2e7711b7..c9304d45 100644 --- a/src/main/java/cuchaz/enigma/mapping/ClassEntry.java +++ b/src/main/java/cuchaz/enigma/mapping/ClassEntry.java @@ -67,10 +67,7 @@ public class ClassEntry implements Entry, Serializable { @Override public boolean equals(Object other) { - if (other instanceof ClassEntry) { - return equals((ClassEntry) other); - } - return false; + return other instanceof ClassEntry && equals((ClassEntry) other); } public boolean equals(ClassEntry other) { diff --git a/src/main/java/cuchaz/enigma/mapping/ClassMapping.java b/src/main/java/cuchaz/enigma/mapping/ClassMapping.java index 9258ec78..84fb6dd8 100644 --- a/src/main/java/cuchaz/enigma/mapping/ClassMapping.java +++ b/src/main/java/cuchaz/enigma/mapping/ClassMapping.java @@ -403,7 +403,7 @@ public class ClassMapping implements Serializable, Comparable { public boolean renameObfClass(String oldObfClassName, String newObfClassName) { // rename inner classes - for (ClassMapping innerClassMapping : new ArrayList(m_innerClassesByObfSimple.values())) { + for (ClassMapping innerClassMapping : new ArrayList<>(m_innerClassesByObfSimple.values())) { if (innerClassMapping.renameObfClass(oldObfClassName, newObfClassName)) { boolean wasRemoved = m_innerClassesByObfSimple.remove(oldObfClassName) != null; assert (wasRemoved); @@ -413,7 +413,7 @@ public class ClassMapping implements Serializable, Comparable { } // rename field types - for (FieldMapping fieldMapping : new ArrayList(m_fieldsByObf.values())) { + for (FieldMapping fieldMapping : new ArrayList<>(m_fieldsByObf.values())) { String oldFieldKey = getFieldKey(fieldMapping.getObfName(), fieldMapping.getObfType()); if (fieldMapping.renameObfClass(oldObfClassName, newObfClassName)) { boolean wasRemoved = m_fieldsByObf.remove(oldFieldKey) != null; @@ -424,7 +424,7 @@ public class ClassMapping implements Serializable, Comparable { } // rename method signatures - for (MethodMapping methodMapping : new ArrayList(m_methodsByObf.values())) { + for (MethodMapping methodMapping : new ArrayList<>(m_methodsByObf.values())) { String oldMethodKey = getMethodKey(methodMapping.getObfName(), methodMapping.getObfSignature()); if (methodMapping.renameObfClass(oldObfClassName, newObfClassName)) { boolean wasRemoved = m_methodsByObf.remove(oldMethodKey) != null; diff --git a/src/main/java/cuchaz/enigma/mapping/FieldEntry.java b/src/main/java/cuchaz/enigma/mapping/FieldEntry.java index 3de72239..bebc5045 100644 --- a/src/main/java/cuchaz/enigma/mapping/FieldEntry.java +++ b/src/main/java/cuchaz/enigma/mapping/FieldEntry.java @@ -80,10 +80,7 @@ public class FieldEntry implements Entry, Serializable { @Override public boolean equals(Object other) { - if (other instanceof FieldEntry) { - return equals((FieldEntry) other); - } - return false; + return other instanceof FieldEntry && equals((FieldEntry) other); } public boolean equals(FieldEntry other) { diff --git a/src/main/java/cuchaz/enigma/mapping/MappingsChecker.java b/src/main/java/cuchaz/enigma/mapping/MappingsChecker.java index ab686827..5e2b40b2 100644 --- a/src/main/java/cuchaz/enigma/mapping/MappingsChecker.java +++ b/src/main/java/cuchaz/enigma/mapping/MappingsChecker.java @@ -90,8 +90,6 @@ public class MappingsChecker { classMapping.removeMethodMapping(methodMapping); m_droppedMethodMappings.put(obfBehaviorEntry, methodMapping); } - - m_relatedMethodChecker.checkMethod(classEntry, methodMapping); } // check inner classes diff --git a/src/main/java/cuchaz/enigma/mapping/MappingsReader.java b/src/main/java/cuchaz/enigma/mapping/MappingsReader.java index 7110d40c..b2c3a5c0 100644 --- a/src/main/java/cuchaz/enigma/mapping/MappingsReader.java +++ b/src/main/java/cuchaz/enigma/mapping/MappingsReader.java @@ -42,14 +42,14 @@ public class MappingsReader { public void readFile(Mappings mappings, BufferedReader in) throws IOException, MappingParseException { - String builder = ""; + StringBuffer buf = new StringBuffer(); String line = null; while ((line = in.readLine()) != null) { - builder += line; + buf.append(line); } Gson gson = new GsonBuilder().setPrettyPrinting().create(); - JsonClass jsonClass = gson.fromJson(builder, JsonClass.class); + JsonClass jsonClass = gson.fromJson(buf.toString(), JsonClass.class); load(null, jsonClass, mappings); } diff --git a/src/main/java/cuchaz/enigma/mapping/MappingsWriter.java b/src/main/java/cuchaz/enigma/mapping/MappingsWriter.java index 89fee4e8..aaab22fa 100644 --- a/src/main/java/cuchaz/enigma/mapping/MappingsWriter.java +++ b/src/main/java/cuchaz/enigma/mapping/MappingsWriter.java @@ -24,7 +24,6 @@ import cuchaz.enigma.json.*; public class MappingsWriter { - public void write(File file, Mappings mappings) throws IOException { if (!file.isDirectory()) { return; diff --git a/src/main/java/cuchaz/enigma/mapping/MethodEntry.java b/src/main/java/cuchaz/enigma/mapping/MethodEntry.java index 301da615..01a5c43d 100644 --- a/src/main/java/cuchaz/enigma/mapping/MethodEntry.java +++ b/src/main/java/cuchaz/enigma/mapping/MethodEntry.java @@ -85,10 +85,7 @@ public class MethodEntry implements BehaviorEntry, Serializable { @Override public boolean equals(Object other) { - if (other instanceof MethodEntry) { - return equals((MethodEntry) other); - } - return false; + return other instanceof MethodEntry && equals((MethodEntry) other); } public boolean equals(MethodEntry other) { diff --git a/src/main/java/cuchaz/enigma/mapping/MethodMapping.java b/src/main/java/cuchaz/enigma/mapping/MethodMapping.java index d1beddde..ff14ccd3 100644 --- a/src/main/java/cuchaz/enigma/mapping/MethodMapping.java +++ b/src/main/java/cuchaz/enigma/mapping/MethodMapping.java @@ -36,62 +36,62 @@ public class MethodMapping implements Serializable, Comparable, M if (obfSignature == null) { throw new IllegalArgumentException("obf signature cannot be null!"); } - m_obfName = obfName; - m_deobfName = NameValidator.validateMethodName(deobfName); - m_obfSignature = obfSignature; - m_arguments = Maps.newTreeMap(); + this.m_obfName = obfName; + this.m_deobfName = NameValidator.validateMethodName(deobfName); + this.m_obfSignature = obfSignature; + this.m_arguments = Maps.newTreeMap(); } public MethodMapping(MethodMapping other, ClassNameReplacer obfClassNameReplacer) { - m_obfName = other.m_obfName; - m_deobfName = other.m_deobfName; - m_obfSignature = new Signature(other.m_obfSignature, obfClassNameReplacer); - m_arguments = Maps.newTreeMap(); + this.m_obfName = other.m_obfName; + this.m_deobfName = other.m_deobfName; + this.m_obfSignature = new Signature(other.m_obfSignature, obfClassNameReplacer); + this.m_arguments = Maps.newTreeMap(); for (Entry entry : other.m_arguments.entrySet()) { - m_arguments.put(entry.getKey(), new ArgumentMapping(entry.getValue())); + this.m_arguments.put(entry.getKey(), new ArgumentMapping(entry.getValue())); } } @Override public String getObfName() { - return m_obfName; + return this.m_obfName; } public void setObfName(String val) { - m_obfName = NameValidator.validateMethodName(val); + this.m_obfName = NameValidator.validateMethodName(val); } public String getDeobfName() { - return m_deobfName; + return this.m_deobfName; } public void setDeobfName(String val) { - m_deobfName = NameValidator.validateMethodName(val); + this.m_deobfName = NameValidator.validateMethodName(val); } public Signature getObfSignature() { - return m_obfSignature; + return this.m_obfSignature; } public void setObfSignature(Signature val) { - m_obfSignature = val; + this.m_obfSignature = val; } public Iterable arguments() { - return m_arguments.values(); + return this.m_arguments.values(); } public boolean isConstructor() { - return m_obfName.startsWith("<"); + return this.m_obfName.startsWith("<"); } public void addArgumentMapping(ArgumentMapping argumentMapping) { - boolean wasAdded = m_arguments.put(argumentMapping.getIndex(), argumentMapping) == null; + boolean wasAdded = this.m_arguments.put(argumentMapping.getIndex(), argumentMapping) == null; assert (wasAdded); } public String getObfArgumentName(int index) { - ArgumentMapping argumentMapping = m_arguments.get(index); + ArgumentMapping argumentMapping = this.m_arguments.get(index); if (argumentMapping != null) { return argumentMapping.getName(); } @@ -100,7 +100,7 @@ public class MethodMapping implements Serializable, Comparable, M } public String getDeobfArgumentName(int index) { - ArgumentMapping argumentMapping = m_arguments.get(index); + ArgumentMapping argumentMapping = this.m_arguments.get(index); if (argumentMapping != null) { return argumentMapping.getName(); } @@ -109,10 +109,10 @@ public class MethodMapping implements Serializable, Comparable, M } public void setArgumentName(int index, String name) { - ArgumentMapping argumentMapping = m_arguments.get(index); + ArgumentMapping argumentMapping = this.m_arguments.get(index); if (argumentMapping == null) { argumentMapping = new ArgumentMapping(index, name); - boolean wasAdded = m_arguments.put(index, argumentMapping) == null; + boolean wasAdded = this.m_arguments.put(index, argumentMapping) == null; assert (wasAdded); } else { argumentMapping.setName(name); @@ -120,7 +120,7 @@ public class MethodMapping implements Serializable, Comparable, M } public void removeArgumentName(int index) { - boolean wasRemoved = m_arguments.remove(index) != null; + boolean wasRemoved = this.m_arguments.remove(index) != null; assert (wasRemoved); } @@ -136,7 +136,7 @@ public class MethodMapping implements Serializable, Comparable, M buf.append(m_obfSignature); buf.append("\n"); buf.append("\tArguments:\n"); - for (ArgumentMapping argumentMapping : m_arguments.values()) { + for (ArgumentMapping argumentMapping : this.m_arguments.values()) { buf.append("\t\t"); buf.append(argumentMapping.getIndex()); buf.append(" -> "); @@ -148,31 +148,28 @@ public class MethodMapping implements Serializable, Comparable, M @Override public int compareTo(MethodMapping other) { - return (m_obfName + m_obfSignature).compareTo(other.m_obfName + other.m_obfSignature); + return (this.m_obfName + this.m_obfSignature).compareTo(other.m_obfName + other.m_obfSignature); } public boolean renameObfClass(final String oldObfClassName, final String newObfClassName) { // rename obf classes in the signature - Signature newSignature = new Signature(m_obfSignature, new ClassNameReplacer() { - @Override - public String replace(String className) { - if (className.equals(oldObfClassName)) { - return newObfClassName; - } - return null; + Signature newSignature = new Signature(this.m_obfSignature, className -> { + if (className.equals(oldObfClassName)) { + return newObfClassName; } + return null; }); - if (!newSignature.equals(m_obfSignature)) { - m_obfSignature = newSignature; + if (!newSignature.equals(this.m_obfSignature)) { + this.m_obfSignature = newSignature; return true; } return false; } public boolean containsArgument(String name) { - for (ArgumentMapping argumentMapping : m_arguments.values()) { + for (ArgumentMapping argumentMapping : this.m_arguments.values()) { if (argumentMapping.getName().equals(name)) { return true; } @@ -183,9 +180,9 @@ public class MethodMapping implements Serializable, Comparable, M @Override public BehaviorEntry getObfEntry(ClassEntry classEntry) { if (isConstructor()) { - return new ConstructorEntry(classEntry, m_obfSignature); + return new ConstructorEntry(classEntry, this.m_obfSignature); } else { - return new MethodEntry(classEntry, m_obfName, m_obfSignature); + return new MethodEntry(classEntry, this.m_obfName, this.m_obfSignature); } } } diff --git a/src/test/java/cuchaz/enigma/TestTranslator.java b/src/test/java/cuchaz/enigma/TestTranslator.java index 9b7f0931..dcdced01 100644 --- a/src/test/java/cuchaz/enigma/TestTranslator.java +++ b/src/test/java/cuchaz/enigma/TestTranslator.java @@ -4,7 +4,7 @@ * are made available under the terms of the GNU Lesser General Public * License v3.0 which accompanies this distribution, and is available at * http://www.gnu.org/licenses/lgpl.html - * + * * Contributors: * Jeff Martin - initial API and implementation ******************************************************************************/ @@ -34,7 +34,7 @@ public class TestTranslator { private static Mappings m_mappings; private static Translator m_deobfTranslator; private static Translator m_obfTranslator; - + @BeforeClass public static void beforeClass() throws Exception { @@ -47,7 +47,7 @@ public class TestTranslator { // m_obfTranslator = m_deobfuscator.getTranslator(TranslationDirection.Obfuscating); //} } - + @Test public void basicClasses() { assertMapping(newClass("none/a"), newClass("deobf/A_Basic")); @@ -61,7 +61,7 @@ public class TestTranslator { assertMapping(newField("none/a", "a", "F"), newField("deobf/A_Basic", "f2", "F")); assertMapping(newField("none/a", "a", "Ljava/lang/String;"), newField("deobf/A_Basic", "f3", "Ljava/lang/String;")); } - + @Test public void basicMethods() { assertMapping(newMethod("none/a", "a", "()V"), newMethod("deobf/A_Basic", "m1", "()V")); @@ -69,9 +69,9 @@ public class TestTranslator { assertMapping(newMethod("none/a", "a", "(I)V"), newMethod("deobf/A_Basic", "m3", "(I)V")); assertMapping(newMethod("none/a", "a", "(I)I"), newMethod("deobf/A_Basic", "m4", "(I)I")); } - + // TODO: basic constructors - + @Test public void inheritanceFields() { assertMapping(newField("none/b", "a", "I"), newField("deobf/B_BaseClass", "f1", "I")); @@ -79,69 +79,69 @@ public class TestTranslator { assertMapping(newField("none/c", "b", "I"), newField("deobf/C_SubClass", "f3", "I")); assertMapping(newField("none/c", "c", "I"), newField("deobf/C_SubClass", "f4", "I")); } - + @Test public void inheritanceFieldsShadowing() { assertMapping(newField("none/c", "b", "C"), newField("deobf/C_SubClass", "f2", "C")); } - + @Test public void inheritanceFieldsBySubClass() { assertMapping(newField("none/c", "a", "I"), newField("deobf/C_SubClass", "f1", "I")); // NOTE: can't reference b.C by subclass since it's shadowed } - + @Test public void inheritanceMethods() { assertMapping(newMethod("none/b", "a", "()I"), newMethod("deobf/B_BaseClass", "m1", "()I")); assertMapping(newMethod("none/b", "b", "()I"), newMethod("deobf/B_BaseClass", "m2", "()I")); assertMapping(newMethod("none/c", "c", "()I"), newMethod("deobf/C_SubClass", "m3", "()I")); } - + @Test public void inheritanceMethodsOverrides() { assertMapping(newMethod("none/c", "a", "()I"), newMethod("deobf/C_SubClass", "m1", "()I")); } - + @Test public void inheritanceMethodsBySubClass() { assertMapping(newMethod("none/c", "b", "()I"), newMethod("deobf/C_SubClass", "m2", "()I")); } - + @Test public void innerClasses() { - + // classes assertMapping(newClass("none/g"), newClass("deobf/G_OuterClass")); assertMapping(newClass("none/g$a"), newClass("deobf/G_OuterClass$A_InnerClass")); assertMapping(newClass("none/g$a$a"), newClass("deobf/G_OuterClass$A_InnerClass$A_InnerInnerClass")); assertMapping(newClass("none/g$b"), newClass("deobf/G_OuterClass$b")); assertMapping(newClass("none/g$b$a"), newClass("deobf/G_OuterClass$b$A_NamedInnerClass")); - + // fields assertMapping(newField("none/g$a", "a", "I"), newField("deobf/G_OuterClass$A_InnerClass", "f1", "I")); assertMapping(newField("none/g$a", "a", "Ljava/lang/String;"), newField("deobf/G_OuterClass$A_InnerClass", "f2", "Ljava/lang/String;")); assertMapping(newField("none/g$a$a", "a", "I"), newField("deobf/G_OuterClass$A_InnerClass$A_InnerInnerClass", "f3", "I")); assertMapping(newField("none/g$b$a", "a", "I"), newField("deobf/G_OuterClass$b$A_NamedInnerClass", "f4", "I")); - + // methods assertMapping(newMethod("none/g$a", "a", "()V"), newMethod("deobf/G_OuterClass$A_InnerClass", "m1", "()V")); assertMapping(newMethod("none/g$a$a", "a", "()V"), newMethod("deobf/G_OuterClass$A_InnerClass$A_InnerInnerClass", "m2", "()V")); } - + @Test public void namelessClass() { assertMapping(newClass("none/h"), newClass("none/h")); } - + @Test public void testGenerics() { - + // classes assertMapping(newClass("none/i"), newClass("deobf/I_Generics")); assertMapping(newClass("none/i$a"), newClass("deobf/I_Generics$A_Type")); assertMapping(newClass("none/i$b"), newClass("deobf/I_Generics$B_Generic")); - + // fields assertMapping(newField("none/i", "a", "Ljava/util/List;"), newField("deobf/I_Generics", "f1", "Ljava/util/List;")); assertMapping(newField("none/i", "b", "Ljava/util/List;"), newField("deobf/I_Generics", "f2", "Ljava/util/List;")); @@ -149,20 +149,20 @@ public class TestTranslator { assertMapping(newField("none/i$b", "a", "Ljava/lang/Object;"), newField("deobf/I_Generics$B_Generic", "f4", "Ljava/lang/Object;")); assertMapping(newField("none/i", "a", "Lnone/i$b;"), newField("deobf/I_Generics", "f5", "Ldeobf/I_Generics$B_Generic;")); assertMapping(newField("none/i", "b", "Lnone/i$b;"), newField("deobf/I_Generics", "f6", "Ldeobf/I_Generics$B_Generic;")); - + // methods assertMapping(newMethod("none/i$b", "a", "()Ljava/lang/Object;"), newMethod("deobf/I_Generics$B_Generic", "m1", "()Ljava/lang/Object;")); } - + private void assertMapping(Entry obf, Entry deobf) { //assertThat(m_deobfTranslator.translateEntry(obf), is(deobf)); //assertThat(m_obfTranslator.translateEntry(deobf), is(obf)); - + //String deobfName = m_deobfTranslator.translate(obf); //if (deobfName != null) { // assertThat(deobfName, is(deobf.getName())); //} - + //String obfName = m_obfTranslator.translate(deobf); //if (obfName != null) { // assertThat(obfName, is(obf.getName())); -- cgit v1.2.3