From b4aaff683d78ab92b83f3a7257c33b8e27d1affa Mon Sep 17 00:00:00 2001 From: Thog Date: Tue, 7 Mar 2017 21:24:39 +0100 Subject: Drop unix case style and implement hashCode when equals is overrided Also update Guava to version 21 --- build.gradle | 2 +- src/main/java/cuchaz/enigma/ConvertMain.java | 58 ++-- src/main/java/cuchaz/enigma/Deobfuscator.java | 8 +- src/main/java/cuchaz/enigma/Main.java | 1 - src/main/java/cuchaz/enigma/analysis/Access.java | 15 +- .../enigma/analysis/BehaviorReferenceTreeNode.java | 93 +++--- .../java/cuchaz/enigma/analysis/BridgeMarker.java | 6 +- src/main/java/cuchaz/enigma/analysis/JarIndex.java | 2 - .../analysis/SourceIndexBehaviorVisitor.java | 1 - src/main/java/cuchaz/enigma/analysis/Token.java | 6 + .../cuchaz/enigma/analysis/TreeDumpVisitor.java | 13 +- .../cuchaz/enigma/bytecode/CheckCastIterator.java | 119 -------- .../java/cuchaz/enigma/bytecode/ClassRenamer.java | 7 +- .../cuchaz/enigma/bytecode/InnerClassWriter.java | 1 - .../java/cuchaz/enigma/convert/ClassIdentity.java | 19 +- .../java/cuchaz/enigma/convert/ClassMatches.java | 88 +++--- .../java/cuchaz/enigma/convert/ClassMatching.java | 36 +-- .../java/cuchaz/enigma/convert/FieldMatches.java | 68 ++--- .../cuchaz/enigma/convert/MappingsConverter.java | 53 ++-- .../java/cuchaz/enigma/convert/MatchesReader.java | 5 +- .../java/cuchaz/enigma/convert/MemberMatches.java | 70 ++--- src/main/java/cuchaz/enigma/gui/BrowserCaret.java | 1 - .../java/cuchaz/enigma/gui/ClassMatchingGui.java | 290 +++++++++---------- src/main/java/cuchaz/enigma/gui/ClassSelector.java | 29 +- src/main/java/cuchaz/enigma/gui/CodeReader.java | 89 +++--- src/main/java/cuchaz/enigma/gui/Gui.java | 318 ++++++++++----------- src/main/java/cuchaz/enigma/gui/GuiController.java | 64 ++--- .../java/cuchaz/enigma/gui/MemberMatchingGui.java | 281 ++++++++---------- .../java/cuchaz/enigma/gui/ScoredClassEntry.java | 20 +- .../java/cuchaz/enigma/gui/dialog/CrashDialog.java | 32 +-- .../cuchaz/enigma/gui/dialog/ProgressDialog.java | 16 +- .../java/cuchaz/enigma/gui/elements/MenuBar.java | 20 +- .../cuchaz/enigma/gui/elements/PopupMenuBar.java | 2 +- .../enigma/gui/node/ClassSelectorClassNode.java | 5 + .../enigma/gui/node/ClassSelectorPackageNode.java | 5 + .../java/cuchaz/enigma/mapping/ClassMapping.java | 250 ++++++++-------- .../java/cuchaz/enigma/mapping/FieldMapping.java | 12 +- .../enigma/mapping/MappingsEnigmaWriter.java | 6 +- .../cuchaz/enigma/mapping/MappingsRenamer.java | 54 ++-- .../cuchaz/enigma/mapping/MappingsSRGWriter.java | 2 +- .../java/cuchaz/enigma/mapping/MethodMapping.java | 12 +- .../enigma/throwables/MappingParseException.java | 10 +- src/main/java/cuchaz/enigma/utils/Utils.java | 3 +- src/test/java/cuchaz/enigma/TestDeobfed.java | 14 +- src/test/java/cuchaz/enigma/TestInnerClasses.java | 66 ++--- .../enigma/TestJarIndexConstructorReferences.java | 75 ++--- .../cuchaz/enigma/TestJarIndexInheritanceTree.java | 176 ++++++------ .../java/cuchaz/enigma/TestJarIndexLoneClass.java | 68 ++--- src/test/java/cuchaz/enigma/TestTranslator.java | 26 +- src/test/java/cuchaz/enigma/TokenChecker.java | 16 +- .../enigma/inputs/inheritanceTree/BaseClass.java | 6 +- .../enigma/inputs/inheritanceTree/SubclassB.java | 6 +- .../cuchaz/enigma/inputs/loneClass/LoneClass.java | 6 +- .../enigma/inputs/translation/F_ObjectMethods.java | 1 + 54 files changed, 1237 insertions(+), 1415 deletions(-) delete mode 100644 src/main/java/cuchaz/enigma/bytecode/CheckCastIterator.java diff --git a/build.gradle b/build.gradle index d42cd61..d67082c 100644 --- a/build.gradle +++ b/build.gradle @@ -64,7 +64,7 @@ configurations { } dependencies { - compile 'com.google.guava:guava:17.+' + compile 'com.google.guava:guava:21.+' compile 'org.javassist:javassist:3.+' compile 'org.bitbucket.mstrobel:procyon-compilertools:0.5.33.8-enigma' diff --git a/src/main/java/cuchaz/enigma/ConvertMain.java b/src/main/java/cuchaz/enigma/ConvertMain.java index 1890aef..48e7f27 100644 --- a/src/main/java/cuchaz/enigma/ConvertMain.java +++ b/src/main/java/cuchaz/enigma/ConvertMain.java @@ -126,14 +126,12 @@ public class ConvertMain { Deobfuscators deobfuscators = new Deobfuscators(sourceJar, destJar); deobfuscators.source.setMappings(mappings); System.out.println("Starting GUI..."); - new ClassMatchingGui(classMatches, deobfuscators.source, deobfuscators.dest).setSaveListener(new ClassMatchingGui.SaveListener() { - @Override - public void save(ClassMatches matches) { - try { - MatchesWriter.writeClasses(matches, classMatchesFile); - } catch (IOException ex) { - throw new Error(ex); - } + new ClassMatchingGui(classMatches, deobfuscators.source, deobfuscators.dest).setSaveListener(matches -> + { + try { + MatchesWriter.writeClasses(matches, classMatchesFile); + } catch (IOException ex) { + throw new Error(ex); } }); } @@ -190,16 +188,15 @@ public class ConvertMain { checker.dropBrokenMappings(destMappings); deobfuscators.dest.setMappings(destMappings); - new MemberMatchingGui<>(classMatches, fieldMatches, deobfuscators.source, deobfuscators.dest).setSaveListener(new MemberMatchingGui.SaveListener() { - @Override - public void save(MemberMatches matches) { - try { - MatchesWriter.writeMembers(matches, fieldMatchesFile); - } catch (IOException ex) { - throw new Error(ex); - } - } - }); + new MemberMatchingGui<>(classMatches, fieldMatches, deobfuscators.source, deobfuscators.dest).setSaveListener( + matches -> + { + try { + MatchesWriter.writeMembers(matches, fieldMatchesFile); + } catch (IOException ex) { + throw new Error(ex); + } + }); } @SuppressWarnings("unused") @@ -267,16 +264,15 @@ public class ConvertMain { checker.dropBrokenMappings(destMappings); deobfuscators.dest.setMappings(destMappings); - new MemberMatchingGui<>(classMatches, methodMatches, deobfuscators.source, deobfuscators.dest).setSaveListener(new MemberMatchingGui.SaveListener() { - @Override - public void save(MemberMatches matches) { - try { - MatchesWriter.writeMembers(matches, methodMatchesFile); - } catch (IOException ex) { - throw new Error(ex); - } - } - }); + new MemberMatchingGui<>(classMatches, methodMatches, deobfuscators.source, deobfuscators.dest).setSaveListener( + matches -> + { + try { + MatchesWriter.writeMembers(matches, methodMatchesFile); + } catch (IOException ex) { + throw new Error(ex); + } + }); } private static void convertMappings(File outMappingsFile, JarFile sourceJar, JarFile destJar, Mappings mappings, File classMatchesFile, File fieldMatchesFile, File methodMatchesFile) @@ -338,11 +334,11 @@ public class ConvertMain { private static class IndexerThread extends Thread { - private JarFile m_jarFile; + private JarFile jarFile; public Deobfuscator deobfuscator; public IndexerThread(JarFile jarFile) { - m_jarFile = jarFile; + this.jarFile = jarFile; deobfuscator = null; } @@ -356,7 +352,7 @@ public class ConvertMain { @Override public void run() { - deobfuscator = new Deobfuscator(m_jarFile); + deobfuscator = new Deobfuscator(jarFile); } } } \ No newline at end of file diff --git a/src/main/java/cuchaz/enigma/Deobfuscator.java b/src/main/java/cuchaz/enigma/Deobfuscator.java index 2766380..2602abc 100644 --- a/src/main/java/cuchaz/enigma/Deobfuscator.java +++ b/src/main/java/cuchaz/enigma/Deobfuscator.java @@ -126,12 +126,8 @@ public class Deobfuscator { } public Translator getTranslator(TranslationDirection direction) { - Translator translator = this.translatorCache.get(direction); - if (translator == null) { - translator = this.mappings.getTranslator(direction, this.jarIndex.getTranslationIndex()); - this.translatorCache.put(direction, translator); - } - return translator; + return this.translatorCache.computeIfAbsent(direction, + k -> this.mappings.getTranslator(direction, this.jarIndex.getTranslationIndex())); } public void getSeparatedClasses(List obfClasses, List deobfClasses) { diff --git a/src/main/java/cuchaz/enigma/Main.java b/src/main/java/cuchaz/enigma/Main.java index a89f898..7370986 100644 --- a/src/main/java/cuchaz/enigma/Main.java +++ b/src/main/java/cuchaz/enigma/Main.java @@ -16,7 +16,6 @@ import java.util.jar.JarFile; import javax.swing.UIManager; import cuchaz.enigma.gui.Gui; -import cuchaz.enigma.mapping.ClassEntry; public class Main { diff --git a/src/main/java/cuchaz/enigma/analysis/Access.java b/src/main/java/cuchaz/enigma/analysis/Access.java index b8aafaa..b8a7b2c 100644 --- a/src/main/java/cuchaz/enigma/analysis/Access.java +++ b/src/main/java/cuchaz/enigma/analysis/Access.java @@ -17,10 +17,7 @@ import javassist.CtField; public enum Access { - Public, - Protected, - Package, - Private; + PUBLIC, PROTECTED, PACKAGE, PRIVATE; public static Access get(CtBehavior behavior) { return get(behavior.getModifiers()); @@ -36,15 +33,15 @@ public enum Access { boolean isPrivate = Modifier.isPrivate(modifiers); if (isPublic && !isProtected && !isPrivate) { - return Public; + return PUBLIC; } else if (!isPublic && isProtected && !isPrivate) { - return Protected; + return PROTECTED; } else if (!isPublic && !isProtected && isPrivate) { - return Private; + return PRIVATE; } else if (!isPublic && !isProtected && !isPrivate) { - return Package; + return PACKAGE; } // assume public by default - return Public; + return PUBLIC; } } diff --git a/src/main/java/cuchaz/enigma/analysis/BehaviorReferenceTreeNode.java b/src/main/java/cuchaz/enigma/analysis/BehaviorReferenceTreeNode.java index 98aa12e..52d5b31 100644 --- a/src/main/java/cuchaz/enigma/analysis/BehaviorReferenceTreeNode.java +++ b/src/main/java/cuchaz/enigma/analysis/BehaviorReferenceTreeNode.java @@ -11,75 +11,88 @@ package cuchaz.enigma.analysis; import com.google.common.collect.Sets; - -import java.util.Set; - -import javax.swing.tree.DefaultMutableTreeNode; -import javax.swing.tree.TreeNode; - import cuchaz.enigma.mapping.BehaviorEntry; import cuchaz.enigma.mapping.Entry; import cuchaz.enigma.mapping.Translator; -public class BehaviorReferenceTreeNode extends DefaultMutableTreeNode implements ReferenceTreeNode { +import javax.swing.tree.DefaultMutableTreeNode; +import javax.swing.tree.TreeNode; +import java.util.Set; + +public class BehaviorReferenceTreeNode extends DefaultMutableTreeNode + implements ReferenceTreeNode +{ - private Translator m_deobfuscatingTranslator; - private BehaviorEntry m_entry; - private EntryReference m_reference; - private Access m_access; + private Translator deobfuscatingTranslator; + private BehaviorEntry entry; + private EntryReference reference; + private Access access; - public BehaviorReferenceTreeNode(Translator deobfuscatingTranslator, BehaviorEntry entry) { - this.m_deobfuscatingTranslator = deobfuscatingTranslator; - this.m_entry = entry; - this.m_reference = null; + public BehaviorReferenceTreeNode(Translator deobfuscatingTranslator, BehaviorEntry entry) + { + this.deobfuscatingTranslator = deobfuscatingTranslator; + this.entry = entry; + this.reference = null; } - public BehaviorReferenceTreeNode(Translator deobfuscatingTranslator, EntryReference reference, Access access) { - this.m_deobfuscatingTranslator = deobfuscatingTranslator; - this.m_entry = reference.entry; - this.m_reference = reference; - this.m_access = access; + public BehaviorReferenceTreeNode(Translator deobfuscatingTranslator, + EntryReference reference, Access access) + { + this.deobfuscatingTranslator = deobfuscatingTranslator; + this.entry = reference.entry; + this.reference = reference; + this.access = access; } - @Override - public BehaviorEntry getEntry() { - return this.m_entry; + @Override public BehaviorEntry getEntry() + { + return this.entry; } - @Override - public EntryReference getReference() { - return this.m_reference; + @Override public EntryReference getReference() + { + return this.reference; } - @Override - public String toString() { - if (this.m_reference != null) { - return String.format("%s (%s)", this.m_deobfuscatingTranslator.translateEntry(this.m_reference.context), this.m_access); + @Override public String toString() + { + if (this.reference != null) + { + return String.format("%s (%s)", this.deobfuscatingTranslator.translateEntry(this.reference.context), + this.access); } - return this.m_deobfuscatingTranslator.translateEntry(this.m_entry).toString(); + return this.deobfuscatingTranslator.translateEntry(this.entry).toString(); } - public void load(JarIndex index, boolean recurse) { + public void load(JarIndex index, boolean recurse) + { // get all the child nodes - for (EntryReference reference : index.getBehaviorReferences(this.m_entry)) { - add(new BehaviorReferenceTreeNode(this.m_deobfuscatingTranslator, reference, index.getAccess(this.m_entry))); + for (EntryReference reference : index.getBehaviorReferences(this.entry)) + { + add(new BehaviorReferenceTreeNode(this.deobfuscatingTranslator, reference, index.getAccess(this.entry))); } - if (recurse && this.children != null) { - for (Object child : this.children) { - if (child instanceof BehaviorReferenceTreeNode) { + 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 = node; - while (n.getParent() != null) { + while (n.getParent() != null) + { n = n.getParent(); - if (n instanceof BehaviorReferenceTreeNode) { + if (n instanceof BehaviorReferenceTreeNode) + { ancestors.add(((BehaviorReferenceTreeNode) n).getEntry()); } } - if (ancestors.contains(node.getEntry())) { + if (ancestors.contains(node.getEntry())) + { continue; } diff --git a/src/main/java/cuchaz/enigma/analysis/BridgeMarker.java b/src/main/java/cuchaz/enigma/analysis/BridgeMarker.java index cd18584..0f4be7d 100644 --- a/src/main/java/cuchaz/enigma/analysis/BridgeMarker.java +++ b/src/main/java/cuchaz/enigma/analysis/BridgeMarker.java @@ -18,10 +18,10 @@ import javassist.bytecode.AccessFlag; public class BridgeMarker { - private JarIndex m_jarIndex; + private JarIndex jarIndex; public BridgeMarker(JarIndex jarIndex) { - this.m_jarIndex = jarIndex; + this.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 = this.m_jarIndex.getBridgedMethod(methodEntry); + MethodEntry bridgedMethodEntry = this.jarIndex.getBridgedMethod(methodEntry); if (bridgedMethodEntry != null) { // it's a bridge method! add the bridge flag diff --git a/src/main/java/cuchaz/enigma/analysis/JarIndex.java b/src/main/java/cuchaz/enigma/analysis/JarIndex.java index ee1dd54..e8f74cc 100644 --- a/src/main/java/cuchaz/enigma/analysis/JarIndex.java +++ b/src/main/java/cuchaz/enigma/analysis/JarIndex.java @@ -16,8 +16,6 @@ import java.lang.reflect.Modifier; import java.util.*; import java.util.jar.JarFile; -import cuchaz.enigma.Constants; -import cuchaz.enigma.bytecode.ClassRenamer; import cuchaz.enigma.mapping.*; import cuchaz.enigma.mapping.Translator; import javassist.*; diff --git a/src/main/java/cuchaz/enigma/analysis/SourceIndexBehaviorVisitor.java b/src/main/java/cuchaz/enigma/analysis/SourceIndexBehaviorVisitor.java index e690abd..bfd5a56 100644 --- a/src/main/java/cuchaz/enigma/analysis/SourceIndexBehaviorVisitor.java +++ b/src/main/java/cuchaz/enigma/analysis/SourceIndexBehaviorVisitor.java @@ -12,7 +12,6 @@ package cuchaz.enigma.analysis; import com.google.common.collect.HashMultimap; import com.google.common.collect.Multimap; -import com.google.common.collect.Multimaps; import com.strobel.assembler.metadata.MemberReference; import com.strobel.assembler.metadata.MethodReference; import com.strobel.assembler.metadata.ParameterDefinition; diff --git a/src/main/java/cuchaz/enigma/analysis/Token.java b/src/main/java/cuchaz/enigma/analysis/Token.java index 419842a..42f4660 100644 --- a/src/main/java/cuchaz/enigma/analysis/Token.java +++ b/src/main/java/cuchaz/enigma/analysis/Token.java @@ -38,6 +38,12 @@ public class Token implements Comparable { return other instanceof Token && equals((Token) other); } + @Override + public int hashCode() + { + return Integer.hashCode(start) + Integer.hashCode(end) + (text != null ? text.hashCode() : 0); + } + public boolean equals(Token other) { return start == other.start && end == other.end; } diff --git a/src/main/java/cuchaz/enigma/analysis/TreeDumpVisitor.java b/src/main/java/cuchaz/enigma/analysis/TreeDumpVisitor.java index de39d36..cc025da 100644 --- a/src/main/java/cuchaz/enigma/analysis/TreeDumpVisitor.java +++ b/src/main/java/cuchaz/enigma/analysis/TreeDumpVisitor.java @@ -19,20 +19,19 @@ import java.nio.charset.Charset; public class TreeDumpVisitor implements IAstVisitor { - private File m_file; - private Writer m_out; + private File file; + private Writer out; public TreeDumpVisitor(File file) { - m_file = file; - m_out = null; + this.file = file; } @Override public Void visitCompilationUnit(CompilationUnit node, Void ignored) { try { - m_out = new OutputStreamWriter(new FileOutputStream(m_file), Charset.forName("UTF-8")); + out = new OutputStreamWriter(new FileOutputStream(file), Charset.forName("UTF-8")); recurse(node, ignored); - m_out.close(); + out.close(); return null; } catch (IOException ex) { throw new Error(ex); @@ -42,7 +41,7 @@ public class TreeDumpVisitor implements IAstVisitor { private Void recurse(AstNode node, Void ignored) { // show the tree try { - m_out.write(getIndent(node) + node.getClass().getSimpleName() + " " + getText(node) + " " + dumpUserData(node) + " " + node.getRegion() + "\n"); + out.write(getIndent(node) + node.getClass().getSimpleName() + " " + getText(node) + " " + dumpUserData(node) + " " + node.getRegion() + "\n"); } catch (IOException 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 deleted file mode 100644 index d15dd87..0000000 --- a/src/main/java/cuchaz/enigma/bytecode/CheckCastIterator.java +++ /dev/null @@ -1,119 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2015 Jeff Martin. - * All rights reserved. This program and the accompanying materials - * 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 - ******************************************************************************/ -package cuchaz.enigma.bytecode; - -import java.util.Iterator; - -import cuchaz.enigma.bytecode.CheckCastIterator.CheckCast; -import cuchaz.enigma.mapping.ClassEntry; -import cuchaz.enigma.mapping.MethodEntry; -import cuchaz.enigma.mapping.Signature; -import javassist.bytecode.*; - -@Deprecated -// TODO: Find if this class can have any usage. -public class CheckCastIterator implements Iterator { - - public static class CheckCast { - - public String className; - public MethodEntry prevMethodEntry; - - public CheckCast(String className, MethodEntry prevMethodEntry) { - this.className = className; - this.prevMethodEntry = prevMethodEntry; - } - } - - private ConstPool constants; - private CodeAttribute attribute; - private CodeIterator iter; - private CheckCast next; - - public CheckCastIterator(CodeAttribute codeAttribute) throws BadBytecode { - this.constants = codeAttribute.getConstPool(); - this.attribute = codeAttribute; - this.iter = this.attribute.iterator(); - - this.next = getNext(); - } - - @Override - public boolean hasNext() { - return this.next != null; - } - - @Override - public CheckCast next() { - CheckCast out = this.next; - try { - this.next = getNext(); - } catch (BadBytecode ex) { - throw new Error(ex); - } - return out; - } - - @Override - public void remove() { - throw new UnsupportedOperationException(); - } - - private CheckCast getNext() throws BadBytecode { - int prevPos = 0; - 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(this.constants.getClassInfo(this.iter.s16bitAt(pos + 1)), prevMethodEntry); - } - break; - } - prevPos = pos; - } - return null; - } - - private MethodEntry getMethodEntry(int pos) { - switch (this.iter.byteAt(pos)) { - case Opcode.INVOKEVIRTUAL: - case Opcode.INVOKESTATIC: - case Opcode.INVOKEDYNAMIC: - case Opcode.INVOKESPECIAL: { - int index = this.iter.s16bitAt(pos + 1); - return new MethodEntry( - new ClassEntry(Descriptor.toJvmName(this.constants.getMethodrefClassName(index))), - this.constants.getMethodrefName(index), - new Signature(this.constants.getMethodrefType(index)) - ); - } - - case Opcode.INVOKEINTERFACE: { - int index = this.iter.s16bitAt(pos + 1); - return new MethodEntry( - new ClassEntry(Descriptor.toJvmName(this.constants.getInterfaceMethodrefClassName(index))), - this.constants.getInterfaceMethodrefName(index), - new Signature(this.constants.getInterfaceMethodrefType(index)) - ); - } - } - return null; - } - - public Iterable casts() { - return () -> CheckCastIterator.this; - } -} diff --git a/src/main/java/cuchaz/enigma/bytecode/ClassRenamer.java b/src/main/java/cuchaz/enigma/bytecode/ClassRenamer.java index d49f13a..d874633 100644 --- a/src/main/java/cuchaz/enigma/bytecode/ClassRenamer.java +++ b/src/main/java/cuchaz/enigma/bytecode/ClassRenamer.java @@ -52,10 +52,10 @@ public class ClassRenamer { private static class ReplacerClassMap extends HashMap { - private ClassNameReplacer m_replacer; + private ClassNameReplacer replacer; public ReplacerClassMap(ClassNameReplacer replacer) { - m_replacer = replacer; + this.replacer = replacer; } @Override @@ -67,7 +67,7 @@ public class ClassRenamer { } public String get(String className) { - return m_replacer.replace(className); + return replacer.replace(className); } } @@ -146,7 +146,6 @@ public class ClassRenamer { // rename the constant pool (covers ClassInfo, MethodTypeInfo, and NameAndTypeInfo) ConstPool constPool = c.getClassFile().getConstPool(); - String className = constPool.getClassName(); constPool.renameClass(map); // rename class attributes diff --git a/src/main/java/cuchaz/enigma/bytecode/InnerClassWriter.java b/src/main/java/cuchaz/enigma/bytecode/InnerClassWriter.java index 6e2a29d..eb70c23 100644 --- a/src/main/java/cuchaz/enigma/bytecode/InnerClassWriter.java +++ b/src/main/java/cuchaz/enigma/bytecode/InnerClassWriter.java @@ -15,7 +15,6 @@ import com.google.common.collect.Lists; import java.util.Collection; import java.util.List; -import cuchaz.enigma.Deobfuscator; import cuchaz.enigma.analysis.JarIndex; import cuchaz.enigma.mapping.*; import javassist.ClassPool; diff --git a/src/main/java/cuchaz/enigma/convert/ClassIdentity.java b/src/main/java/cuchaz/enigma/convert/ClassIdentity.java index 7360011..f72bf70 100644 --- a/src/main/java/cuchaz/enigma/convert/ClassIdentity.java +++ b/src/main/java/cuchaz/enigma/convert/ClassIdentity.java @@ -20,7 +20,6 @@ import java.util.List; import java.util.Map; import java.util.Set; -import cuchaz.enigma.Constants; import cuchaz.enigma.analysis.ClassImplementationsTreeNode; import cuchaz.enigma.analysis.EntryReference; import cuchaz.enigma.analysis.JarIndex; @@ -49,9 +48,9 @@ public class ClassIdentity { private Multiset references; private String outer; - private final ClassNameReplacer m_classNameReplacer = new ClassNameReplacer() { + private final ClassNameReplacer classNameReplacer = new ClassNameReplacer() { - private Map m_classNames = Maps.newHashMap(); + private Map classNames = Maps.newHashMap(); @Override public String replace(String className) { @@ -76,14 +75,14 @@ public class ClassIdentity { } // otherwise, use local naming - if (!m_classNames.containsKey(className)) { - m_classNames.put(className, getNewClassName()); + if (!classNames.containsKey(className)) { + classNames.put(className, getNewClassName()); } - return m_classNames.get(className); + return classNames.get(className); } private String getNewClassName() { - return String.format("C%03d", m_classNames.size()); + return String.format("C%03d", classNames.size()); } }; @@ -229,7 +228,7 @@ public class ClassIdentity { } private String scrubClassName(String className) { - return m_classNameReplacer.replace(className); + return classNameReplacer.replace(className); } private String scrubType(String typeName) { @@ -238,7 +237,7 @@ public class ClassIdentity { private Type scrubType(Type type) { if (type.hasClass()) { - return new Type(type, m_classNameReplacer); + return new Type(type, classNameReplacer); } else { return type; } @@ -249,7 +248,7 @@ public class ClassIdentity { } private Signature scrubSignature(Signature signature) { - return new Signature(signature, m_classNameReplacer); + return new Signature(signature, classNameReplacer); } private boolean isClassMatchedUniquely(String className) { diff --git a/src/main/java/cuchaz/enigma/convert/ClassMatches.java b/src/main/java/cuchaz/enigma/convert/ClassMatches.java index 3a25435..431c4f2 100644 --- a/src/main/java/cuchaz/enigma/convert/ClassMatches.java +++ b/src/main/java/cuchaz/enigma/convert/ClassMatches.java @@ -22,28 +22,28 @@ import cuchaz.enigma.mapping.ClassEntry; public class ClassMatches implements Iterable { - Collection m_matches; - Map m_matchesBySource; - Map m_matchesByDest; - BiMap m_uniqueMatches; - Map m_ambiguousMatchesBySource; - Map m_ambiguousMatchesByDest; - Set m_unmatchedSourceClasses; - Set m_unmatchedDestClasses; + private Collection matches; + private Map matchesBySource; + private Map matchesByDest; + private BiMap uniqueMatches; + private Map ambiguousMatchesBySource; + private Map ambiguousMatchesByDest; + private Set unmatchedSourceClasses; + private Set unmatchedDestClasses; public ClassMatches() { this(new ArrayList<>()); } public ClassMatches(Collection matches) { - m_matches = matches; - m_matchesBySource = Maps.newHashMap(); - m_matchesByDest = Maps.newHashMap(); - m_uniqueMatches = HashBiMap.create(); - m_ambiguousMatchesBySource = Maps.newHashMap(); - m_ambiguousMatchesByDest = Maps.newHashMap(); - m_unmatchedSourceClasses = Sets.newHashSet(); - m_unmatchedDestClasses = Sets.newHashSet(); + this.matches = matches; + matchesBySource = Maps.newHashMap(); + matchesByDest = Maps.newHashMap(); + uniqueMatches = HashBiMap.create(); + ambiguousMatchesBySource = Maps.newHashMap(); + ambiguousMatchesByDest = Maps.newHashMap(); + unmatchedSourceClasses = Sets.newHashSet(); + unmatchedDestClasses = Sets.newHashSet(); for (ClassMatch match : matches) { indexMatch(match); @@ -51,92 +51,92 @@ public class ClassMatches implements Iterable { } public void add(ClassMatch match) { - m_matches.add(match); + matches.add(match); indexMatch(match); } public void remove(ClassMatch match) { for (ClassEntry sourceClass : match.sourceClasses) { - m_matchesBySource.remove(sourceClass); - m_uniqueMatches.remove(sourceClass); - m_ambiguousMatchesBySource.remove(sourceClass); - m_unmatchedSourceClasses.remove(sourceClass); + matchesBySource.remove(sourceClass); + uniqueMatches.remove(sourceClass); + ambiguousMatchesBySource.remove(sourceClass); + unmatchedSourceClasses.remove(sourceClass); } for (ClassEntry destClass : match.destClasses) { - m_matchesByDest.remove(destClass); - m_uniqueMatches.inverse().remove(destClass); - m_ambiguousMatchesByDest.remove(destClass); - m_unmatchedDestClasses.remove(destClass); + matchesByDest.remove(destClass); + uniqueMatches.inverse().remove(destClass); + ambiguousMatchesByDest.remove(destClass); + unmatchedDestClasses.remove(destClass); } - m_matches.remove(match); + matches.remove(match); } public int size() { - return m_matches.size(); + return matches.size(); } @Override public Iterator iterator() { - return m_matches.iterator(); + return matches.iterator(); } private void indexMatch(ClassMatch match) { if (!match.isMatched()) { // unmatched - m_unmatchedSourceClasses.addAll(match.sourceClasses); - m_unmatchedDestClasses.addAll(match.destClasses); + unmatchedSourceClasses.addAll(match.sourceClasses); + unmatchedDestClasses.addAll(match.destClasses); } else { if (match.isAmbiguous()) { // ambiguously matched for (ClassEntry entry : match.sourceClasses) { - m_ambiguousMatchesBySource.put(entry, match); + ambiguousMatchesBySource.put(entry, match); } for (ClassEntry entry : match.destClasses) { - m_ambiguousMatchesByDest.put(entry, match); + ambiguousMatchesByDest.put(entry, match); } } else { // uniquely matched - m_uniqueMatches.put(match.getUniqueSource(), match.getUniqueDest()); + uniqueMatches.put(match.getUniqueSource(), match.getUniqueDest()); } } for (ClassEntry entry : match.sourceClasses) { - m_matchesBySource.put(entry, match); + matchesBySource.put(entry, match); } for (ClassEntry entry : match.destClasses) { - m_matchesByDest.put(entry, match); + matchesByDest.put(entry, match); } } public BiMap getUniqueMatches() { - return m_uniqueMatches; + return uniqueMatches; } public Set getUnmatchedSourceClasses() { - return m_unmatchedSourceClasses; + return unmatchedSourceClasses; } public Set getUnmatchedDestClasses() { - return m_unmatchedDestClasses; + return unmatchedDestClasses; } public Set getAmbiguouslyMatchedSourceClasses() { - return m_ambiguousMatchesBySource.keySet(); + return ambiguousMatchesBySource.keySet(); } public ClassMatch getAmbiguousMatchBySource(ClassEntry sourceClass) { - return m_ambiguousMatchesBySource.get(sourceClass); + return ambiguousMatchesBySource.get(sourceClass); } public ClassMatch getMatchBySource(ClassEntry sourceClass) { - return m_matchesBySource.get(sourceClass); + return matchesBySource.get(sourceClass); } public ClassMatch getMatchByDest(ClassEntry destClass) { - return m_matchesByDest.get(destClass); + return matchesByDest.get(destClass); } public void removeSource(ClassEntry sourceClass) { - ClassMatch match = m_matchesBySource.get(sourceClass); + ClassMatch match = matchesBySource.get(sourceClass); if (match != null) { remove(match); match.sourceClasses.remove(sourceClass); @@ -147,7 +147,7 @@ public class ClassMatches implements Iterable { } public void removeDest(ClassEntry destClass) { - ClassMatch match = m_matchesByDest.get(destClass); + ClassMatch match = matchesByDest.get(destClass); if (match != null) { remove(match); match.destClasses.remove(destClass); diff --git a/src/main/java/cuchaz/enigma/convert/ClassMatching.java b/src/main/java/cuchaz/enigma/convert/ClassMatching.java index af9ae01..b05df87 100644 --- a/src/main/java/cuchaz/enigma/convert/ClassMatching.java +++ b/src/main/java/cuchaz/enigma/convert/ClassMatching.java @@ -25,52 +25,52 @@ import cuchaz.enigma.mapping.ClassEntry; public class ClassMatching { - private ClassForest m_sourceClasses; - private ClassForest m_destClasses; - private BiMap m_knownMatches; + private ClassForest sourceClasses; + private ClassForest destClasses; + private BiMap knownMatches; public ClassMatching(ClassIdentifier sourceIdentifier, ClassIdentifier destIdentifier) { - m_sourceClasses = new ClassForest(sourceIdentifier); - m_destClasses = new ClassForest(destIdentifier); - m_knownMatches = HashBiMap.create(); + sourceClasses = new ClassForest(sourceIdentifier); + destClasses = new ClassForest(destIdentifier); + knownMatches = HashBiMap.create(); } public void addKnownMatches(BiMap knownMatches) { - m_knownMatches.putAll(knownMatches); + this.knownMatches.putAll(knownMatches); } public void match(Iterable sourceClasses, Iterable destClasses) { for (ClassEntry sourceClass : sourceClasses) { - if (!m_knownMatches.containsKey(sourceClass)) { - m_sourceClasses.add(sourceClass); + if (!knownMatches.containsKey(sourceClass)) { + this.sourceClasses.add(sourceClass); } } for (ClassEntry destClass : destClasses) { - if (!m_knownMatches.containsValue(destClass)) { - m_destClasses.add(destClass); + if (!knownMatches.containsValue(destClass)) { + this.destClasses.add(destClass); } } } public Collection matches() { List matches = Lists.newArrayList(); - for (Entry entry : m_knownMatches.entrySet()) { + for (Entry entry : knownMatches.entrySet()) { matches.add(new ClassMatch( entry.getKey(), entry.getValue() )); } - for (ClassIdentity identity : m_sourceClasses.identities()) { + for (ClassIdentity identity : sourceClasses.identities()) { matches.add(new ClassMatch( - m_sourceClasses.getClasses(identity), - m_destClasses.getClasses(identity) + sourceClasses.getClasses(identity), + destClasses.getClasses(identity) )); } - for (ClassIdentity identity : m_destClasses.identities()) { - if (!m_sourceClasses.containsIdentity(identity)) { + for (ClassIdentity identity : destClasses.identities()) { + if (!sourceClasses.containsIdentity(identity)) { matches.add(new ClassMatch( new ArrayList<>(), - m_destClasses.getClasses(identity) + destClasses.getClasses(identity) )); } } diff --git a/src/main/java/cuchaz/enigma/convert/FieldMatches.java b/src/main/java/cuchaz/enigma/convert/FieldMatches.java index 0899cd2..236cd4d 100644 --- a/src/main/java/cuchaz/enigma/convert/FieldMatches.java +++ b/src/main/java/cuchaz/enigma/convert/FieldMatches.java @@ -21,29 +21,29 @@ import cuchaz.enigma.mapping.FieldEntry; public class FieldMatches { - private BiMap m_matches; - private Multimap m_matchedSourceFields; - private Multimap m_unmatchedSourceFields; - private Multimap m_unmatchedDestFields; - private Multimap m_unmatchableSourceFields; + private BiMap matches; + private Multimap matchedSourceFields; + private Multimap unmatchedSourceFields; + private Multimap unmatchedDestFields; + private Multimap unmatchableSourceFields; public FieldMatches() { - m_matches = HashBiMap.create(); - m_matchedSourceFields = HashMultimap.create(); - m_unmatchedSourceFields = HashMultimap.create(); - m_unmatchedDestFields = HashMultimap.create(); - m_unmatchableSourceFields = HashMultimap.create(); + matches = HashBiMap.create(); + matchedSourceFields = HashMultimap.create(); + unmatchedSourceFields = HashMultimap.create(); + unmatchedDestFields = HashMultimap.create(); + unmatchableSourceFields = HashMultimap.create(); } public void addMatch(FieldEntry srcField, FieldEntry destField) { - boolean wasAdded = m_matches.put(srcField, destField) == null; + boolean wasAdded = matches.put(srcField, destField) == null; assert (wasAdded); - wasAdded = m_matchedSourceFields.put(srcField.getClassEntry(), srcField); + wasAdded = matchedSourceFields.put(srcField.getClassEntry(), srcField); assert (wasAdded); } public void addUnmatchedSourceField(FieldEntry fieldEntry) { - boolean wasAdded = m_unmatchedSourceFields.put(fieldEntry.getClassEntry(), fieldEntry); + boolean wasAdded = unmatchedSourceFields.put(fieldEntry.getClassEntry(), fieldEntry); assert (wasAdded); } @@ -54,7 +54,7 @@ public class FieldMatches { } public void addUnmatchedDestField(FieldEntry fieldEntry) { - boolean wasAdded = m_unmatchedDestFields.put(fieldEntry.getClassEntry(), fieldEntry); + boolean wasAdded = unmatchedDestFields.put(fieldEntry.getClassEntry(), fieldEntry); assert (wasAdded); } @@ -65,78 +65,78 @@ public class FieldMatches { } public void addUnmatchableSourceField(FieldEntry sourceField) { - boolean wasAdded = m_unmatchableSourceFields.put(sourceField.getClassEntry(), sourceField); + boolean wasAdded = unmatchableSourceFields.put(sourceField.getClassEntry(), sourceField); assert (wasAdded); } public Set getSourceClassesWithUnmatchedFields() { - return m_unmatchedSourceFields.keySet(); + return unmatchedSourceFields.keySet(); } public Collection getSourceClassesWithoutUnmatchedFields() { Set out = Sets.newHashSet(); - out.addAll(m_matchedSourceFields.keySet()); - out.removeAll(m_unmatchedSourceFields.keySet()); + out.addAll(matchedSourceFields.keySet()); + out.removeAll(unmatchedSourceFields.keySet()); return out; } public Collection getUnmatchedSourceFields() { - return m_unmatchedSourceFields.values(); + return unmatchedSourceFields.values(); } public Collection getUnmatchedSourceFields(ClassEntry sourceClass) { - return m_unmatchedSourceFields.get(sourceClass); + return unmatchedSourceFields.get(sourceClass); } public Collection getUnmatchedDestFields() { - return m_unmatchedDestFields.values(); + return unmatchedDestFields.values(); } public Collection getUnmatchedDestFields(ClassEntry destClass) { - return m_unmatchedDestFields.get(destClass); + return unmatchedDestFields.get(destClass); } public Collection getUnmatchableSourceFields() { - return m_unmatchableSourceFields.values(); + return unmatchableSourceFields.values(); } public boolean hasSource(FieldEntry fieldEntry) { - return m_matches.containsKey(fieldEntry) || m_unmatchedSourceFields.containsValue(fieldEntry); + return matches.containsKey(fieldEntry) || unmatchedSourceFields.containsValue(fieldEntry); } public boolean hasDest(FieldEntry fieldEntry) { - return m_matches.containsValue(fieldEntry) || m_unmatchedDestFields.containsValue(fieldEntry); + return matches.containsValue(fieldEntry) || unmatchedDestFields.containsValue(fieldEntry); } public BiMap matches() { - return m_matches; + return matches; } public boolean isMatchedSourceField(FieldEntry sourceField) { - return m_matches.containsKey(sourceField); + return matches.containsKey(sourceField); } public boolean isMatchedDestField(FieldEntry destField) { - return m_matches.containsValue(destField); + return matches.containsValue(destField); } public void makeMatch(FieldEntry sourceField, FieldEntry destField) { - boolean wasRemoved = m_unmatchedSourceFields.remove(sourceField.getClassEntry(), sourceField); + boolean wasRemoved = unmatchedSourceFields.remove(sourceField.getClassEntry(), sourceField); assert (wasRemoved); - wasRemoved = m_unmatchedDestFields.remove(destField.getClassEntry(), destField); + wasRemoved = unmatchedDestFields.remove(destField.getClassEntry(), destField); assert (wasRemoved); addMatch(sourceField, destField); } public boolean isMatched(FieldEntry sourceField, FieldEntry destField) { - FieldEntry match = m_matches.get(sourceField); + FieldEntry match = matches.get(sourceField); return match != null && match.equals(destField); } public void unmakeMatch(FieldEntry sourceField, FieldEntry destField) { - boolean wasRemoved = m_matches.remove(sourceField) != null; + boolean wasRemoved = matches.remove(sourceField) != null; assert (wasRemoved); - wasRemoved = m_matchedSourceFields.remove(sourceField.getClassEntry(), sourceField); + wasRemoved = matchedSourceFields.remove(sourceField.getClassEntry(), sourceField); assert (wasRemoved); addUnmatchedSourceField(sourceField); addUnmatchedDestField(destField); @@ -144,7 +144,7 @@ public class FieldMatches { public void makeSourceUnmatchable(FieldEntry sourceField) { assert (!isMatchedSourceField(sourceField)); - boolean wasRemoved = m_unmatchedSourceFields.remove(sourceField.getClassEntry(), sourceField); + boolean wasRemoved = unmatchedSourceFields.remove(sourceField.getClassEntry(), sourceField); assert (wasRemoved); addUnmatchableSourceField(sourceField); } diff --git a/src/main/java/cuchaz/enigma/convert/MappingsConverter.java b/src/main/java/cuchaz/enigma/convert/MappingsConverter.java index 929c89f..a5ded67 100644 --- a/src/main/java/cuchaz/enigma/convert/MappingsConverter.java +++ b/src/main/java/cuchaz/enigma/convert/MappingsConverter.java @@ -11,7 +11,6 @@ package cuchaz.enigma.convert; import com.google.common.collect.*; -import cuchaz.enigma.Constants; import cuchaz.enigma.Deobfuscator; import cuchaz.enigma.TranslatingTypeLoader; import cuchaz.enigma.analysis.JarIndex; @@ -24,7 +23,6 @@ import javassist.NotFoundException; import javassist.bytecode.BadBytecode; import javassist.bytecode.CodeAttribute; import javassist.bytecode.CodeIterator; -import javassist.bytecode.MethodInfo; import java.util.*; import java.util.jar.JarFile; @@ -174,15 +172,13 @@ public class MappingsConverter { private static ClassMapping migrateClassMapping(ClassEntry newObfClass, ClassMapping oldClassMapping, final ClassMatches matches, boolean useSimpleName) { - ClassNameReplacer replacer = new ClassNameReplacer() { - @Override - public String replace(String className) { - ClassEntry newClassEntry = matches.getUniqueMatches().get(new ClassEntry(className)); - if (newClassEntry != null) { - return newClassEntry.getName(); - } - return null; + ClassNameReplacer replacer = className -> + { + ClassEntry newClassEntry = matches.getUniqueMatches().get(new ClassEntry(className)); + if (newClassEntry != null) { + return newClassEntry.getName(); } + return null; }; ClassMapping newClassMapping; @@ -434,13 +430,12 @@ public class MappingsConverter { // Empty method body, ignore! if (sourceAttribute == null) return null; - Iterator it = obfDestEntries.iterator(); - while (it.hasNext()) + for (BehaviorEntry desEntry : obfDestEntries) { - BehaviorEntry desEntry = it.next(); try { - CtMethod destCtClassMethod = destCtClass.getMethod(desEntry.getName(), desEntry.getSignature().toString()); + CtMethod destCtClassMethod = destCtClass + .getMethod(desEntry.getName(), desEntry.getSignature().toString()); CodeAttribute destAttribute = destCtClassMethod.getMethodInfo().getCodeAttribute(); // Ignore empty body methods @@ -533,7 +528,7 @@ public class MappingsConverter { public static MemberMatches computeMemberMatches(Deobfuscator destDeobfuscator, Mappings destMappings, ClassMatches classMatches, Doer doer) { - MemberMatches memberMatches = new MemberMatches(); + MemberMatches memberMatches = new MemberMatches<>(); // unmatched source fields are easy MappingsChecker checker = new MappingsChecker(destDeobfuscator.getJarIndex()); @@ -624,15 +619,13 @@ public class MappingsConverter { } private static Type translate(Type type, final BiMap map) { - return new Type(type, new ClassNameReplacer() { - @Override - public String replace(String inClassName) { - ClassEntry outClassEntry = map.get(new ClassEntry(inClassName)); - if (outClassEntry == null) { - return null; - } - return outClassEntry.getName(); + return new Type(type, inClassName -> + { + ClassEntry outClassEntry = map.get(new ClassEntry(inClassName)); + if (outClassEntry == null) { + return null; } + return outClassEntry.getName(); }); } @@ -640,15 +633,13 @@ public class MappingsConverter { if (signature == null) { return null; } - return new Signature(signature, new ClassNameReplacer() { - @Override - public String replace(String inClassName) { - ClassEntry outClassEntry = map.get(new ClassEntry(inClassName)); - if (outClassEntry == null) { - return null; - } - return outClassEntry.getName(); + return new Signature(signature, inClassName -> + { + ClassEntry outClassEntry = map.get(new ClassEntry(inClassName)); + if (outClassEntry == null) { + return null; } + return outClassEntry.getName(); }); } diff --git a/src/main/java/cuchaz/enigma/convert/MatchesReader.java b/src/main/java/cuchaz/enigma/convert/MatchesReader.java index 550da49..d86d6c2 100644 --- a/src/main/java/cuchaz/enigma/convert/MatchesReader.java +++ b/src/main/java/cuchaz/enigma/convert/MatchesReader.java @@ -34,8 +34,7 @@ public class MatchesReader { } } - private static ClassMatch readClassMatch(String line) - throws IOException { + private static ClassMatch readClassMatch(String line) { String[] sides = line.split(":", 2); return new ClassMatch(readClasses(sides[0]), readClasses(sides[1])); } @@ -54,7 +53,7 @@ public class MatchesReader { public static MemberMatches readMembers(File file) throws IOException { try (BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(file), Charset.forName("UTF-8")))) { - MemberMatches matches = new MemberMatches(); + MemberMatches matches = new MemberMatches<>(); String line; while ((line = in.readLine()) != null) { readMemberMatch(matches, line); diff --git a/src/main/java/cuchaz/enigma/convert/MemberMatches.java b/src/main/java/cuchaz/enigma/convert/MemberMatches.java index 25af2f8..51cee85 100644 --- a/src/main/java/cuchaz/enigma/convert/MemberMatches.java +++ b/src/main/java/cuchaz/enigma/convert/MemberMatches.java @@ -21,29 +21,29 @@ import java.util.Set; public class MemberMatches { - private BiMap m_matches; - private Multimap m_matchedSourceEntries; - private Multimap m_unmatchedSourceEntries; - private Multimap m_unmatchedDestEntries; - private Multimap m_unmatchableSourceEntries; + private BiMap matches; + private Multimap matchedSourceEntries; + private Multimap unmatchedSourceEntries; + private Multimap unmatchedDestEntries; + private Multimap unmatchableSourceEntries; public MemberMatches() { - m_matches = HashBiMap.create(); - m_matchedSourceEntries = HashMultimap.create(); - m_unmatchedSourceEntries = HashMultimap.create(); - m_unmatchedDestEntries = HashMultimap.create(); - m_unmatchableSourceEntries = HashMultimap.create(); + matches = HashBiMap.create(); + matchedSourceEntries = HashMultimap.create(); + unmatchedSourceEntries = HashMultimap.create(); + unmatchedDestEntries = HashMultimap.create(); + unmatchableSourceEntries = HashMultimap.create(); } public void addMatch(T srcEntry, T destEntry) { - boolean wasAdded = m_matches.put(srcEntry, destEntry) == null; + boolean wasAdded = matches.put(srcEntry, destEntry) == null; assert (wasAdded); - wasAdded = m_matchedSourceEntries.put(srcEntry.getClassEntry(), srcEntry); + wasAdded = matchedSourceEntries.put(srcEntry.getClassEntry(), srcEntry); assert (wasAdded); } public void addUnmatchedSourceEntry(T sourceEntry) { - boolean wasAdded = m_unmatchedSourceEntries.put(sourceEntry.getClassEntry(), sourceEntry); + boolean wasAdded = unmatchedSourceEntries.put(sourceEntry.getClassEntry(), sourceEntry); assert (wasAdded); } @@ -56,7 +56,7 @@ public class MemberMatches { public void addUnmatchedDestEntry(T destEntry) { if (destEntry.getName().equals("") || destEntry.getName().equals("")) return; - boolean wasAdded = m_unmatchedDestEntries.put(destEntry.getClassEntry(), destEntry); + boolean wasAdded = unmatchedDestEntries.put(destEntry.getClassEntry(), destEntry); assert (wasAdded); } @@ -67,63 +67,63 @@ public class MemberMatches { } public void addUnmatchableSourceEntry(T sourceEntry) { - boolean wasAdded = m_unmatchableSourceEntries.put(sourceEntry.getClassEntry(), sourceEntry); + boolean wasAdded = unmatchableSourceEntries.put(sourceEntry.getClassEntry(), sourceEntry); assert (wasAdded); } public Set getSourceClassesWithUnmatchedEntries() { - return m_unmatchedSourceEntries.keySet(); + return unmatchedSourceEntries.keySet(); } public Collection getSourceClassesWithoutUnmatchedEntries() { Set out = Sets.newHashSet(); - out.addAll(m_matchedSourceEntries.keySet()); - out.removeAll(m_unmatchedSourceEntries.keySet()); + out.addAll(matchedSourceEntries.keySet()); + out.removeAll(unmatchedSourceEntries.keySet()); return out; } public Collection getUnmatchedSourceEntries() { - return m_unmatchedSourceEntries.values(); + return unmatchedSourceEntries.values(); } public Collection getUnmatchedSourceEntries(ClassEntry sourceClass) { - return m_unmatchedSourceEntries.get(sourceClass); + return unmatchedSourceEntries.get(sourceClass); } public Collection getUnmatchedDestEntries() { - return m_unmatchedDestEntries.values(); + return unmatchedDestEntries.values(); } public Collection getUnmatchedDestEntries(ClassEntry destClass) { - return m_unmatchedDestEntries.get(destClass); + return unmatchedDestEntries.get(destClass); } public Collection getUnmatchableSourceEntries() { - return m_unmatchableSourceEntries.values(); + return unmatchableSourceEntries.values(); } public boolean hasSource(T sourceEntry) { - return m_matches.containsKey(sourceEntry) || m_unmatchedSourceEntries.containsValue(sourceEntry); + return matches.containsKey(sourceEntry) || unmatchedSourceEntries.containsValue(sourceEntry); } public boolean hasDest(T destEntry) { - return m_matches.containsValue(destEntry) || m_unmatchedDestEntries.containsValue(destEntry); + return matches.containsValue(destEntry) || unmatchedDestEntries.containsValue(destEntry); } public BiMap matches() { - return m_matches; + return matches; } public boolean isMatchedSourceEntry(T sourceEntry) { - return m_matches.containsKey(sourceEntry); + return matches.containsKey(sourceEntry); } public boolean isMatchedDestEntry(T destEntry) { - return m_matches.containsValue(destEntry); + return matches.containsValue(destEntry); } public boolean isUnmatchableSourceEntry(T sourceEntry) { - return m_unmatchableSourceEntries.containsEntry(sourceEntry.getClassEntry(), sourceEntry); + return unmatchableSourceEntries.containsEntry(sourceEntry.getClassEntry(), sourceEntry); } public void makeMatch(T sourceEntry, T destEntry) { makeMatch(sourceEntry, destEntry, null, null); @@ -136,15 +136,15 @@ public class MemberMatches { sourceEntry = (T) sourceEntry.cloneToNewClass(sourceDeobfuscator.getJarIndex().getTranslationIndex().resolveEntryClass(sourceEntry, true)); destEntry = (T) destEntry.cloneToNewClass(destDeobfuscator.getJarIndex().getTranslationIndex().resolveEntryClass(destEntry, true)); } - boolean wasRemoved = m_unmatchedSourceEntries.remove(sourceEntry.getClassEntry(), sourceEntry); + boolean wasRemoved = unmatchedSourceEntries.remove(sourceEntry.getClassEntry(), sourceEntry); assert (wasRemoved); - wasRemoved = m_unmatchedDestEntries.remove(destEntry.getClassEntry(), destEntry); + wasRemoved = unmatchedDestEntries.remove(destEntry.getClassEntry(), destEntry); assert (wasRemoved); addMatch(sourceEntry, destEntry); } public boolean isMatched(T sourceEntry, T destEntry) { - T match = m_matches.get(sourceEntry); + T match = matches.get(sourceEntry); return match != null && match.equals(destEntry); } @@ -159,9 +159,9 @@ public class MemberMatches { destDeobfuscator.getJarIndex().getTranslationIndex().resolveEntryClass(destEntry, true)); } - boolean wasRemoved = m_matches.remove(sourceEntry) != null; + boolean wasRemoved = matches.remove(sourceEntry) != null; assert (wasRemoved); - wasRemoved = m_matchedSourceEntries.remove(sourceEntry.getClassEntry(), sourceEntry); + wasRemoved = matchedSourceEntries.remove(sourceEntry.getClassEntry(), sourceEntry); assert (wasRemoved); addUnmatchedSourceEntry(sourceEntry); addUnmatchedDestEntry(destEntry); @@ -175,7 +175,7 @@ public class MemberMatches { sourceDeobfuscator.getJarIndex().getTranslationIndex().resolveEntryClass(sourceEntry, true)); } assert (!isMatchedSourceEntry(sourceEntry)); - boolean wasRemoved = m_unmatchedSourceEntries.remove(sourceEntry.getClassEntry(), sourceEntry); + boolean wasRemoved = unmatchedSourceEntries.remove(sourceEntry.getClassEntry(), sourceEntry); assert (wasRemoved); addUnmatchableSourceEntry(sourceEntry); } diff --git a/src/main/java/cuchaz/enigma/gui/BrowserCaret.java b/src/main/java/cuchaz/enigma/gui/BrowserCaret.java index 013778a..bcdff51 100644 --- a/src/main/java/cuchaz/enigma/gui/BrowserCaret.java +++ b/src/main/java/cuchaz/enigma/gui/BrowserCaret.java @@ -11,7 +11,6 @@ package cuchaz.enigma.gui; import javax.swing.text.DefaultCaret; -import javax.swing.text.Highlighter; public class BrowserCaret extends DefaultCaret { diff --git a/src/main/java/cuchaz/enigma/gui/ClassMatchingGui.java b/src/main/java/cuchaz/enigma/gui/ClassMatchingGui.java index edf1e30..dcbe1c5 100644 --- a/src/main/java/cuchaz/enigma/gui/ClassMatchingGui.java +++ b/src/main/java/cuchaz/enigma/gui/ClassMatchingGui.java @@ -13,19 +13,6 @@ package cuchaz.enigma.gui; import com.google.common.collect.BiMap; import com.google.common.collect.Lists; import com.google.common.collect.Maps; - -import java.awt.BorderLayout; -import java.awt.Container; -import java.awt.Dimension; -import java.awt.FlowLayout; -import java.awt.event.ActionListener; -import java.util.Collection; -import java.util.Collections; -import java.util.List; -import java.util.Map; - -import javax.swing.*; - import cuchaz.enigma.Constants; import cuchaz.enigma.Deobfuscator; import cuchaz.enigma.convert.*; @@ -37,6 +24,13 @@ import cuchaz.enigma.mapping.MappingsChecker; import cuchaz.enigma.throwables.MappingConflict; import de.sciss.syntaxpane.DefaultSyntaxKit; +import javax.swing.*; +import java.awt.*; +import java.awt.event.ActionListener; +import java.util.Collection; +import java.util.List; +import java.util.Map; + public class ClassMatchingGui { @@ -80,35 +74,35 @@ public class ClassMatchingGui { } // controls - private JFrame m_frame; - private ClassSelector m_sourceClasses; - private ClassSelector m_destClasses; - private CodeReader m_sourceReader; - private CodeReader m_destReader; - private JLabel m_sourceClassLabel; - private JLabel m_destClassLabel; - private JButton m_matchButton; - private Map m_sourceTypeButtons; - private JCheckBox m_advanceCheck; - private JCheckBox m_top10Matches; - - private ClassMatches m_classMatches; - private Deobfuscator m_sourceDeobfuscator; - private Deobfuscator m_destDeobfuscator; - private ClassEntry m_sourceClass; - private ClassEntry m_destClass; - private SourceType m_sourceType; - private SaveListener m_saveListener; + private JFrame frame; + private ClassSelector sourceClasses; + private ClassSelector destClasses; + private CodeReader sourceReader; + private CodeReader destReader; + private JLabel sourceClassLabel; + private JLabel destClassLabel; + private JButton matchButton; + private Map sourceTypeButtons; + private JCheckBox advanceCheck; + private JCheckBox top10Matches; + + private ClassMatches classMatches; + private Deobfuscator sourceDeobfuscator; + private Deobfuscator destDeobfuscator; + private ClassEntry sourceClass; + private ClassEntry destClass; + private SourceType sourceType; + private SaveListener saveListener; public ClassMatchingGui(ClassMatches matches, Deobfuscator sourceDeobfuscator, Deobfuscator destDeobfuscator) { - m_classMatches = matches; - m_sourceDeobfuscator = sourceDeobfuscator; - m_destDeobfuscator = destDeobfuscator; + classMatches = matches; + this.sourceDeobfuscator = sourceDeobfuscator; + this.destDeobfuscator = destDeobfuscator; // init frame - m_frame = new JFrame(Constants.NAME + " - Class Matcher"); - final Container pane = m_frame.getContentPane(); + frame = new JFrame(Constants.NAME + " - Class Matcher"); + final Container pane = frame.getContentPane(); pane.setLayout(new BorderLayout()); // init source side @@ -124,16 +118,16 @@ public class ClassMatchingGui { sourceTypePanel.setLayout(new BoxLayout(sourceTypePanel, BoxLayout.PAGE_AXIS)); ActionListener sourceTypeListener = event -> setSourceType(SourceType.valueOf(event.getActionCommand())); ButtonGroup sourceTypeButtons = new ButtonGroup(); - m_sourceTypeButtons = Maps.newHashMap(); + this.sourceTypeButtons = Maps.newHashMap(); for (SourceType sourceType : SourceType.values()) { JRadioButton button = sourceType.newRadio(sourceTypeListener, sourceTypeButtons); - m_sourceTypeButtons.put(sourceType, button); + this.sourceTypeButtons.put(sourceType, button); sourceTypePanel.add(button); } - m_sourceClasses = new ClassSelector(null, ClassSelector.DEOBF_CLASS_COMPARATOR, false); - m_sourceClasses.setSelectionListener(this::setSourceClass); - JScrollPane sourceScroller = new JScrollPane(m_sourceClasses); + sourceClasses = new ClassSelector(null, ClassSelector.DEOBF_CLASS_COMPARATOR, false); + sourceClasses.setSelectionListener(this::setSourceClass); + JScrollPane sourceScroller = new JScrollPane(sourceClasses); sourcePanel.add(sourceScroller); // init dest side @@ -143,13 +137,13 @@ public class ClassMatchingGui { pane.add(destPanel, BorderLayout.WEST); destPanel.add(new JLabel("Destination Classes")); - m_top10Matches = new JCheckBox("Show only top 10 matches"); - destPanel.add(m_top10Matches); - m_top10Matches.addActionListener(event -> toggleTop10Matches()); + top10Matches = new JCheckBox("Show only top 10 matches"); + destPanel.add(top10Matches); + top10Matches.addActionListener(event -> toggleTop10Matches()); - m_destClasses = new ClassSelector(null, ClassSelector.DEOBF_CLASS_COMPARATOR, false); - m_destClasses.setSelectionListener(this::setDestClass); - JScrollPane destScroller = new JScrollPane(m_destClasses); + destClasses = new ClassSelector(null, ClassSelector.DEOBF_CLASS_COMPARATOR, false); + destClasses.setSelectionListener(this::setDestClass); + JScrollPane destScroller = new JScrollPane(destClasses); destPanel.add(destScroller); JButton autoMatchButton = new JButton("AutoMatch"); @@ -158,13 +152,14 @@ public class ClassMatchingGui { // init source panels DefaultSyntaxKit.initKit(); - m_sourceReader = new CodeReader(); - m_destReader = new CodeReader(); + sourceReader = new CodeReader(); + destReader = new CodeReader(); // init all the splits - JSplitPane splitLeft = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, true, sourcePanel, new JScrollPane(m_sourceReader)); + JSplitPane splitLeft = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, true, sourcePanel, new JScrollPane( + sourceReader)); splitLeft.setResizeWeight(0); // let the right side take all the slack - JSplitPane splitRight = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, true, new JScrollPane(m_destReader), destPanel); + JSplitPane splitRight = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, true, new JScrollPane(destReader), destPanel); splitRight.setResizeWeight(1); // let the left side take all the slack JSplitPane splitCenter = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, true, splitLeft, splitRight); splitCenter.setResizeWeight(0.5); // resize 50:50 @@ -175,55 +170,52 @@ public class ClassMatchingGui { JPanel bottomPanel = new JPanel(); bottomPanel.setLayout(new FlowLayout()); - m_sourceClassLabel = new JLabel(); - m_sourceClassLabel.setHorizontalAlignment(SwingConstants.RIGHT); - m_destClassLabel = new JLabel(); - m_destClassLabel.setHorizontalAlignment(SwingConstants.LEFT); + sourceClassLabel = new JLabel(); + sourceClassLabel.setHorizontalAlignment(SwingConstants.RIGHT); + destClassLabel = new JLabel(); + destClassLabel.setHorizontalAlignment(SwingConstants.LEFT); - m_matchButton = new JButton(); + matchButton = new JButton(); - m_advanceCheck = new JCheckBox("Advance to next likely match"); - m_advanceCheck.addActionListener(event -> { - if (m_advanceCheck.isSelected()) { + advanceCheck = new JCheckBox("Advance to next likely match"); + advanceCheck.addActionListener(event -> { + if (advanceCheck.isSelected()) { advance(); } }); - bottomPanel.add(m_sourceClassLabel); - bottomPanel.add(m_matchButton); - bottomPanel.add(m_destClassLabel); - bottomPanel.add(m_advanceCheck); + bottomPanel.add(sourceClassLabel); + bottomPanel.add(matchButton); + bottomPanel.add(destClassLabel); + bottomPanel.add(advanceCheck); pane.add(bottomPanel, BorderLayout.SOUTH); // show the frame pane.doLayout(); - m_frame.setSize(1024, 576); - m_frame.setMinimumSize(new Dimension(640, 480)); - m_frame.setVisible(true); - m_frame.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE); + frame.setSize(1024, 576); + frame.setMinimumSize(new Dimension(640, 480)); + frame.setVisible(true); + frame.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE); // init state updateDestMappings(); setSourceType(SourceType.getDefault()); updateMatchButton(); - m_saveListener = null; + saveListener = null; } public void setSaveListener(SaveListener val) { - m_saveListener = val; + saveListener = val; } private void updateDestMappings() { try { - Mappings newMappings = MappingsConverter.newMappings( - m_classMatches, - m_sourceDeobfuscator.getMappings(), - m_sourceDeobfuscator, - m_destDeobfuscator + Mappings newMappings = MappingsConverter.newMappings(classMatches, + sourceDeobfuscator.getMappings(), sourceDeobfuscator, destDeobfuscator ); // look for dropped mappings - MappingsChecker checker = new MappingsChecker(m_destDeobfuscator.getJarIndex()); + MappingsChecker checker = new MappingsChecker(destDeobfuscator.getJarIndex()); checker.dropBrokenMappings(newMappings); // count them @@ -236,7 +228,7 @@ public class ClassMatchingGui { numDroppedMethods )); - m_destDeobfuscator.setMappings(newMappings); + destDeobfuscator.setMappings(newMappings); } catch (MappingConflict ex) { System.out.println(ex.getMessage()); ex.printStackTrace(); @@ -247,14 +239,14 @@ public class ClassMatchingGui { protected void setSourceType(SourceType val) { // show the source classes - m_sourceType = val; - m_sourceClasses.setClasses(deobfuscateClasses(m_sourceType.getSourceClasses(m_classMatches), m_sourceDeobfuscator)); + sourceType = val; + sourceClasses.setClasses(deobfuscateClasses(sourceType.getSourceClasses(classMatches), sourceDeobfuscator)); // update counts for (SourceType sourceType : SourceType.values()) { - m_sourceTypeButtons.get(sourceType).setText(String.format("%s (%d)", + sourceTypeButtons.get(sourceType).setText(String.format("%s (%d)", sourceType.name(), - sourceType.getSourceClasses(m_classMatches).size() + sourceType.getSourceClasses(classMatches).size() )); } } @@ -278,7 +270,7 @@ public class ClassMatchingGui { protected void setSourceClass(ClassEntry classEntry) { Runnable onGetDestClasses = null; - if (m_advanceCheck.isSelected()) { + if (advanceCheck.isSelected()) { onGetDestClasses = this::pickBestDestClass; } @@ -288,35 +280,33 @@ public class ClassMatchingGui { protected void setSourceClass(ClassEntry classEntry, final Runnable onGetDestClasses) { // update the current source class - m_sourceClass = classEntry; - m_sourceClassLabel.setText(m_sourceClass != null ? m_sourceClass.getName() : ""); + sourceClass = classEntry; + sourceClassLabel.setText(sourceClass != null ? sourceClass.getName() : ""); - if (m_sourceClass != null) { + if (sourceClass != null) { // show the dest class(es) - ClassMatch match = m_classMatches.getMatchBySource(m_sourceDeobfuscator.obfuscateEntry(m_sourceClass)); + ClassMatch match = classMatches.getMatchBySource(sourceDeobfuscator.obfuscateEntry(sourceClass)); assert (match != null); if (match.destClasses.isEmpty()) { - m_destClasses.setClasses(null); + destClasses.setClasses(null); // run in a separate thread to keep ui responsive - new Thread() { - @Override - public void run() { - m_destClasses.setClasses(deobfuscateClasses(getLikelyMatches(m_sourceClass), m_destDeobfuscator)); - m_destClasses.expandAll(); - - if (onGetDestClasses != null) { - onGetDestClasses.run(); - } + new Thread(() -> + { + destClasses.setClasses(deobfuscateClasses(getLikelyMatches(sourceClass), destDeobfuscator)); + destClasses.expandAll(); + + if (onGetDestClasses != null) { + onGetDestClasses.run(); } - }.start(); + }).start(); } else { - m_destClasses.setClasses(deobfuscateClasses(match.destClasses, m_destDeobfuscator)); - m_destClasses.expandAll(); + destClasses.setClasses(deobfuscateClasses(match.destClasses, destDeobfuscator)); + destClasses.expandAll(); if (onGetDestClasses != null) { onGetDestClasses.run(); @@ -325,23 +315,24 @@ public class ClassMatchingGui { } setDestClass(null); - m_sourceReader.decompileClass(m_sourceClass, m_sourceDeobfuscator, () -> m_sourceReader.navigateToClassDeclaration(m_sourceClass)); + sourceReader.decompileClass( + sourceClass, sourceDeobfuscator, () -> sourceReader.navigateToClassDeclaration(sourceClass)); updateMatchButton(); } private Collection getLikelyMatches(ClassEntry sourceClass) { - ClassEntry obfSourceClass = m_sourceDeobfuscator.obfuscateEntry(sourceClass); + ClassEntry obfSourceClass = sourceDeobfuscator.obfuscateEntry(sourceClass); // set up identifiers - ClassNamer namer = new ClassNamer(m_classMatches.getUniqueMatches()); + ClassNamer namer = new ClassNamer(classMatches.getUniqueMatches()); ClassIdentifier sourceIdentifier = new ClassIdentifier( - m_sourceDeobfuscator.getJar(), m_sourceDeobfuscator.getJarIndex(), + sourceDeobfuscator.getJar(), sourceDeobfuscator.getJarIndex(), namer.getSourceNamer(), true ); ClassIdentifier destIdentifier = new ClassIdentifier( - m_destDeobfuscator.getJar(), m_destDeobfuscator.getJarIndex(), + destDeobfuscator.getJar(), destDeobfuscator.getJarIndex(), namer.getDestNamer(), true ); @@ -350,15 +341,16 @@ public class ClassMatchingGui { // rank all the unmatched dest classes against the source class ClassIdentity sourceIdentity = sourceIdentifier.identify(obfSourceClass); List scoredDestClasses = Lists.newArrayList(); - for (ClassEntry unmatchedDestClass : m_classMatches.getUnmatchedDestClasses()) { + for (ClassEntry unmatchedDestClass : classMatches.getUnmatchedDestClasses()) { ClassIdentity destIdentity = destIdentifier.identify(unmatchedDestClass); float score = 100.0f * (sourceIdentity.getMatchScore(destIdentity) + destIdentity.getMatchScore(sourceIdentity)) / (sourceIdentity.getMaxMatchScore() + destIdentity.getMaxMatchScore()); scoredDestClasses.add(new ScoredClassEntry(unmatchedDestClass, score)); } - if (m_top10Matches.isSelected() && scoredDestClasses.size() > 10) { - Collections.sort(scoredDestClasses, (a, b) -> { + if (top10Matches.isSelected() && scoredDestClasses.size() > 10) { + scoredDestClasses.sort((a, b) -> + { ScoredClassEntry sa = (ScoredClassEntry) a; ScoredClassEntry sb = (ScoredClassEntry) b; return -Float.compare(sa.getScore(), sb.getScore()); @@ -376,30 +368,30 @@ public class ClassMatchingGui { protected void setDestClass(ClassEntry classEntry) { // update the current source class - m_destClass = classEntry; - m_destClassLabel.setText(m_destClass != null ? m_destClass.getName() : ""); + destClass = classEntry; + destClassLabel.setText(destClass != null ? destClass.getName() : ""); - m_destReader.decompileClass(m_destClass, m_destDeobfuscator, () -> m_destReader.navigateToClassDeclaration(m_destClass)); + destReader.decompileClass(destClass, destDeobfuscator, () -> destReader.navigateToClassDeclaration(destClass)); updateMatchButton(); } private void updateMatchButton() { - ClassEntry obfSource = m_sourceDeobfuscator.obfuscateEntry(m_sourceClass); - ClassEntry obfDest = m_destDeobfuscator.obfuscateEntry(m_destClass); + ClassEntry obfSource = sourceDeobfuscator.obfuscateEntry(sourceClass); + ClassEntry obfDest = destDeobfuscator.obfuscateEntry(destClass); - BiMap uniqueMatches = m_classMatches.getUniqueMatches(); - boolean twoSelected = m_sourceClass != null && m_destClass != null; + BiMap uniqueMatches = classMatches.getUniqueMatches(); + boolean twoSelected = sourceClass != null && destClass != null; boolean isMatched = uniqueMatches.containsKey(obfSource) && uniqueMatches.containsValue(obfDest); boolean canMatch = !uniqueMatches.containsKey(obfSource) && !uniqueMatches.containsValue(obfDest); - GuiTricks.deactivateButton(m_matchButton); + GuiTricks.deactivateButton(matchButton); if (twoSelected) { if (isMatched) { - GuiTricks.activateButton(m_matchButton, "Unmatch", event -> onUnmatchClick()); + GuiTricks.activateButton(matchButton, "Unmatch", event -> onUnmatchClick()); } else if (canMatch) { - GuiTricks.activateButton(m_matchButton, "Match", event -> onMatchClick()); + GuiTricks.activateButton(matchButton, "Match", event -> onMatchClick()); } } } @@ -407,19 +399,19 @@ public class ClassMatchingGui { private void onMatchClick() { // precondition: source and dest classes are set correctly - ClassEntry obfSource = m_sourceDeobfuscator.obfuscateEntry(m_sourceClass); - ClassEntry obfDest = m_destDeobfuscator.obfuscateEntry(m_destClass); + ClassEntry obfSource = sourceDeobfuscator.obfuscateEntry(sourceClass); + ClassEntry obfDest = destDeobfuscator.obfuscateEntry(destClass); // remove the classes from their match - m_classMatches.removeSource(obfSource); - m_classMatches.removeDest(obfDest); + classMatches.removeSource(obfSource); + classMatches.removeDest(obfDest); // add them as matched classes - m_classMatches.add(new ClassMatch(obfSource, obfDest)); + classMatches.add(new ClassMatch(obfSource, obfDest)); ClassEntry nextClass = null; - if (m_advanceCheck.isSelected()) { - nextClass = m_sourceClasses.getNextClass(m_sourceClass); + if (advanceCheck.isSelected()) { + nextClass = sourceClasses.getNextClass(sourceClass); } save(); @@ -433,11 +425,11 @@ public class ClassMatchingGui { private void onUnmatchClick() { // precondition: source and dest classes are set to a unique match - ClassEntry obfSource = m_sourceDeobfuscator.obfuscateEntry(m_sourceClass); + ClassEntry obfSource = sourceDeobfuscator.obfuscateEntry(sourceClass); // remove the source to break the match, then add the source back as unmatched - m_classMatches.removeSource(obfSource); - m_classMatches.add(new ClassMatch(obfSource, null)); + classMatches.removeSource(obfSource); + classMatches.add(new ClassMatch(obfSource, null)); save(); updateMatches(); @@ -446,20 +438,20 @@ public class ClassMatchingGui { private void updateMatches() { updateDestMappings(); setDestClass(null); - m_destClasses.setClasses(null); + destClasses.setClasses(null); updateMatchButton(); // remember where we were in the source tree - String packageName = m_sourceClasses.getSelectedPackage(); + String packageName = sourceClasses.getSelectedPackage(); - setSourceType(m_sourceType); + setSourceType(sourceType); - m_sourceClasses.expandPackage(packageName); + sourceClasses.expandPackage(packageName); } private void save() { - if (m_saveListener != null) { - m_saveListener.save(m_classMatches); + if (saveListener != null) { + saveListener.save(classMatches); } } @@ -469,17 +461,17 @@ public class ClassMatchingGui { // compute a new matching ClassMatching matching = MappingsConverter.computeMatching( - m_sourceDeobfuscator.getJar(), m_sourceDeobfuscator.getJarIndex(), - m_destDeobfuscator.getJar(), m_destDeobfuscator.getJarIndex(), - m_classMatches.getUniqueMatches() + sourceDeobfuscator.getJar(), sourceDeobfuscator.getJarIndex(), + destDeobfuscator.getJar(), destDeobfuscator.getJarIndex(), + classMatches.getUniqueMatches() ); ClassMatches newMatches = new ClassMatches(matching.matches()); System.out.println(String.format("Automatch found %d new matches", - newMatches.getUniqueMatches().size() - m_classMatches.getUniqueMatches().size() + newMatches.getUniqueMatches().size() - classMatches.getUniqueMatches().size() )); // update the current matches - m_classMatches = newMatches; + classMatches = newMatches; save(); updateMatches(); } @@ -492,17 +484,17 @@ public class ClassMatchingGui { // make sure we have a source class if (sourceClass == null) { - sourceClass = m_sourceClasses.getSelectedClass(); + sourceClass = sourceClasses.getSelectedClass(); if (sourceClass != null) { - sourceClass = m_sourceClasses.getNextClass(sourceClass); + sourceClass = sourceClasses.getNextClass(sourceClass); } else { - sourceClass = m_sourceClasses.getFirstClass(); + sourceClass = sourceClasses.getFirstClass(); } } // set the source class setSourceClass(sourceClass, this::pickBestDestClass); - m_sourceClasses.setSelectionClass(sourceClass); + sourceClasses.setSelectionClass(sourceClass); } private void pickBestDestClass() { @@ -510,8 +502,8 @@ public class ClassMatchingGui { // then, pick the best dest class ClassEntry firstClass = null; ScoredClassEntry bestDestClass = null; - for (ClassSelectorPackageNode packageNode : m_destClasses.packageNodes()) { - for (ClassSelectorClassNode classNode : m_destClasses.classNodes(packageNode)) { + for (ClassSelectorPackageNode packageNode : destClasses.packageNodes()) { + for (ClassSelectorClassNode classNode : destClasses.classNodes(packageNode)) { if (firstClass == null) { firstClass = classNode.getClassEntry(); } @@ -533,14 +525,14 @@ public class ClassMatchingGui { } setDestClass(destClass); - m_destClasses.setSelectionClass(destClass); + destClasses.setSelectionClass(destClass); } private void toggleTop10Matches() { - if (m_sourceClass != null) { - m_destClasses.clearSelection(); - m_destClasses.setClasses(deobfuscateClasses(getLikelyMatches(m_sourceClass), m_destDeobfuscator)); - m_destClasses.expandAll(); + if (sourceClass != null) { + destClasses.clearSelection(); + destClasses.setClasses(deobfuscateClasses(getLikelyMatches(sourceClass), destDeobfuscator)); + destClasses.expandAll(); } } } diff --git a/src/main/java/cuchaz/enigma/gui/ClassSelector.java b/src/main/java/cuchaz/enigma/gui/ClassSelector.java index 435509e..8ece0a0 100644 --- a/src/main/java/cuchaz/enigma/gui/ClassSelector.java +++ b/src/main/java/cuchaz/enigma/gui/ClassSelector.java @@ -29,7 +29,7 @@ import java.util.*; public class ClassSelector extends JTree { - public static final Comparator DEOBF_CLASS_COMPARATOR = (a, b) -> a.getName().compareTo(b.getName()); + public static final Comparator DEOBF_CLASS_COMPARATOR = Comparator.comparing(ClassEntry::getName); private DefaultMutableTreeNode rootNodes; public interface ClassSelectionListener { @@ -177,25 +177,32 @@ public class ClassSelector extends JTree { // sort the packages List sortedPackageNames = Lists.newArrayList(packages.keySet()); - Collections.sort(sortedPackageNames, (a, b) -> { + sortedPackageNames.sort((a, b) -> + { // I can never keep this rule straight when writing these damn things... // a < b => -1, a == b => 0, a > b => +1 - if(b == null || a == null){ + if (b == null || a == null) + { return 0; } String[] aparts = a.split("/"); String[] bparts = b.split("/"); - for (int i = 0; true; i++) { - if (i >= aparts.length) { + for (int i = 0; true; i++) + { + if (i >= aparts.length) + { return -1; - } else if (i >= bparts.length) { + } + else if (i >= bparts.length) + { return 1; } int result = aparts[i].compareTo(bparts[i]); - if (result != 0) { + if (result != 0) + { return result; } } @@ -219,7 +226,7 @@ public class ClassSelector extends JTree { for (String packageName : packagedClassEntries.keySet()) { // sort the class entries List classEntriesInPackage = Lists.newArrayList(packagedClassEntries.get(packageName)); - Collections.sort(classEntriesInPackage, this.comparator); + classEntriesInPackage.sort(this.comparator); // create the nodes in order for (ClassEntry classEntry : classEntriesInPackage) { @@ -274,7 +281,7 @@ public class ClassSelector extends JTree { public String getExpansionState(JTree tree, int row) { TreePath rowPath = tree.getPathForRow(row); - StringBuffer buf = new StringBuffer(); + StringBuilder buf = new StringBuilder(); int rowCount = tree.getRowCount(); for (int i = row; i < rowCount; i++) { TreePath path = tree.getPathForRow(i); @@ -500,7 +507,7 @@ public class ClassSelector extends JTree { { List classNodes = classNodes(newPackageNode); classNodes.add(classNode); - Collections.sort(classNodes, (a, b) -> a.toString().compareTo(b.toString())); + classNodes.sort(Comparator.comparing(ClassSelectorClassNode::toString)); for (int i = 0; i < classNodes.size(); i++) if (classNodes.get(i) == classNode) return i; @@ -514,7 +521,7 @@ public class ClassSelector extends JTree { if (!packageNodes.contains(newPackageNode)) { packageNodes.add(newPackageNode); - Collections.sort(packageNodes, (a, b) -> a.toString().compareTo(b.toString())); + packageNodes.sort(Comparator.comparing(ClassSelectorPackageNode::toString)); } for (int i = 0; i < packageNodes.size(); i++) diff --git a/src/main/java/cuchaz/enigma/gui/CodeReader.java b/src/main/java/cuchaz/enigma/gui/CodeReader.java index 601e5b9..8225d8f 100644 --- a/src/main/java/cuchaz/enigma/gui/CodeReader.java +++ b/src/main/java/cuchaz/enigma/gui/CodeReader.java @@ -19,8 +19,6 @@ import java.awt.event.ActionListener; import javax.swing.JEditorPane; import javax.swing.SwingUtilities; import javax.swing.Timer; -import javax.swing.event.CaretEvent; -import javax.swing.event.CaretListener; import javax.swing.text.BadLocationException; import javax.swing.text.Highlighter.HighlightPainter; @@ -38,15 +36,15 @@ public class CodeReader extends JEditorPane { private static final long serialVersionUID = 3673180950485748810L; - private static final Object m_lock = new Object(); + private static final Object lock = new Object(); public interface SelectionListener { void onSelect(EntryReference reference); } - private SelectionHighlightPainter m_selectionHighlightPainter; - private SourceIndex m_sourceIndex; - private SelectionListener m_selectionListener; + private SelectionHighlightPainter selectionHighlightPainter; + private SourceIndex sourceIndex; + private SelectionListener selectionListener; public CodeReader() { @@ -58,38 +56,34 @@ public class CodeReader extends JEditorPane { kit.toggleComponent(this, "de.sciss.syntaxpane.components.TokenMarker"); // hook events - addCaretListener(new CaretListener() { - @Override - public void caretUpdate(CaretEvent event) { - if (m_selectionListener != null && m_sourceIndex != null) { - Token token = m_sourceIndex.getReferenceToken(event.getDot()); - if (token != null) { - m_selectionListener.onSelect(m_sourceIndex.getDeobfReference(token)); - } else { - m_selectionListener.onSelect(null); - } + addCaretListener(event -> + { + if (selectionListener != null && sourceIndex != null) { + Token token = sourceIndex.getReferenceToken(event.getDot()); + if (token != null) { + selectionListener.onSelect(sourceIndex.getDeobfReference(token)); + } else { + selectionListener.onSelect(null); } } }); - m_selectionHighlightPainter = new SelectionHighlightPainter(); - m_sourceIndex = null; - m_selectionListener = null; + selectionHighlightPainter = new SelectionHighlightPainter(); } public void setSelectionListener(SelectionListener val) { - m_selectionListener = val; + selectionListener = val; } public void setCode(String code) { // sadly, the java lexer is not thread safe, so we have to serialize all these calls - synchronized (m_lock) { + synchronized (lock) { setText(code); } } public SourceIndex getSourceIndex() { - return m_sourceIndex; + return sourceIndex; } public void decompileClass(ClassEntry classEntry, Deobfuscator deobfuscator) { @@ -110,33 +104,31 @@ public class CodeReader extends JEditorPane { setCode("(decompiling...)"); // run decompilation in a separate thread to keep ui responsive - new Thread() { - @Override - public void run() { + new Thread(() -> + { - // decompile it - CompilationUnit sourceTree = deobfuscator.getSourceTree(classEntry.getOutermostClassName()); - String source = deobfuscator.getSource(sourceTree); - setCode(source); - m_sourceIndex = deobfuscator.getSourceIndex(sourceTree, source, ignoreBadTokens); + // decompile it + CompilationUnit sourceTree = deobfuscator.getSourceTree(classEntry.getOutermostClassName()); + String source = deobfuscator.getSource(sourceTree); + setCode(source); + sourceIndex = deobfuscator.getSourceIndex(sourceTree, source, ignoreBadTokens); - if (callback != null) { - callback.run(); - } + if (callback != null) { + callback.run(); } - }.start(); + }).start(); } public void navigateToClassDeclaration(ClassEntry classEntry) { // navigate to the class declaration - Token token = m_sourceIndex.getDeclarationToken(classEntry); + Token token = sourceIndex.getDeclarationToken(classEntry); if (token == null) { // couldn't find the class declaration token, might be an anonymous class // look for any declaration in that class instead - for (Entry entry : m_sourceIndex.declarations()) { + for (Entry entry : sourceIndex.declarations()) { if (entry.getClassEntry().equals(classEntry)) { - token = m_sourceIndex.getDeclarationToken(entry); + token = sourceIndex.getDeclarationToken(entry); break; } } @@ -151,7 +143,7 @@ public class CodeReader extends JEditorPane { } public void navigateToToken(final Token token) { - navigateToToken(this, token, m_selectionHighlightPainter); + navigateToToken(this, token, selectionHighlightPainter); } // HACKHACK: someday we can update the main GUI to use this code reader @@ -167,34 +159,29 @@ public class CodeReader extends JEditorPane { Rectangle end = editor.modelToView(token.end); final Rectangle show = start.union(end); show.grow(start.width * 10, start.height * 6); - SwingUtilities.invokeLater(new Runnable() { - @Override - public void run() { - editor.scrollRectToVisible(show); - } - }); + SwingUtilities.invokeLater(() -> editor.scrollRectToVisible(show)); } catch (BadLocationException ex) { throw new Error(ex); } // highlight the token momentarily final Timer timer = new Timer(200, new ActionListener() { - private int m_counter = 0; - private Object m_highlight = null; + private int counter = 0; + private Object highlight = null; @Override public void actionPerformed(ActionEvent event) { - if (m_counter % 2 == 0) { + if (counter % 2 == 0) { try { - m_highlight = editor.getHighlighter().addHighlight(token.start, token.end, highlightPainter); + highlight = editor.getHighlighter().addHighlight(token.start, token.end, highlightPainter); } catch (BadLocationException ex) { // don't care } - } else if (m_highlight != null) { - editor.getHighlighter().removeHighlight(m_highlight); + } else if (highlight != null) { + editor.getHighlighter().removeHighlight(highlight); } - if (m_counter++ > 6) { + if (counter++ > 6) { Timer timer = (Timer) event.getSource(); timer.stop(); } diff --git a/src/main/java/cuchaz/enigma/gui/Gui.java b/src/main/java/cuchaz/enigma/gui/Gui.java index ed18777..7cb494f 100644 --- a/src/main/java/cuchaz/enigma/gui/Gui.java +++ b/src/main/java/cuchaz/enigma/gui/Gui.java @@ -62,23 +62,23 @@ public class Gui { private final MenuBar menuBar; public final PopupMenuBar popupMenu; - private JFrame frame; - private PanelEditor editor; - private JPanel classesPanel; - private JSplitPane m_splitClasses; - private PanelIdentifier m_infoPanel; - private ObfuscatedHighlightPainter m_obfuscatedHighlightPainter; - private DeobfuscatedHighlightPainter m_deobfuscatedHighlightPainter; - private OtherHighlightPainter m_otherHighlightPainter; - private SelectionHighlightPainter m_selectionHighlightPainter; - private JTree m_inheritanceTree; - private JTree m_implementationsTree; - private JTree m_callsTree; - private JList m_tokens; - private JTabbedPane m_tabs; + private JFrame frame; + private PanelEditor editor; + private JPanel classesPanel; + private JSplitPane splitClasses; + private PanelIdentifier infoPanel; + private ObfuscatedHighlightPainter obfuscatedHighlightPainter; + private DeobfuscatedHighlightPainter deobfuscatedHighlightPainter; + private OtherHighlightPainter otherHighlightPainter; + private SelectionHighlightPainter selectionHighlightPainter; + private JTree inheritanceTree; + private JTree implementationsTree; + private JTree callsTree; + private JList tokens; + private JTabbedPane tabs; // state - public EntryReference m_reference; + public EntryReference reference; public JFileChooser jarFileChooser; public JFileChooser enigmaMappingsFileChooser; @@ -118,22 +118,22 @@ public class Gui { this.deobfPanel = new PanelDeobf(this); // set up classes panel (don't add the splitter yet) - m_splitClasses = new JSplitPane(JSplitPane.VERTICAL_SPLIT, true, this.obfPanel, this.deobfPanel); - m_splitClasses.setResizeWeight(0.3); + splitClasses = new JSplitPane(JSplitPane.VERTICAL_SPLIT, true, this.obfPanel, this.deobfPanel); + splitClasses.setResizeWeight(0.3); this.classesPanel = new JPanel(); this.classesPanel.setLayout(new BorderLayout()); this.classesPanel.setPreferredSize(new Dimension(250, 0)); // init info panel - m_infoPanel = new PanelIdentifier(this); - m_infoPanel.clearReference(); + infoPanel = new PanelIdentifier(this); + infoPanel.clearReference(); // init editor DefaultSyntaxKit.initKit(); - m_obfuscatedHighlightPainter = new ObfuscatedHighlightPainter(); - m_deobfuscatedHighlightPainter = new DeobfuscatedHighlightPainter(); - m_otherHighlightPainter = new OtherHighlightPainter(); - m_selectionHighlightPainter = new SelectionHighlightPainter(); + obfuscatedHighlightPainter = new ObfuscatedHighlightPainter(); + deobfuscatedHighlightPainter = new DeobfuscatedHighlightPainter(); + otherHighlightPainter = new OtherHighlightPainter(); + selectionHighlightPainter = new SelectionHighlightPainter(); this.editor = new PanelEditor(this); JScrollPane sourceScroller = new JScrollPane(this.editor); this.editor.setContentType("text/java"); @@ -145,14 +145,14 @@ public class Gui { this.editor.setComponentPopupMenu(this.popupMenu); // init inheritance panel - m_inheritanceTree = new JTree(); - m_inheritanceTree.setModel(null); - m_inheritanceTree.addMouseListener(new MouseAdapter() { + inheritanceTree = new JTree(); + inheritanceTree.setModel(null); + inheritanceTree.addMouseListener(new MouseAdapter() { @Override public void mouseClicked(MouseEvent event) { if (event.getClickCount() == 2) { // get the selected node - TreePath path = m_inheritanceTree.getSelectionPath(); + TreePath path = inheritanceTree.getSelectionPath(); if (path == null) { return; } @@ -172,17 +172,17 @@ public class Gui { }); JPanel inheritancePanel = new JPanel(); inheritancePanel.setLayout(new BorderLayout()); - inheritancePanel.add(new JScrollPane(m_inheritanceTree)); + inheritancePanel.add(new JScrollPane(inheritanceTree)); // init implementations panel - m_implementationsTree = new JTree(); - m_implementationsTree.setModel(null); - m_implementationsTree.addMouseListener(new MouseAdapter() { + implementationsTree = new JTree(); + implementationsTree.setModel(null); + implementationsTree.addMouseListener(new MouseAdapter() { @Override public void mouseClicked(MouseEvent event) { if (event.getClickCount() == 2) { // get the selected node - TreePath path = m_implementationsTree.getSelectionPath(); + TreePath path = implementationsTree.getSelectionPath(); if (path == null) { return; } @@ -200,18 +200,18 @@ public class Gui { }); JPanel implementationsPanel = new JPanel(); implementationsPanel.setLayout(new BorderLayout()); - implementationsPanel.add(new JScrollPane(m_implementationsTree)); + implementationsPanel.add(new JScrollPane(implementationsTree)); // init call panel - m_callsTree = new JTree(); - m_callsTree.setModel(null); - m_callsTree.addMouseListener(new MouseAdapter() { + callsTree = new JTree(); + callsTree.setModel(null); + callsTree.addMouseListener(new MouseAdapter() { @SuppressWarnings("unchecked") @Override public void mouseClicked(MouseEvent event) { if (event.getClickCount() == 2) { // get the selected node - TreePath path = m_callsTree.getSelectionPath(); + TreePath path = callsTree.getSelectionPath(); if (path == null) { return; } @@ -228,28 +228,28 @@ public class Gui { } } }); - m_tokens = new JList<>(); - m_tokens.setCellRenderer(new TokenListCellRenderer(this.controller)); - m_tokens.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); - m_tokens.setLayoutOrientation(JList.VERTICAL); - m_tokens.addMouseListener(new MouseAdapter() { + tokens = new JList<>(); + tokens.setCellRenderer(new TokenListCellRenderer(this.controller)); + tokens.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); + tokens.setLayoutOrientation(JList.VERTICAL); + tokens.addMouseListener(new MouseAdapter() { @Override public void mouseClicked(MouseEvent event) { if (event.getClickCount() == 2) { - Token selected = m_tokens.getSelectedValue(); + Token selected = tokens.getSelectedValue(); if (selected != null) { showToken(selected); } } } }); - m_tokens.setPreferredSize(new Dimension(0, 200)); - m_tokens.setMinimumSize(new Dimension(0, 200)); + tokens.setPreferredSize(new Dimension(0, 200)); + tokens.setMinimumSize(new Dimension(0, 200)); JSplitPane callPanel = new JSplitPane( JSplitPane.VERTICAL_SPLIT, true, - new JScrollPane(m_callsTree), - new JScrollPane(m_tokens) + new JScrollPane(callsTree), + new JScrollPane(tokens) ); callPanel.setResizeWeight(1); // let the top side take all the slack callPanel.resetToPreferredSizes(); @@ -257,14 +257,14 @@ public class Gui { // layout controls JPanel centerPanel = new JPanel(); centerPanel.setLayout(new BorderLayout()); - centerPanel.add(m_infoPanel, BorderLayout.NORTH); + centerPanel.add(infoPanel, BorderLayout.NORTH); centerPanel.add(sourceScroller, BorderLayout.CENTER); - m_tabs = new JTabbedPane(); - m_tabs.setPreferredSize(new Dimension(250, 0)); - m_tabs.addTab("Inheritance", inheritancePanel); - m_tabs.addTab("Implementations", implementationsPanel); - m_tabs.addTab("Call Graph", callPanel); - JSplitPane splitRight = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, true, centerPanel, m_tabs); + tabs = new JTabbedPane(); + tabs.setPreferredSize(new Dimension(250, 0)); + tabs.addTab("Inheritance", inheritancePanel); + tabs.addTab("Implementations", implementationsPanel); + tabs.addTab("Call Graph", callPanel); + JSplitPane splitRight = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, true, centerPanel, tabs); splitRight.setResizeWeight(1); // let the left side take all the slack splitRight.resetToPreferredSizes(); JSplitPane splitCenter = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, true, this.classesPanel, splitRight); @@ -314,7 +314,7 @@ public class Gui { // update gui this.frame.setTitle(Constants.NAME + " - " + jarName); this.classesPanel.removeAll(); - this.classesPanel.add(m_splitClasses); + this.classesPanel.add(splitClasses); setSource(null); // update menu @@ -375,7 +375,7 @@ public class Gui { if (token == null) { throw new IllegalArgumentException("Token cannot be null!"); } - CodeReader.navigateToToken(this.editor, token, m_selectionHighlightPainter); + CodeReader.navigateToToken(this.editor, token, selectionHighlightPainter); redraw(); } @@ -384,10 +384,10 @@ public class Gui { Collections.sort(sortedTokens); if (sortedTokens.size() > 1) { // sort the tokens and update the tokens panel - m_tokens.setListData(sortedTokens); - m_tokens.setSelectedIndex(0); + this.tokens.setListData(sortedTokens); + this.tokens.setSelectedIndex(0); } else { - m_tokens.setListData(new Vector<>()); + this.tokens.setListData(new Vector<>()); } // show the first token @@ -401,13 +401,13 @@ public class Gui { // color things based on the index if (obfuscatedTokens != null) { - setHighlightedTokens(obfuscatedTokens, m_obfuscatedHighlightPainter); + setHighlightedTokens(obfuscatedTokens, obfuscatedHighlightPainter); } if (deobfuscatedTokens != null) { - setHighlightedTokens(deobfuscatedTokens, m_deobfuscatedHighlightPainter); + setHighlightedTokens(deobfuscatedTokens, deobfuscatedHighlightPainter); } if (otherTokens != null) { - setHighlightedTokens(otherTokens, m_otherHighlightPainter); + setHighlightedTokens(otherTokens, otherHighlightPainter); } redraw(); @@ -425,73 +425,73 @@ public class Gui { private void showReference(EntryReference reference) { if (reference == null) { - m_infoPanel.clearReference(); + infoPanel.clearReference(); return; } - m_reference = reference; + this.reference = reference; - m_infoPanel.removeAll(); + infoPanel.removeAll(); if (reference.entry instanceof ClassEntry) { - showClassEntry((ClassEntry) m_reference.entry); - } else if (m_reference.entry instanceof FieldEntry) { - showFieldEntry((FieldEntry) m_reference.entry); - } else if (m_reference.entry instanceof MethodEntry) { - showMethodEntry((MethodEntry) m_reference.entry); - } else if (m_reference.entry instanceof ConstructorEntry) { - showConstructorEntry((ConstructorEntry) m_reference.entry); - } else if (m_reference.entry instanceof ArgumentEntry) { - showArgumentEntry((ArgumentEntry) m_reference.entry); - } else if (m_reference.entry instanceof LocalVariableEntry) { - showLocalVariableEntry((LocalVariableEntry) m_reference.entry); + showClassEntry((ClassEntry) this.reference.entry); + } else if (this.reference.entry instanceof FieldEntry) { + showFieldEntry((FieldEntry) this.reference.entry); + } else if (this.reference.entry instanceof MethodEntry) { + showMethodEntry((MethodEntry) this.reference.entry); + } else if (this.reference.entry instanceof ConstructorEntry) { + showConstructorEntry((ConstructorEntry) this.reference.entry); + } else if (this.reference.entry instanceof ArgumentEntry) { + showArgumentEntry((ArgumentEntry) this.reference.entry); + } else if (this.reference.entry instanceof LocalVariableEntry) { + showLocalVariableEntry((LocalVariableEntry) this.reference.entry); } else { - throw new Error("Unknown entry type: " + m_reference.entry.getClass().getName()); + throw new Error("Unknown entry type: " + this.reference.entry.getClass().getName()); } redraw(); } private void showLocalVariableEntry(LocalVariableEntry entry) { - addNameValue(m_infoPanel, "Variable", entry.getName()); - addNameValue(m_infoPanel, "Class", entry.getClassEntry().getName()); - addNameValue(m_infoPanel, "Method", entry.getBehaviorEntry().getName()); - addNameValue(m_infoPanel, "Index", Integer.toString(entry.getIndex())); - addNameValue(m_infoPanel, "Type", entry.getType().toString()); + addNameValue(infoPanel, "Variable", entry.getName()); + addNameValue(infoPanel, "Class", entry.getClassEntry().getName()); + addNameValue(infoPanel, "Method", entry.getBehaviorEntry().getName()); + addNameValue(infoPanel, "Index", Integer.toString(entry.getIndex())); + addNameValue(infoPanel, "Type", entry.getType().toString()); } private void showClassEntry(ClassEntry entry) { - addNameValue(m_infoPanel, "Class", entry.getName()); - addModifierComboBox(m_infoPanel, "Modifier", entry); + addNameValue(infoPanel, "Class", entry.getName()); + addModifierComboBox(infoPanel, "Modifier", entry); } private void showFieldEntry(FieldEntry entry) { - addNameValue(m_infoPanel, "Field", entry.getName()); - addNameValue(m_infoPanel, "Class", entry.getClassEntry().getName()); - addNameValue(m_infoPanel, "Type", entry.getType().toString()); - addModifierComboBox(m_infoPanel, "Modifier", entry); + addNameValue(infoPanel, "Field", entry.getName()); + addNameValue(infoPanel, "Class", entry.getClassEntry().getName()); + addNameValue(infoPanel, "Type", entry.getType().toString()); + addModifierComboBox(infoPanel, "Modifier", entry); } private void showMethodEntry(MethodEntry entry) { - addNameValue(m_infoPanel, "Method", entry.getName()); - addNameValue(m_infoPanel, "Class", entry.getClassEntry().getName()); - addNameValue(m_infoPanel, "Signature", entry.getSignature().toString()); - addModifierComboBox(m_infoPanel, "Modifier", entry); + addNameValue(infoPanel, "Method", entry.getName()); + addNameValue(infoPanel, "Class", entry.getClassEntry().getName()); + addNameValue(infoPanel, "Signature", entry.getSignature().toString()); + addModifierComboBox(infoPanel, "Modifier", entry); } private void showConstructorEntry(ConstructorEntry entry) { - addNameValue(m_infoPanel, "Constructor", entry.getClassEntry().getName()); + addNameValue(infoPanel, "Constructor", entry.getClassEntry().getName()); if (!entry.isStatic()) { - addNameValue(m_infoPanel, "Signature", entry.getSignature().toString()); - addModifierComboBox(m_infoPanel, "Modifier", entry); + addNameValue(infoPanel, "Signature", entry.getSignature().toString()); + addModifierComboBox(infoPanel, "Modifier", entry); } } private void showArgumentEntry(ArgumentEntry entry) { - addNameValue(m_infoPanel, "Argument", entry.getName()); - addNameValue(m_infoPanel, "Class", entry.getClassEntry().getName()); - addNameValue(m_infoPanel, "Method", entry.getBehaviorEntry().getName()); - addNameValue(m_infoPanel, "Index", Integer.toString(entry.getIndex())); + addNameValue(infoPanel, "Argument", entry.getName()); + addNameValue(infoPanel, "Class", entry.getClassEntry().getName()); + addNameValue(infoPanel, "Method", entry.getBehaviorEntry().getName()); + addNameValue(infoPanel, "Index", Integer.toString(entry.getIndex())); } private void addNameValue(JPanel container, String name, String value) { @@ -530,18 +530,18 @@ public class Gui { Token token = this.controller.getToken(pos); boolean isToken = token != null; - m_reference = this.controller.getDeobfReference(token); - boolean isClassEntry = isToken && m_reference.entry instanceof ClassEntry; - boolean isFieldEntry = isToken && m_reference.entry instanceof FieldEntry; - boolean isMethodEntry = isToken && m_reference.entry instanceof MethodEntry; - boolean isConstructorEntry = isToken && m_reference.entry instanceof ConstructorEntry; - boolean isInJar = isToken && this.controller.entryIsInJar(m_reference.entry); - boolean isRenameable = isToken && this.controller.referenceIsRenameable(m_reference); + reference = this.controller.getDeobfReference(token); + boolean isClassEntry = isToken && reference.entry instanceof ClassEntry; + boolean isFieldEntry = isToken && reference.entry instanceof FieldEntry; + boolean isMethodEntry = isToken && reference.entry instanceof MethodEntry; + boolean isConstructorEntry = isToken && reference.entry instanceof ConstructorEntry; + boolean isInJar = isToken && this.controller.entryIsInJar(reference.entry); + boolean isRenameable = isToken && this.controller.referenceIsRenameable(reference); if (isToken) { - showReference(m_reference); + showReference(reference); } else { - m_infoPanel.clearReference(); + infoPanel.clearReference(); } this.popupMenu.renameMenu.setEnabled(isRenameable); @@ -552,7 +552,7 @@ public class Gui { this.popupMenu.openPreviousMenu.setEnabled(this.controller.hasPreviousLocation()); this.popupMenu.toggleMappingMenu.setEnabled(isRenameable); - if (isToken && this.controller.entryHasDeobfuscatedName(m_reference.entry)) { + if (isToken && this.controller.entryHasDeobfuscatedName(reference.entry)) { this.popupMenu.toggleMappingMenu.setText("Reset to obfuscated"); } else { this.popupMenu.toggleMappingMenu.setText("Mark as deobfuscated"); @@ -564,8 +564,8 @@ public class Gui { // entry is not in the jar. Ignore it return; } - if (m_reference != null) { - this.controller.savePreviousReference(m_reference); + if (reference != null) { + this.controller.savePreviousReference(reference); } this.controller.openDeclaration(entry); } @@ -574,8 +574,8 @@ public class Gui { if (!this.controller.entryIsInJar(reference.getLocationClassEntry())) { return; } - if (m_reference != null) { - this.controller.savePreviousReference(m_reference); + if (this.reference != null) { + this.controller.savePreviousReference(this.reference); } this.controller.openReference(reference); } @@ -584,7 +584,7 @@ public class Gui { // init the text box final JTextField text = new JTextField(); - text.setText(m_reference.getNamableName()); + text.setText(reference.getNamableName()); text.setPreferredSize(new Dimension(360, text.getPreferredSize().height)); text.addKeyListener(new KeyAdapter() { @Override @@ -604,14 +604,14 @@ public class Gui { }); // find the label with the name and replace it with the text box - JPanel panel = (JPanel) m_infoPanel.getComponent(0); + JPanel panel = (JPanel) infoPanel.getComponent(0); panel.remove(panel.getComponentCount() - 1); panel.add(text); text.grabFocus(); int offset = text.getText().lastIndexOf('/') + 1; // If it's a class and isn't in the default package, assume that it's deobfuscated. - if (m_reference.getNameableEntry() instanceof ClassEntry && text.getText().contains("/") && offset != 0) + if (reference.getNameableEntry() instanceof ClassEntry && text.getText().contains("/") && offset != 0) text.select(offset, text.getText().length()); else text.selectAll(); @@ -623,7 +623,7 @@ public class Gui { String newName = text.getText(); if (saveName && newName != null && newName.length() > 0) { try { - this.controller.rename(m_reference, newName); + this.controller.rename(reference, newName); } catch (IllegalNameException ex) { text.setBorder(BorderFactory.createLineBorder(Color.red, 1)); text.setToolTipText(ex.getReason()); @@ -633,9 +633,9 @@ public class Gui { } // abort the rename - JPanel panel = (JPanel) m_infoPanel.getComponent(0); + JPanel panel = (JPanel) infoPanel.getComponent(0); panel.remove(panel.getComponentCount() - 1); - panel.add(Utils.unboldLabel(new JLabel(m_reference.getNamableName(), JLabel.LEFT))); + panel.add(Utils.unboldLabel(new JLabel(reference.getNamableName(), JLabel.LEFT))); this.editor.grabFocus(); @@ -644,95 +644,95 @@ public class Gui { public void showInheritance() { - if (m_reference == null) { + if (reference == null) { return; } - m_inheritanceTree.setModel(null); + inheritanceTree.setModel(null); - if (m_reference.entry instanceof ClassEntry) { + if (reference.entry instanceof ClassEntry) { // get the class inheritance - ClassInheritanceTreeNode classNode = this.controller.getClassInheritance((ClassEntry) m_reference.entry); + ClassInheritanceTreeNode classNode = this.controller.getClassInheritance((ClassEntry) reference.entry); // show the tree at the root TreePath path = getPathToRoot(classNode); - m_inheritanceTree.setModel(new DefaultTreeModel((TreeNode) path.getPathComponent(0))); - m_inheritanceTree.expandPath(path); - m_inheritanceTree.setSelectionRow(m_inheritanceTree.getRowForPath(path)); - } else if (m_reference.entry instanceof MethodEntry) { + inheritanceTree.setModel(new DefaultTreeModel((TreeNode) path.getPathComponent(0))); + inheritanceTree.expandPath(path); + inheritanceTree.setSelectionRow(inheritanceTree.getRowForPath(path)); + } else if (reference.entry instanceof MethodEntry) { // get the method inheritance - MethodInheritanceTreeNode classNode = this.controller.getMethodInheritance((MethodEntry) m_reference.entry); + MethodInheritanceTreeNode classNode = this.controller.getMethodInheritance((MethodEntry) reference.entry); // show the tree at the root TreePath path = getPathToRoot(classNode); - m_inheritanceTree.setModel(new DefaultTreeModel((TreeNode) path.getPathComponent(0))); - m_inheritanceTree.expandPath(path); - m_inheritanceTree.setSelectionRow(m_inheritanceTree.getRowForPath(path)); + inheritanceTree.setModel(new DefaultTreeModel((TreeNode) path.getPathComponent(0))); + inheritanceTree.expandPath(path); + inheritanceTree.setSelectionRow(inheritanceTree.getRowForPath(path)); } - m_tabs.setSelectedIndex(0); + tabs.setSelectedIndex(0); redraw(); } public void showImplementations() { - if (m_reference == null) { + if (reference == null) { return; } - m_implementationsTree.setModel(null); + implementationsTree.setModel(null); DefaultMutableTreeNode node = null; // get the class implementations - if (m_reference.entry instanceof ClassEntry) - node = this.controller.getClassImplementations((ClassEntry) m_reference.entry); + if (reference.entry instanceof ClassEntry) + node = this.controller.getClassImplementations((ClassEntry) reference.entry); else // get the method implementations - if (m_reference.entry instanceof MethodEntry) - node = this.controller.getMethodImplementations((MethodEntry) m_reference.entry); + if (reference.entry instanceof MethodEntry) + node = this.controller.getMethodImplementations((MethodEntry) reference.entry); if (node != null) { // show the tree at the root TreePath path = getPathToRoot(node); - m_implementationsTree.setModel(new DefaultTreeModel((TreeNode) path.getPathComponent(0))); - m_implementationsTree.expandPath(path); - m_implementationsTree.setSelectionRow(m_implementationsTree.getRowForPath(path)); + implementationsTree.setModel(new DefaultTreeModel((TreeNode) path.getPathComponent(0))); + implementationsTree.expandPath(path); + implementationsTree.setSelectionRow(implementationsTree.getRowForPath(path)); } - m_tabs.setSelectedIndex(1); + tabs.setSelectedIndex(1); redraw(); } public void showCalls() { - if (m_reference == null) { + if (reference == null) { return; } - if (m_reference.entry instanceof ClassEntry) { + if (reference.entry instanceof ClassEntry) { // look for calls to the default constructor // TODO: get a list of all the constructors and find calls to all of them - BehaviorReferenceTreeNode node = this.controller.getMethodReferences(new ConstructorEntry((ClassEntry) m_reference.entry, new Signature("()V"))); - m_callsTree.setModel(new DefaultTreeModel(node)); - } else if (m_reference.entry instanceof FieldEntry) { - FieldReferenceTreeNode node = this.controller.getFieldReferences((FieldEntry) m_reference.entry); - m_callsTree.setModel(new DefaultTreeModel(node)); - } else if (m_reference.entry instanceof MethodEntry) { - BehaviorReferenceTreeNode node = this.controller.getMethodReferences((MethodEntry) m_reference.entry); - m_callsTree.setModel(new DefaultTreeModel(node)); - } else if (m_reference.entry instanceof ConstructorEntry) { - BehaviorReferenceTreeNode node = this.controller.getMethodReferences((ConstructorEntry) m_reference.entry); - m_callsTree.setModel(new DefaultTreeModel(node)); + BehaviorReferenceTreeNode node = this.controller.getMethodReferences(new ConstructorEntry((ClassEntry) reference.entry, new Signature("()V"))); + callsTree.setModel(new DefaultTreeModel(node)); + } else if (reference.entry instanceof FieldEntry) { + FieldReferenceTreeNode node = this.controller.getFieldReferences((FieldEntry) reference.entry); + callsTree.setModel(new DefaultTreeModel(node)); + } else if (reference.entry instanceof MethodEntry) { + BehaviorReferenceTreeNode node = this.controller.getMethodReferences((MethodEntry) reference.entry); + callsTree.setModel(new DefaultTreeModel(node)); + } else if (reference.entry instanceof ConstructorEntry) { + BehaviorReferenceTreeNode node = this.controller.getMethodReferences((ConstructorEntry) reference.entry); + callsTree.setModel(new DefaultTreeModel(node)); } - m_tabs.setSelectedIndex(2); + tabs.setSelectedIndex(2); redraw(); } public void toggleMapping() { - if (this.controller.entryHasDeobfuscatedName(m_reference.entry)) { - this.controller.removeMapping(m_reference); + if (this.controller.entryHasDeobfuscatedName(reference.entry)) { + this.controller.removeMapping(reference); } else { - this.controller.markAsDeobfuscated(m_reference); + this.controller.markAsDeobfuscated(reference); } } diff --git a/src/main/java/cuchaz/enigma/gui/GuiController.java b/src/main/java/cuchaz/enigma/gui/GuiController.java index c2e202e..68fd484 100644 --- a/src/main/java/cuchaz/enigma/gui/GuiController.java +++ b/src/main/java/cuchaz/enigma/gui/GuiController.java @@ -50,7 +50,7 @@ public class GuiController { return this.isDirty; } - public void openJar(final JarFile jar) throws IOException { + public void openJar(final JarFile jar) { this.gui.onStartOpenJar(); this.deobfuscator = new Deobfuscator(jar); this.gui.onFinishOpenJar(this.deobfuscator.getJarName()); @@ -302,42 +302,40 @@ public class GuiController { this.gui.setSource("(deobfuscating...)"); // run the deobfuscator in a separate thread so we don't block the GUI event queue - new Thread() { - @Override - public void run() { - // decompile,deobfuscate the bytecode - CompilationUnit sourceTree = deobfuscator.getSourceTree(classEntry.getClassName()); - if (sourceTree == null) { - // decompilation of this class is not supported - gui.setSource("Unable to find class: " + classEntry); - return; - } - String source = deobfuscator.getSource(sourceTree); - index = deobfuscator.getSourceIndex(sourceTree, source); - gui.setSource(index.getSource()); - if (obfReference != null) { - showReference(obfReference); - } + new Thread(() -> + { + // decompile,deobfuscate the bytecode + CompilationUnit sourceTree = deobfuscator.getSourceTree(classEntry.getClassName()); + if (sourceTree == null) { + // decompilation of this class is not supported + gui.setSource("Unable to find class: " + classEntry); + return; + } + String source = deobfuscator.getSource(sourceTree); + index = deobfuscator.getSourceIndex(sourceTree, source); + gui.setSource(index.getSource()); + if (obfReference != null) { + showReference(obfReference); + } - // set the highlighted tokens - List obfuscatedTokens = Lists.newArrayList(); - List deobfuscatedTokens = Lists.newArrayList(); - List otherTokens = Lists.newArrayList(); - for (Token token : index.referenceTokens()) { - EntryReference reference = index.getDeobfReference(token); - if (referenceIsRenameable(reference)) { - if (entryHasDeobfuscatedName(reference.getNameableEntry())) { - deobfuscatedTokens.add(token); - } else { - obfuscatedTokens.add(token); - } + // set the highlighted tokens + List obfuscatedTokens = Lists.newArrayList(); + List deobfuscatedTokens = Lists.newArrayList(); + List otherTokens = Lists.newArrayList(); + for (Token token : index.referenceTokens()) { + EntryReference reference = index.getDeobfReference(token); + if (referenceIsRenameable(reference)) { + if (entryHasDeobfuscatedName(reference.getNameableEntry())) { + deobfuscatedTokens.add(token); } else { - otherTokens.add(token); + obfuscatedTokens.add(token); } + } else { + otherTokens.add(token); } - gui.setHighlightedTokens(obfuscatedTokens, deobfuscatedTokens, otherTokens); } - }.start(); + gui.setHighlightedTokens(obfuscatedTokens, deobfuscatedTokens, otherTokens); + }).start(); } public Deobfuscator getDeobfuscator() @@ -349,7 +347,7 @@ public class GuiController { { if (event.getStateChange() == ItemEvent.SELECTED) { - deobfuscator.changeModifier(gui.m_reference.entry, (Mappings.EntryModifier) event.getItem()); + deobfuscator.changeModifier(gui.reference.entry, (Mappings.EntryModifier) event.getItem()); this.isDirty = true; refreshCurrentClass(); } diff --git a/src/main/java/cuchaz/enigma/gui/MemberMatchingGui.java b/src/main/java/cuchaz/enigma/gui/MemberMatchingGui.java index ecc280d..671f85f 100644 --- a/src/main/java/cuchaz/enigma/gui/MemberMatchingGui.java +++ b/src/main/java/cuchaz/enigma/gui/MemberMatchingGui.java @@ -17,7 +17,6 @@ import java.awt.BorderLayout; import java.awt.Container; import java.awt.Dimension; import java.awt.FlowLayout; -import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt.event.KeyAdapter; import java.awt.event.KeyEvent; @@ -30,7 +29,6 @@ import javax.swing.text.Highlighter.HighlightPainter; import cuchaz.enigma.Constants; import cuchaz.enigma.Deobfuscator; -import cuchaz.enigma.analysis.EntryReference; import cuchaz.enigma.analysis.SourceIndex; import cuchaz.enigma.analysis.Token; import cuchaz.enigma.convert.ClassMatches; @@ -78,39 +76,38 @@ public class MemberMatchingGui { } // controls - private JFrame m_frame; - private Map m_sourceTypeButtons; - private ClassSelector m_sourceClasses; - private CodeReader m_sourceReader; - private CodeReader m_destReader; - private JButton m_matchButton; - private JButton m_unmatchableButton; - private JLabel m_sourceLabel; - private JLabel m_destLabel; - private HighlightPainter m_unmatchedHighlightPainter; - private HighlightPainter m_matchedHighlightPainter; - - private ClassMatches m_classMatches; - private MemberMatches m_memberMatches; - private Deobfuscator m_sourceDeobfuscator; - private Deobfuscator m_destDeobfuscator; - private SaveListener m_saveListener; - private SourceType m_sourceType; - private ClassEntry m_obfSourceClass; - private ClassEntry m_obfDestClass; - private T m_obfSourceEntry; - private T m_obfDestEntry; + private JFrame frame; + private Map sourceTypeButtons; + private ClassSelector sourceClasses; + private CodeReader sourceReader; + private CodeReader destReader; + private JButton matchButton; + private JButton unmatchableButton; + private JLabel sourceLabel; + private JLabel destLabel; + private HighlightPainter unmatchedHighlightPainter; + private HighlightPainter matchedHighlightPainter; + private ClassMatches classMatches; + private MemberMatches memberMatches; + private Deobfuscator sourceDeobfuscator; + private Deobfuscator destDeobfuscator; + private SaveListener saveListener; + private SourceType sourceType; + private ClassEntry obfSourceClass; + private ClassEntry obfDestClass; + private T obfSourceEntry; + private T obfDestEntry; public MemberMatchingGui(ClassMatches classMatches, MemberMatches fieldMatches, Deobfuscator sourceDeobfuscator, Deobfuscator destDeobfuscator) { - m_classMatches = classMatches; - m_memberMatches = fieldMatches; - m_sourceDeobfuscator = sourceDeobfuscator; - m_destDeobfuscator = destDeobfuscator; + this.classMatches = classMatches; + memberMatches = fieldMatches; + this.sourceDeobfuscator = sourceDeobfuscator; + this.destDeobfuscator = destDeobfuscator; // init frame - m_frame = new JFrame(Constants.NAME + " - Member Matcher"); - final Container pane = m_frame.getContentPane(); + frame = new JFrame(Constants.NAME + " - Member Matcher"); + final Container pane = frame.getContentPane(); pane.setLayout(new BorderLayout()); // init classes side @@ -124,47 +121,38 @@ public class MemberMatchingGui { JPanel sourceTypePanel = new JPanel(); classesPanel.add(sourceTypePanel); sourceTypePanel.setLayout(new BoxLayout(sourceTypePanel, BoxLayout.PAGE_AXIS)); - ActionListener sourceTypeListener = new ActionListener() { - @Override - public void actionPerformed(ActionEvent event) { - setSourceType(SourceType.valueOf(event.getActionCommand())); - } - }; + ActionListener sourceTypeListener = event -> setSourceType(SourceType.valueOf(event.getActionCommand())); ButtonGroup sourceTypeButtons = new ButtonGroup(); - m_sourceTypeButtons = Maps.newHashMap(); + this.sourceTypeButtons = Maps.newHashMap(); for (SourceType sourceType : SourceType.values()) { JRadioButton button = sourceType.newRadio(sourceTypeListener, sourceTypeButtons); - m_sourceTypeButtons.put(sourceType, button); + this.sourceTypeButtons.put(sourceType, button); sourceTypePanel.add(button); } - m_sourceClasses = new ClassSelector(null, ClassSelector.DEOBF_CLASS_COMPARATOR, false); - m_sourceClasses.setSelectionListener(this::setSourceClass); - JScrollPane sourceScroller = new JScrollPane(m_sourceClasses); + sourceClasses = new ClassSelector(null, ClassSelector.DEOBF_CLASS_COMPARATOR, false); + sourceClasses.setSelectionListener(this::setSourceClass); + JScrollPane sourceScroller = new JScrollPane(sourceClasses); classesPanel.add(sourceScroller); // init readers DefaultSyntaxKit.initKit(); - m_sourceReader = new CodeReader(); - m_sourceReader.setSelectionListener(new CodeReader.SelectionListener() { - @Override - public void onSelect(EntryReference reference) { - if (reference != null) { - onSelectSource(reference.entry); - } else { - onSelectSource(null); - } + sourceReader = new CodeReader(); + sourceReader.setSelectionListener(reference -> + { + if (reference != null) { + onSelectSource(reference.entry); + } else { + onSelectSource(null); } }); - m_destReader = new CodeReader(); - m_destReader.setSelectionListener(new CodeReader.SelectionListener() { - @Override - public void onSelect(EntryReference reference) { - if (reference != null) { - onSelectDest(reference.entry); - } else { - onSelectDest(null); - } + destReader = new CodeReader(); + destReader.setSelectionListener(reference -> + { + if (reference != null) { + onSelectDest(reference.entry); + } else { + onSelectDest(null); } }); @@ -173,14 +161,15 @@ public class MemberMatchingGui { @Override public void keyPressed(KeyEvent event) { if (event.getKeyCode() == KeyEvent.VK_M) - m_matchButton.doClick(); + matchButton.doClick(); } }; - m_sourceReader.addKeyListener(keyListener); - m_destReader.addKeyListener(keyListener); + sourceReader.addKeyListener(keyListener); + destReader.addKeyListener(keyListener); // init all the splits - JSplitPane splitRight = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, true, new JScrollPane(m_sourceReader), new JScrollPane(m_destReader)); + JSplitPane splitRight = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, true, new JScrollPane(sourceReader), new JScrollPane( + destReader)); splitRight.setResizeWeight(0.5); // resize 50:50 JSplitPane splitLeft = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, true, classesPanel, splitRight); splitLeft.setResizeWeight(0); // let the right side take all the slack @@ -192,102 +181,92 @@ public class MemberMatchingGui { bottomPanel.setLayout(new FlowLayout()); pane.add(bottomPanel, BorderLayout.SOUTH); - m_matchButton = new JButton(); - m_unmatchableButton = new JButton(); + matchButton = new JButton(); + unmatchableButton = new JButton(); - m_sourceLabel = new JLabel(); - bottomPanel.add(m_sourceLabel); - bottomPanel.add(m_matchButton); - bottomPanel.add(m_unmatchableButton); - m_destLabel = new JLabel(); - bottomPanel.add(m_destLabel); + sourceLabel = new JLabel(); + bottomPanel.add(sourceLabel); + bottomPanel.add(matchButton); + bottomPanel.add(unmatchableButton); + destLabel = new JLabel(); + bottomPanel.add(destLabel); // show the frame pane.doLayout(); - m_frame.setSize(1024, 576); - m_frame.setMinimumSize(new Dimension(640, 480)); - m_frame.setVisible(true); - m_frame.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE); + frame.setSize(1024, 576); + frame.setMinimumSize(new Dimension(640, 480)); + frame.setVisible(true); + frame.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE); - m_unmatchedHighlightPainter = new ObfuscatedHighlightPainter(); - m_matchedHighlightPainter = new DeobfuscatedHighlightPainter(); + unmatchedHighlightPainter = new ObfuscatedHighlightPainter(); + matchedHighlightPainter = new DeobfuscatedHighlightPainter(); // init state - m_saveListener = null; - m_obfSourceClass = null; - m_obfDestClass = null; - m_obfSourceEntry = null; - m_obfDestEntry = null; + saveListener = null; + obfSourceClass = null; + obfDestClass = null; + obfSourceEntry = null; + obfDestEntry = null; setSourceType(SourceType.getDefault()); updateButtons(); } protected void setSourceType(SourceType val) { - m_sourceType = val; + sourceType = val; updateSourceClasses(); } public void setSaveListener(SaveListener val) { - m_saveListener = val; + saveListener = val; } private void updateSourceClasses() { - String selectedPackage = m_sourceClasses.getSelectedPackage(); + String selectedPackage = sourceClasses.getSelectedPackage(); List deobfClassEntries = Lists.newArrayList(); - for (ClassEntry entry : m_sourceType.getObfSourceClasses(m_memberMatches)) { - deobfClassEntries.add(m_sourceDeobfuscator.deobfuscateEntry(entry)); + for (ClassEntry entry : sourceType.getObfSourceClasses(memberMatches)) { + deobfClassEntries.add(sourceDeobfuscator.deobfuscateEntry(entry)); } - m_sourceClasses.setClasses(deobfClassEntries); + sourceClasses.setClasses(deobfClassEntries); if (selectedPackage != null) { - m_sourceClasses.expandPackage(selectedPackage); + sourceClasses.expandPackage(selectedPackage); } for (SourceType sourceType : SourceType.values()) { - m_sourceTypeButtons.get(sourceType).setText(String.format("%s (%d)", - sourceType.name(), sourceType.getObfSourceClasses(m_memberMatches).size() + sourceTypeButtons.get(sourceType).setText(String.format("%s (%d)", + sourceType.name(), sourceType.getObfSourceClasses(memberMatches).size() )); } } protected void setSourceClass(ClassEntry sourceClass) { - m_obfSourceClass = m_sourceDeobfuscator.obfuscateEntry(sourceClass); - m_obfDestClass = m_classMatches.getUniqueMatches().get(m_obfSourceClass); - if (m_obfDestClass == null) { - throw new Error("No matching dest class for source class: " + m_obfSourceClass); + obfSourceClass = sourceDeobfuscator.obfuscateEntry(sourceClass); + obfDestClass = classMatches.getUniqueMatches().get(obfSourceClass); + if (obfDestClass == null) { + throw new Error("No matching dest class for source class: " + obfSourceClass); } - m_sourceReader.decompileClass(m_obfSourceClass, m_sourceDeobfuscator, false, new Runnable() { - @Override - public void run() { - updateSourceHighlights(); - } - }); - m_destReader.decompileClass(m_obfDestClass, m_destDeobfuscator, false, new Runnable() { - @Override - public void run() { - updateDestHighlights(); - } - }); + sourceReader.decompileClass(obfSourceClass, sourceDeobfuscator, false, this::updateSourceHighlights); + destReader.decompileClass(obfDestClass, destDeobfuscator, false, this::updateDestHighlights); } protected void updateSourceHighlights() { - highlightEntries(m_sourceReader, m_sourceDeobfuscator, m_memberMatches.matches().keySet(), m_memberMatches.getUnmatchedSourceEntries()); + highlightEntries(sourceReader, sourceDeobfuscator, memberMatches.matches().keySet(), memberMatches.getUnmatchedSourceEntries()); } protected void updateDestHighlights() { - highlightEntries(m_destReader, m_destDeobfuscator, m_memberMatches.matches().values(), m_memberMatches.getUnmatchedDestEntries()); + highlightEntries(destReader, destDeobfuscator, memberMatches.matches().values(), memberMatches.getUnmatchedDestEntries()); } private void highlightEntries(CodeReader reader, Deobfuscator deobfuscator, Collection obfMatchedEntries, Collection obfUnmatchedEntries) { reader.clearHighlights(); // matched fields - updateHighlighted(obfMatchedEntries, deobfuscator, reader, m_matchedHighlightPainter); + updateHighlighted(obfMatchedEntries, deobfuscator, reader, matchedHighlightPainter); // unmatched fields - updateHighlighted(obfUnmatchedEntries, deobfuscator, reader, m_unmatchedHighlightPainter); + updateHighlighted(obfUnmatchedEntries, deobfuscator, reader, unmatchedHighlightPainter); } private void updateHighlighted(Collection entries, Deobfuscator deobfuscator, CodeReader reader, HighlightPainter painter) @@ -303,8 +282,8 @@ public class MemberMatchingGui { } private boolean isSelectionMatched() { - return m_obfSourceEntry != null && m_obfDestEntry != null - && m_memberMatches.isMatched(m_obfSourceEntry, m_obfDestEntry); + return obfSourceEntry != null && obfDestEntry != null + && memberMatches.isMatched(obfSourceEntry, obfDestEntry); } protected void onSelectSource(Entry source) { @@ -324,12 +303,12 @@ public class MemberMatchingGui { @SuppressWarnings("unchecked") T sourceEntry = (T) source; - T obfSourceEntry = m_sourceDeobfuscator.obfuscateEntry(sourceEntry); - if (m_memberMatches.hasSource(obfSourceEntry)) { + T obfSourceEntry = sourceDeobfuscator.obfuscateEntry(sourceEntry); + if (memberMatches.hasSource(obfSourceEntry)) { setSource(obfSourceEntry); // look for a matched dest too - T obfDestEntry = m_memberMatches.matches().get(obfSourceEntry); + T obfDestEntry = memberMatches.matches().get(obfSourceEntry); if (obfDestEntry != null) { setDest(obfDestEntry); } @@ -356,12 +335,12 @@ public class MemberMatchingGui { @SuppressWarnings("unchecked") T destEntry = (T) dest; - T obfDestEntry = m_destDeobfuscator.obfuscateEntry(destEntry); - if (m_memberMatches.hasDest(obfDestEntry)) { + T obfDestEntry = destDeobfuscator.obfuscateEntry(destEntry); + if (memberMatches.hasDest(obfDestEntry)) { setDest(obfDestEntry); // look for a matched source too - T obfSourceEntry = m_memberMatches.matches().inverse().get(obfDestEntry); + T obfSourceEntry = memberMatches.matches().inverse().get(obfDestEntry); if (obfSourceEntry != null) { setSource(obfSourceEntry); } @@ -373,21 +352,21 @@ public class MemberMatchingGui { private void setSource(T obfEntry) { if (obfEntry == null) { - m_obfSourceEntry = null; - m_sourceLabel.setText(""); + obfSourceEntry = null; + sourceLabel.setText(""); } else { - m_obfSourceEntry = obfEntry; - m_sourceLabel.setText(getEntryLabel(obfEntry, m_sourceDeobfuscator)); + obfSourceEntry = obfEntry; + sourceLabel.setText(getEntryLabel(obfEntry, sourceDeobfuscator)); } } private void setDest(T obfEntry) { if (obfEntry == null) { - m_obfDestEntry = null; - m_destLabel.setText(""); + obfDestEntry = null; + destLabel.setText(""); } else { - m_obfDestEntry = obfEntry; - m_destLabel.setText(getEntryLabel(obfEntry, m_destDeobfuscator)); + obfDestEntry = obfEntry; + destLabel.setText(getEntryLabel(obfEntry, destDeobfuscator)); } } @@ -399,39 +378,23 @@ public class MemberMatchingGui { private void updateButtons() { - GuiTricks.deactivateButton(m_matchButton); - GuiTricks.deactivateButton(m_unmatchableButton); - - if (m_obfSourceEntry != null && m_obfDestEntry != null) { - if (m_memberMatches.isMatched(m_obfSourceEntry, m_obfDestEntry)) { - GuiTricks.activateButton(m_matchButton, "Unmatch", new ActionListener() { - @Override - public void actionPerformed(ActionEvent event) { - unmatch(); - } - }); - } else if (!m_memberMatches.isMatchedSourceEntry(m_obfSourceEntry) && !m_memberMatches.isMatchedDestEntry(m_obfDestEntry)) { - GuiTricks.activateButton(m_matchButton, "Match", new ActionListener() { - @Override - public void actionPerformed(ActionEvent event) { - match(); - } - }); - } - } else if (m_obfSourceEntry != null) { - GuiTricks.activateButton(m_unmatchableButton, "Set Unmatchable", new ActionListener() { - @Override - public void actionPerformed(ActionEvent event) { - unmatchable(); - } - }); - } + GuiTricks.deactivateButton(matchButton); + GuiTricks.deactivateButton(unmatchableButton); + + if (obfSourceEntry != null && obfDestEntry != null) { + if (memberMatches.isMatched(obfSourceEntry, obfDestEntry)) + GuiTricks.activateButton(matchButton, "Unmatch", event -> unmatch()); + else if (!memberMatches.isMatchedSourceEntry(obfSourceEntry) && !memberMatches.isMatchedDestEntry( + obfDestEntry)) + GuiTricks.activateButton(matchButton, "Match", event -> match()); + } else if (obfSourceEntry != null) + GuiTricks.activateButton(unmatchableButton, "Set Unmatchable", event -> unmatchable()); } protected void match() { // update the field matches - m_memberMatches.makeMatch(m_obfSourceEntry, m_obfDestEntry, m_sourceDeobfuscator, m_destDeobfuscator); + memberMatches.makeMatch(obfSourceEntry, obfDestEntry, sourceDeobfuscator, destDeobfuscator); save(); // update the ui @@ -445,7 +408,7 @@ public class MemberMatchingGui { protected void unmatch() { // update the field matches - m_memberMatches.unmakeMatch(m_obfSourceEntry, m_obfDestEntry, m_sourceDeobfuscator, m_destDeobfuscator); + memberMatches.unmakeMatch(obfSourceEntry, obfDestEntry, sourceDeobfuscator, destDeobfuscator); save(); // update the ui @@ -459,7 +422,7 @@ public class MemberMatchingGui { protected void unmatchable() { // update the field matches - m_memberMatches.makeSourceUnmatchable(m_obfSourceEntry, m_sourceDeobfuscator); + memberMatches.makeSourceUnmatchable(obfSourceEntry, sourceDeobfuscator); save(); // update the ui @@ -471,8 +434,8 @@ public class MemberMatchingGui { } private void save() { - if (m_saveListener != null) { - m_saveListener.save(m_memberMatches); + if (saveListener != null) { + saveListener.save(memberMatches); } } } diff --git a/src/main/java/cuchaz/enigma/gui/ScoredClassEntry.java b/src/main/java/cuchaz/enigma/gui/ScoredClassEntry.java index d1e2de0..bd9fe3d 100644 --- a/src/main/java/cuchaz/enigma/gui/ScoredClassEntry.java +++ b/src/main/java/cuchaz/enigma/gui/ScoredClassEntry.java @@ -17,14 +17,28 @@ public class ScoredClassEntry extends ClassEntry { private static final long serialVersionUID = -8798725308554217105L; - private float m_score; + private float score; public ScoredClassEntry(ClassEntry other, float score) { super(other); - m_score = score; + this.score = score; } public float getScore() { - return m_score; + return score; + } + + @Override + public int hashCode() { + return Float.hashCode(score) + super.hashCode(); + } + + @Override + public boolean equals(Object other) { + return super.equals(other) && other instanceof ScoredClassEntry && equals((ScoredClassEntry) other); + } + + public boolean equals(ScoredClassEntry other) { + return other != null && score == other.score; } } diff --git a/src/main/java/cuchaz/enigma/gui/dialog/CrashDialog.java b/src/main/java/cuchaz/enigma/gui/dialog/CrashDialog.java index 8d3df47..5c1d9ff 100644 --- a/src/main/java/cuchaz/enigma/gui/dialog/CrashDialog.java +++ b/src/main/java/cuchaz/enigma/gui/dialog/CrashDialog.java @@ -23,15 +23,15 @@ import cuchaz.enigma.utils.Utils; public class CrashDialog { - private static CrashDialog m_instance = null; + private static CrashDialog instance = null; - private JFrame m_frame; - private JTextArea m_text; + private JFrame frame; + private JTextArea text; private CrashDialog(JFrame parent) { // init frame - m_frame = new JFrame(Constants.NAME + " - Crash Report"); - final Container pane = m_frame.getContentPane(); + frame = new JFrame(Constants.NAME + " - Crash Report"); + final Container pane = frame.getContentPane(); pane.setLayout(new BorderLayout()); JLabel label = new JLabel(Constants.NAME + " has crashed! =("); @@ -39,9 +39,9 @@ public class CrashDialog { pane.add(label, BorderLayout.NORTH); // report panel - m_text = new JTextArea(); - m_text.setTabSize(2); - pane.add(new JScrollPane(m_text), BorderLayout.CENTER); + text = new JTextArea(); + text.setTabSize(2); + pane.add(new JScrollPane(text), BorderLayout.CENTER); // buttons panel JPanel buttonsPanel = new JPanel(); @@ -52,7 +52,7 @@ public class CrashDialog { JButton ignoreButton = new JButton("Ignore"); ignoreButton.addActionListener(event -> { // close (hide) the dialog - m_frame.setVisible(false); + frame.setVisible(false); }); buttonsPanel.add(ignoreButton); JButton exitButton = new JButton("Exit"); @@ -64,13 +64,13 @@ public class CrashDialog { pane.add(buttonsPanel, BorderLayout.SOUTH); // show the frame - m_frame.setSize(600, 400); - m_frame.setLocationRelativeTo(parent); - m_frame.setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE); + frame.setSize(600, 400); + frame.setLocationRelativeTo(parent); + frame.setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE); } public static void init(JFrame parent) { - m_instance = new CrashDialog(parent); + instance = new CrashDialog(parent); } public static void show(Throwable ex) { @@ -80,8 +80,8 @@ public class CrashDialog { String report = buf.toString(); // show it! - m_instance.m_text.setText(report); - m_instance.m_frame.doLayout(); - m_instance.m_frame.setVisible(true); + instance.text.setText(report); + instance.frame.doLayout(); + instance.frame.setVisible(true); } } diff --git a/src/main/java/cuchaz/enigma/gui/dialog/ProgressDialog.java b/src/main/java/cuchaz/enigma/gui/dialog/ProgressDialog.java index c752c86..8df22a7 100644 --- a/src/main/java/cuchaz/enigma/gui/dialog/ProgressDialog.java +++ b/src/main/java/cuchaz/enigma/gui/dialog/ProgressDialog.java @@ -87,15 +87,13 @@ public class ProgressDialog implements ProgressListener, AutoCloseable { } public static void runInThread(final JFrame parent, final ProgressRunnable runnable) { - new Thread() { - @Override - public void run() { - try (ProgressDialog progress = new ProgressDialog(parent)) { - runnable.run(progress); - } catch (Exception ex) { - throw new Error(ex); - } + new Thread(() -> + { + try (ProgressDialog progress = new ProgressDialog(parent)) { + runnable.run(progress); + } catch (Exception ex) { + throw new Error(ex); } - }.start(); + }).start(); } } diff --git a/src/main/java/cuchaz/enigma/gui/elements/MenuBar.java b/src/main/java/cuchaz/enigma/gui/elements/MenuBar.java index dcd7c93..0ccd537 100644 --- a/src/main/java/cuchaz/enigma/gui/elements/MenuBar.java +++ b/src/main/java/cuchaz/enigma/gui/elements/MenuBar.java @@ -42,16 +42,14 @@ public class MenuBar extends JMenuBar { item.addActionListener(event -> { if (this.gui.jarFileChooser.showOpenDialog(this.gui.getFrame()) == JFileChooser.APPROVE_OPTION) { // load the jar in a separate thread - new Thread() { - @Override - public void run() { - try { - gui.getController().openJar(new JarFile(gui.jarFileChooser.getSelectedFile())); - } catch (IOException ex) { - throw new Error(ex); - } + new Thread(() -> + { + try { + gui.getController().openJar(new JarFile(gui.jarFileChooser.getSelectedFile())); + } catch (IOException ex) { + throw new Error(ex); } - }.start(); + }).start(); } }); } @@ -177,9 +175,7 @@ public class MenuBar extends JMenuBar { { JMenuItem item = new JMenuItem("Rebuild Method Names"); menu.add(item); - item.addActionListener(event -> { - this.gui.getController().rebuildMethodNames(); - }); + item.addActionListener(event -> this.gui.getController().rebuildMethodNames()); this.rebuildMethodNamesMenu = item; } menu.addSeparator(); diff --git a/src/main/java/cuchaz/enigma/gui/elements/PopupMenuBar.java b/src/main/java/cuchaz/enigma/gui/elements/PopupMenuBar.java index 2b06342..e387ed3 100644 --- a/src/main/java/cuchaz/enigma/gui/elements/PopupMenuBar.java +++ b/src/main/java/cuchaz/enigma/gui/elements/PopupMenuBar.java @@ -53,7 +53,7 @@ public class PopupMenuBar extends JPopupMenu { } { JMenuItem menu = new JMenuItem("Go to Declaration"); - menu.addActionListener(event -> gui.navigateTo(gui.m_reference.entry)); + menu.addActionListener(event -> gui.navigateTo(gui.reference.entry)); menu.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_N, 0)); menu.setEnabled(false); this.add(menu); diff --git a/src/main/java/cuchaz/enigma/gui/node/ClassSelectorClassNode.java b/src/main/java/cuchaz/enigma/gui/node/ClassSelectorClassNode.java index 8341826..9f391f2 100644 --- a/src/main/java/cuchaz/enigma/gui/node/ClassSelectorClassNode.java +++ b/src/main/java/cuchaz/enigma/gui/node/ClassSelectorClassNode.java @@ -37,6 +37,11 @@ public class ClassSelectorClassNode extends DefaultMutableTreeNode { return other instanceof ClassSelectorClassNode && equals((ClassSelectorClassNode) other); } + @Override public int hashCode() + { + return 17 + (classEntry != null ? classEntry.hashCode() : 0); + } + @Override public void setUserObject(Object userObject) { String packageName = ""; diff --git a/src/main/java/cuchaz/enigma/gui/node/ClassSelectorPackageNode.java b/src/main/java/cuchaz/enigma/gui/node/ClassSelectorPackageNode.java index 31b4ebf..b3eb90e 100644 --- a/src/main/java/cuchaz/enigma/gui/node/ClassSelectorPackageNode.java +++ b/src/main/java/cuchaz/enigma/gui/node/ClassSelectorPackageNode.java @@ -48,6 +48,11 @@ public class ClassSelectorPackageNode extends DefaultMutableTreeNode { return other instanceof ClassSelectorPackageNode && equals((ClassSelectorPackageNode) other); } + @Override public int hashCode() + { + return packageName.hashCode(); + } + public boolean equals(ClassSelectorPackageNode other) { return other != null && this.packageName.equals(other.packageName); } diff --git a/src/main/java/cuchaz/enigma/mapping/ClassMapping.java b/src/main/java/cuchaz/enigma/mapping/ClassMapping.java index 8f89388..a261c91 100644 --- a/src/main/java/cuchaz/enigma/mapping/ClassMapping.java +++ b/src/main/java/cuchaz/enigma/mapping/ClassMapping.java @@ -20,19 +20,19 @@ import cuchaz.enigma.throwables.MappingConflict; // FIXME: Enigma doesn't support inner classes of inner class????! public class ClassMapping implements Comparable { - private String m_obfFullName; - private String m_obfSimpleName; - private String m_deobfName; - private String m_previousDeobfName; - private Map m_innerClassesByObfSimple; - private Map m_innerClassesByObfFull; - private Map m_innerClassesByDeobf; - private Map m_fieldsByObf; - private Map m_fieldsByDeobf; - private Map m_methodsByObf; - private Map m_methodsByDeobf; - private boolean isDirty; - private Mappings.EntryModifier modifier; + private String obfFullName; + private String obfSimpleName; + private String deobfName; + private String previousDeobfName; + private Map innerClassesByObfSimple; + private Map innerClassesByObfFull; + private Map innerClassesByDeobf; + private Map fieldsByObf; + private Map fieldsByDeobf; + private Map methodsByObf; + private Map methodsByDeobf; + private boolean isDirty; + private Mappings.EntryModifier modifier; public ClassMapping(String obfFullName) { @@ -46,85 +46,85 @@ public class ClassMapping implements Comparable { public ClassMapping(String obfFullName, String deobfName, Mappings.EntryModifier modifier) { - m_obfFullName = obfFullName; + this.obfFullName = obfFullName; ClassEntry classEntry = new ClassEntry(obfFullName); - m_obfSimpleName = classEntry.isInnerClass() ? classEntry.getInnermostClassName() : classEntry.getSimpleName(); - m_previousDeobfName = null; - m_deobfName = NameValidator.validateClassName(deobfName, false); - m_innerClassesByObfSimple = Maps.newHashMap(); - m_innerClassesByObfFull = Maps.newHashMap(); - m_innerClassesByDeobf = Maps.newHashMap(); - m_fieldsByObf = Maps.newHashMap(); - m_fieldsByDeobf = Maps.newHashMap(); - m_methodsByObf = Maps.newHashMap(); - m_methodsByDeobf = Maps.newHashMap(); + obfSimpleName = classEntry.isInnerClass() ? classEntry.getInnermostClassName() : classEntry.getSimpleName(); + previousDeobfName = null; + this.deobfName = NameValidator.validateClassName(deobfName, false); + innerClassesByObfSimple = Maps.newHashMap(); + innerClassesByObfFull = Maps.newHashMap(); + innerClassesByDeobf = Maps.newHashMap(); + fieldsByObf = Maps.newHashMap(); + fieldsByDeobf = Maps.newHashMap(); + methodsByObf = Maps.newHashMap(); + methodsByDeobf = Maps.newHashMap(); isDirty = true; this.modifier = modifier; } public String getObfFullName() { - return m_obfFullName; + return obfFullName; } public String getObfSimpleName() { - return m_obfSimpleName; + return obfSimpleName; } public String getPreviousDeobfName() { - return m_previousDeobfName; + return previousDeobfName; } public String getDeobfName() { - return m_deobfName; + return deobfName; } public void setDeobfName(String val) { - m_previousDeobfName = m_deobfName; - m_deobfName = NameValidator.validateClassName(val, false); + previousDeobfName = deobfName; + deobfName = NameValidator.validateClassName(val, false); this.isDirty = true; } //// INNER CLASSES //////// public Iterable innerClasses() { - assert (m_innerClassesByObfSimple.size() >= m_innerClassesByDeobf.size()); - return m_innerClassesByObfSimple.values(); + assert (innerClassesByObfSimple.size() >= innerClassesByDeobf.size()); + return innerClassesByObfSimple.values(); } public void addInnerClassMapping(ClassMapping classMapping) throws MappingConflict { // FIXME: dirty hack, that can get into issues, but it's a temp fix! - if (this.m_innerClassesByObfFull.containsKey(classMapping.getObfSimpleName())) { - throw new MappingConflict("classes", classMapping.getObfSimpleName(), this.m_innerClassesByObfSimple.get(classMapping.getObfSimpleName()).getObfSimpleName()); + if (this.innerClassesByObfFull.containsKey(classMapping.getObfSimpleName())) { + throw new MappingConflict("classes", classMapping.getObfSimpleName(), this.innerClassesByObfSimple.get(classMapping.getObfSimpleName()).getObfSimpleName()); } - m_innerClassesByObfFull.put(classMapping.getObfFullName(), classMapping); - m_innerClassesByObfSimple.put(classMapping.getObfSimpleName(), classMapping); + innerClassesByObfFull.put(classMapping.getObfFullName(), classMapping); + innerClassesByObfSimple.put(classMapping.getObfSimpleName(), classMapping); if (classMapping.getDeobfName() != null) { - if (this.m_innerClassesByDeobf.containsKey(classMapping.getDeobfName())) { - throw new MappingConflict("classes", classMapping.getDeobfName(), this.m_innerClassesByDeobf.get(classMapping.getDeobfName()).getDeobfName()); + if (this.innerClassesByDeobf.containsKey(classMapping.getDeobfName())) { + throw new MappingConflict("classes", classMapping.getDeobfName(), this.innerClassesByDeobf.get(classMapping.getDeobfName()).getDeobfName()); } - m_innerClassesByDeobf.put(classMapping.getDeobfName(), classMapping); + innerClassesByDeobf.put(classMapping.getDeobfName(), classMapping); } this.isDirty = true; } public void removeInnerClassMapping(ClassMapping classMapping) { - m_innerClassesByObfFull.remove(classMapping.getObfFullName()); - boolean obfWasRemoved = m_innerClassesByObfSimple.remove(classMapping.getObfSimpleName()) != null; + innerClassesByObfFull.remove(classMapping.getObfFullName()); + boolean obfWasRemoved = innerClassesByObfSimple.remove(classMapping.getObfSimpleName()) != null; assert (obfWasRemoved); if (classMapping.getDeobfName() != null) { - boolean deobfWasRemoved = m_innerClassesByDeobf.remove(classMapping.getDeobfName()) != null; + boolean deobfWasRemoved = innerClassesByDeobf.remove(classMapping.getDeobfName()) != null; assert (deobfWasRemoved); } this.isDirty = true; } public ClassMapping getOrCreateInnerClass(ClassEntry obfInnerClass) { - ClassMapping classMapping = m_innerClassesByObfSimple.get(obfInnerClass.getInnermostClassName()); + ClassMapping classMapping = innerClassesByObfSimple.get(obfInnerClass.getInnermostClassName()); if (classMapping == null) { classMapping = new ClassMapping(obfInnerClass.getName()); - m_innerClassesByObfFull.put(classMapping.getObfFullName(), classMapping); - boolean wasAdded = m_innerClassesByObfSimple.put(classMapping.getObfSimpleName(), classMapping) == null; + innerClassesByObfFull.put(classMapping.getObfFullName(), classMapping); + boolean wasAdded = innerClassesByObfSimple.put(classMapping.getObfSimpleName(), classMapping) == null; assert (wasAdded); this.isDirty = true; } @@ -133,12 +133,12 @@ public class ClassMapping implements Comparable { public ClassMapping getInnerClassByObfSimple(String obfSimpleName) { assert (isSimpleClassName(obfSimpleName)); - return m_innerClassesByObfSimple.get(obfSimpleName); + return innerClassesByObfSimple.get(obfSimpleName); } public ClassMapping getInnerClassByDeobf(String deobfName) { assert (isSimpleClassName(deobfName)); - return m_innerClassesByDeobf.get(deobfName); + return innerClassesByDeobf.get(deobfName); } public ClassMapping getInnerClassByDeobfThenObfSimple(String name) { @@ -151,7 +151,7 @@ public class ClassMapping implements Comparable { public String getDeobfInnerClassName(String obfSimpleName) { assert (isSimpleClassName(obfSimpleName)); - ClassMapping classMapping = m_innerClassesByObfSimple.get(obfSimpleName); + ClassMapping classMapping = innerClassesByObfSimple.get(obfSimpleName); if (classMapping != null) { return classMapping.getDeobfName(); } @@ -161,80 +161,80 @@ public class ClassMapping implements Comparable { public void setInnerClassName(ClassEntry obfInnerClass, String deobfName) { ClassMapping classMapping = getOrCreateInnerClass(obfInnerClass); if (classMapping.getDeobfName() != null) { - boolean wasRemoved = m_innerClassesByDeobf.remove(classMapping.getDeobfName()) != null; + boolean wasRemoved = innerClassesByDeobf.remove(classMapping.getDeobfName()) != null; assert (wasRemoved); } classMapping.setDeobfName(deobfName); if (deobfName != null) { assert (isSimpleClassName(deobfName)); - boolean wasAdded = m_innerClassesByDeobf.put(deobfName, classMapping) == null; + boolean wasAdded = innerClassesByDeobf.put(deobfName, classMapping) == null; assert (wasAdded); } this.isDirty = true; } public boolean hasInnerClassByObfSimple(String obfSimpleName) { - return m_innerClassesByObfSimple.containsKey(obfSimpleName); + return innerClassesByObfSimple.containsKey(obfSimpleName); } public boolean hasInnerClassByDeobf(String deobfName) { - return m_innerClassesByDeobf.containsKey(deobfName); + return innerClassesByDeobf.containsKey(deobfName); } //// FIELDS //////// public Iterable fields() { - assert (m_fieldsByObf.size() == m_fieldsByDeobf.size()); - return m_fieldsByObf.values(); + assert (fieldsByObf.size() == fieldsByDeobf.size()); + return fieldsByObf.values(); } public boolean containsObfField(String obfName, Type obfType) { - return m_fieldsByObf.containsKey(getFieldKey(obfName, obfType)); + return fieldsByObf.containsKey(getFieldKey(obfName, obfType)); } public boolean containsDeobfField(String deobfName, Type deobfType) { - return m_fieldsByDeobf.containsKey(getFieldKey(deobfName, deobfType)); + return fieldsByDeobf.containsKey(getFieldKey(deobfName, deobfType)); } public void addFieldMapping(FieldMapping fieldMapping) { String obfKey = getFieldKey(fieldMapping.getObfName(), fieldMapping.getObfType()); - if (m_fieldsByObf.containsKey(obfKey)) { - throw new Error("Already have mapping for " + m_obfFullName + "." + obfKey); + if (fieldsByObf.containsKey(obfKey)) { + throw new Error("Already have mapping for " + obfFullName + "." + obfKey); } if (fieldMapping.getDeobfName() != null) { String deobfKey = getFieldKey(fieldMapping.getDeobfName(), fieldMapping.getObfType()); - if (m_fieldsByDeobf.containsKey(deobfKey)) { - throw new Error("Already have mapping for " + m_deobfName + "." + deobfKey); + if (fieldsByDeobf.containsKey(deobfKey)) { + throw new Error("Already have mapping for " + deobfName + "." + deobfKey); } - boolean deobfWasAdded = m_fieldsByDeobf.put(deobfKey, fieldMapping) == null; + boolean deobfWasAdded = fieldsByDeobf.put(deobfKey, fieldMapping) == null; assert (deobfWasAdded); } - boolean obfWasAdded = m_fieldsByObf.put(obfKey, fieldMapping) == null; + boolean obfWasAdded = fieldsByObf.put(obfKey, fieldMapping) == null; assert (obfWasAdded); this.isDirty = true; } public void removeFieldMapping(FieldMapping fieldMapping) { - boolean obfWasRemoved = m_fieldsByObf.remove(getFieldKey(fieldMapping.getObfName(), fieldMapping.getObfType())) != null; + boolean obfWasRemoved = fieldsByObf.remove(getFieldKey(fieldMapping.getObfName(), fieldMapping.getObfType())) != null; assert (obfWasRemoved); if (fieldMapping.getDeobfName() != null) { - boolean deobfWasRemoved = m_fieldsByDeobf.remove(getFieldKey(fieldMapping.getDeobfName(), fieldMapping.getObfType())) != null; + boolean deobfWasRemoved = fieldsByDeobf.remove(getFieldKey(fieldMapping.getDeobfName(), fieldMapping.getObfType())) != null; assert (deobfWasRemoved); } this.isDirty = true; } public FieldMapping getFieldByObf(String obfName, Type obfType) { - return m_fieldsByObf.get(getFieldKey(obfName, obfType)); + return fieldsByObf.get(getFieldKey(obfName, obfType)); } public FieldMapping getFieldByDeobf(String deobfName, Type obfType) { - return m_fieldsByDeobf.get(getFieldKey(deobfName, obfType)); + return fieldsByDeobf.get(getFieldKey(deobfName, obfType)); } public String getObfFieldName(String deobfName, Type obfType) { - FieldMapping fieldMapping = m_fieldsByDeobf.get(getFieldKey(deobfName, obfType)); + FieldMapping fieldMapping = fieldsByDeobf.get(getFieldKey(deobfName, obfType)); if (fieldMapping != null) { return fieldMapping.getObfName(); } @@ -242,7 +242,7 @@ public class ClassMapping implements Comparable { } public String getDeobfFieldName(String obfName, Type obfType) { - FieldMapping fieldMapping = m_fieldsByObf.get(getFieldKey(obfName, obfType)); + FieldMapping fieldMapping = fieldsByObf.get(getFieldKey(obfName, obfType)); if (fieldMapping != null) { return fieldMapping.getDeobfName(); } @@ -261,18 +261,18 @@ public class ClassMapping implements Comparable { public void setFieldName(String obfName, Type obfType, String deobfName) { assert (deobfName != null); - FieldMapping fieldMapping = m_fieldsByObf.get(getFieldKey(obfName, obfType)); + FieldMapping fieldMapping = fieldsByObf.get(getFieldKey(obfName, obfType)); if (fieldMapping == null) { fieldMapping = new FieldMapping(obfName, obfType, deobfName, Mappings.EntryModifier.UNCHANGED); - boolean obfWasAdded = m_fieldsByObf.put(getFieldKey(obfName, obfType), fieldMapping) == null; + boolean obfWasAdded = fieldsByObf.put(getFieldKey(obfName, obfType), fieldMapping) == null; assert (obfWasAdded); } else { - boolean wasRemoved = m_fieldsByDeobf.remove(getFieldKey(fieldMapping.getDeobfName(), obfType)) != null; + boolean wasRemoved = fieldsByDeobf.remove(getFieldKey(fieldMapping.getDeobfName(), obfType)) != null; assert (wasRemoved); } fieldMapping.setDeobfName(deobfName); if (deobfName != null) { - boolean wasAdded = m_fieldsByDeobf.put(getFieldKey(deobfName, obfType), fieldMapping) == null; + boolean wasAdded = fieldsByDeobf.put(getFieldKey(deobfName, obfType), fieldMapping) == null; assert (wasAdded); } this.isDirty = true; @@ -280,11 +280,11 @@ public class ClassMapping implements Comparable { public void setFieldObfNameAndType(String oldObfName, Type obfType, String newObfName, Type newObfType) { assert(newObfName != null); - FieldMapping fieldMapping = m_fieldsByObf.remove(getFieldKey(oldObfName, obfType)); + FieldMapping fieldMapping = fieldsByObf.remove(getFieldKey(oldObfName, obfType)); assert(fieldMapping != null); fieldMapping.setObfName(newObfName); fieldMapping.setObfType(newObfType); - boolean obfWasAdded = m_fieldsByObf.put(getFieldKey(newObfName, newObfType), fieldMapping) == null; + boolean obfWasAdded = fieldsByObf.put(getFieldKey(newObfName, newObfType), fieldMapping) == null; assert(obfWasAdded); this.isDirty = true; } @@ -292,53 +292,53 @@ public class ClassMapping implements Comparable { //// METHODS //////// public Iterable methods() { - assert (m_methodsByObf.size() >= m_methodsByDeobf.size()); - return m_methodsByObf.values(); + assert (methodsByObf.size() >= methodsByDeobf.size()); + return methodsByObf.values(); } public boolean containsObfMethod(String obfName, Signature obfSignature) { - return m_methodsByObf.containsKey(getMethodKey(obfName, obfSignature)); + return methodsByObf.containsKey(getMethodKey(obfName, obfSignature)); } public boolean containsDeobfMethod(String deobfName, Signature obfSignature) { - return m_methodsByDeobf.containsKey(getMethodKey(deobfName, obfSignature)); + return methodsByDeobf.containsKey(getMethodKey(deobfName, obfSignature)); } public void addMethodMapping(MethodMapping methodMapping) { String obfKey = getMethodKey(methodMapping.getObfName(), methodMapping.getObfSignature()); - if (m_methodsByObf.containsKey(obfKey)) { - throw new Error("Already have mapping for " + m_obfFullName + "." + obfKey); + if (methodsByObf.containsKey(obfKey)) { + throw new Error("Already have mapping for " + obfFullName + "." + obfKey); } - boolean wasAdded = m_methodsByObf.put(obfKey, methodMapping) == null; + boolean wasAdded = methodsByObf.put(obfKey, methodMapping) == null; assert (wasAdded); if (methodMapping.getDeobfName() != null) { String deobfKey = getMethodKey(methodMapping.getDeobfName(), methodMapping.getObfSignature()); - if (m_methodsByDeobf.containsKey(deobfKey)) { - throw new Error("Already have mapping for " + m_deobfName + "." + deobfKey); + if (methodsByDeobf.containsKey(deobfKey)) { + throw new Error("Already have mapping for " + deobfName + "." + deobfKey); } - boolean deobfWasAdded = m_methodsByDeobf.put(deobfKey, methodMapping) == null; + boolean deobfWasAdded = methodsByDeobf.put(deobfKey, methodMapping) == null; assert (deobfWasAdded); } this.isDirty = true; - assert (m_methodsByObf.size() >= m_methodsByDeobf.size()); + assert (methodsByObf.size() >= methodsByDeobf.size()); } public void removeMethodMapping(MethodMapping methodMapping) { - boolean obfWasRemoved = m_methodsByObf.remove(getMethodKey(methodMapping.getObfName(), methodMapping.getObfSignature())) != null; + boolean obfWasRemoved = methodsByObf.remove(getMethodKey(methodMapping.getObfName(), methodMapping.getObfSignature())) != null; assert (obfWasRemoved); if (methodMapping.getDeobfName() != null) { - boolean deobfWasRemoved = m_methodsByDeobf.remove(getMethodKey(methodMapping.getDeobfName(), methodMapping.getObfSignature())) != null; + boolean deobfWasRemoved = methodsByDeobf.remove(getMethodKey(methodMapping.getDeobfName(), methodMapping.getObfSignature())) != null; assert (deobfWasRemoved); } this.isDirty = true; } public MethodMapping getMethodByObf(String obfName, Signature obfSignature) { - return m_methodsByObf.get(getMethodKey(obfName, obfSignature)); + return methodsByObf.get(getMethodKey(obfName, obfSignature)); } public MethodMapping getMethodByDeobf(String deobfName, Signature obfSignature) { - return m_methodsByDeobf.get(getMethodKey(deobfName, obfSignature)); + return methodsByDeobf.get(getMethodKey(deobfName, obfSignature)); } private String getMethodKey(String name, Signature signature) { @@ -352,16 +352,16 @@ public class ClassMapping implements Comparable { } public void setMethodName(String obfName, Signature obfSignature, String deobfName) { - MethodMapping methodMapping = m_methodsByObf.get(getMethodKey(obfName, obfSignature)); + MethodMapping methodMapping = methodsByObf.get(getMethodKey(obfName, obfSignature)); if (methodMapping == null) { methodMapping = createMethodMapping(obfName, obfSignature); } else if (methodMapping.getDeobfName() != null) { - boolean wasRemoved = m_methodsByDeobf.remove(getMethodKey(methodMapping.getDeobfName(), methodMapping.getObfSignature())) != null; + boolean wasRemoved = methodsByDeobf.remove(getMethodKey(methodMapping.getDeobfName(), methodMapping.getObfSignature())) != null; assert (wasRemoved); } methodMapping.setDeobfName(deobfName); if (deobfName != null) { - boolean wasAdded = m_methodsByDeobf.put(getMethodKey(deobfName, obfSignature), methodMapping) == null; + boolean wasAdded = methodsByDeobf.put(getMethodKey(deobfName, obfSignature), methodMapping) == null; assert (wasAdded); } this.isDirty = true; @@ -369,11 +369,11 @@ public class ClassMapping implements Comparable { public void setMethodObfNameAndSignature(String oldObfName, Signature obfSignature, String newObfName, Signature newObfSignature) { assert(newObfName != null); - MethodMapping methodMapping = m_methodsByObf.remove(getMethodKey(oldObfName, obfSignature)); + MethodMapping methodMapping = methodsByObf.remove(getMethodKey(oldObfName, obfSignature)); assert(methodMapping != null); methodMapping.setObfName(newObfName); methodMapping.setObfSignature(newObfSignature); - boolean obfWasAdded = m_methodsByObf.put(getMethodKey(newObfName, newObfSignature), methodMapping) == null; + boolean obfWasAdded = methodsByObf.put(getMethodKey(newObfName, newObfSignature), methodMapping) == null; assert(obfWasAdded); this.isDirty = true; } @@ -382,7 +382,7 @@ public class ClassMapping implements Comparable { public void setArgumentName(String obfMethodName, Signature obfMethodSignature, int argumentIndex, String argumentName) { assert (argumentName != null); - MethodMapping methodMapping = m_methodsByObf.get(getMethodKey(obfMethodName, obfMethodSignature)); + MethodMapping methodMapping = methodsByObf.get(getMethodKey(obfMethodName, obfMethodSignature)); if (methodMapping == null) { methodMapping = createMethodMapping(obfMethodName, obfMethodSignature); } @@ -391,13 +391,13 @@ public class ClassMapping implements Comparable { } public void removeArgumentName(String obfMethodName, Signature obfMethodSignature, int argumentIndex) { - m_methodsByObf.get(getMethodKey(obfMethodName, obfMethodSignature)).removeArgumentName(argumentIndex); + methodsByObf.get(getMethodKey(obfMethodName, obfMethodSignature)).removeArgumentName(argumentIndex); this.isDirty = true; } private MethodMapping createMethodMapping(String obfName, Signature obfSignature) { MethodMapping methodMapping = new MethodMapping(obfName, obfSignature); - boolean wasAdded = m_methodsByObf.put(getMethodKey(obfName, obfSignature), methodMapping) == null; + boolean wasAdded = methodsByObf.put(getMethodKey(obfName, obfSignature), methodMapping) == null; assert (wasAdded); this.isDirty = true; return methodMapping; @@ -406,9 +406,9 @@ public class ClassMapping implements Comparable { @Override public String toString() { StringBuilder buf = new StringBuilder(); - buf.append(m_obfFullName); + buf.append(obfFullName); buf.append(" <-> "); - buf.append(m_deobfName); + buf.append(deobfName); buf.append("\n"); buf.append("Fields:\n"); for (FieldMapping fieldMapping : fields()) { @@ -419,12 +419,12 @@ public class ClassMapping implements Comparable { buf.append("\n"); } buf.append("Methods:\n"); - for (MethodMapping methodMapping : m_methodsByObf.values()) { + for (MethodMapping methodMapping : methodsByObf.values()) { buf.append(methodMapping.toString()); buf.append("\n"); } buf.append("Inner Classes:\n"); - for (ClassMapping classMapping : m_innerClassesByObfSimple.values()) { + for (ClassMapping classMapping : innerClassesByObfSimple.values()) { buf.append("\t"); buf.append(classMapping.getObfSimpleName()); buf.append(" <-> "); @@ -437,49 +437,51 @@ public class ClassMapping implements Comparable { @Override public int compareTo(ClassMapping other) { // sort by a, b, c, ... aa, ab, etc - if (m_obfFullName.length() != other.m_obfFullName.length()) { - return m_obfFullName.length() - other.m_obfFullName.length(); + if (obfFullName.length() != other.obfFullName.length()) { + return obfFullName.length() - other.obfFullName.length(); } - return m_obfFullName.compareTo(other.m_obfFullName); + return obfFullName.compareTo(other.obfFullName); } public boolean renameObfClass(String oldObfClassName, String newObfClassName) { // rename inner classes - for (ClassMapping innerClassMapping : new ArrayList<>(m_innerClassesByObfSimple.values())) { + for (ClassMapping innerClassMapping : new ArrayList<>(innerClassesByObfSimple.values())) { if (innerClassMapping.renameObfClass(oldObfClassName, newObfClassName)) { - boolean wasRemoved = m_innerClassesByObfSimple.remove(oldObfClassName) != null; + boolean wasRemoved = innerClassesByObfSimple.remove(oldObfClassName) != null; assert (wasRemoved); - boolean wasAdded = m_innerClassesByObfSimple.put(newObfClassName, innerClassMapping) == null; + boolean wasAdded = innerClassesByObfSimple.put(newObfClassName, innerClassMapping) == null; assert (wasAdded); } } // rename field types - for (FieldMapping fieldMapping : new ArrayList<>(m_fieldsByObf.values())) { + for (FieldMapping fieldMapping : new ArrayList<>(fieldsByObf.values())) { String oldFieldKey = getFieldKey(fieldMapping.getObfName(), fieldMapping.getObfType()); if (fieldMapping.renameObfClass(oldObfClassName, newObfClassName)) { - boolean wasRemoved = m_fieldsByObf.remove(oldFieldKey) != null; + boolean wasRemoved = fieldsByObf.remove(oldFieldKey) != null; assert (wasRemoved); - boolean wasAdded = m_fieldsByObf.put(getFieldKey(fieldMapping.getObfName(), fieldMapping.getObfType()), fieldMapping) == null; + boolean wasAdded = fieldsByObf + .put(getFieldKey(fieldMapping.getObfName(), fieldMapping.getObfType()), fieldMapping) == null; assert (wasAdded); } } // rename method signatures - for (MethodMapping methodMapping : new ArrayList<>(m_methodsByObf.values())) { + for (MethodMapping methodMapping : new ArrayList<>(methodsByObf.values())) { String oldMethodKey = getMethodKey(methodMapping.getObfName(), methodMapping.getObfSignature()); if (methodMapping.renameObfClass(oldObfClassName, newObfClassName)) { - boolean wasRemoved = m_methodsByObf.remove(oldMethodKey) != null; + boolean wasRemoved = methodsByObf.remove(oldMethodKey) != null; assert (wasRemoved); - boolean wasAdded = m_methodsByObf.put(getMethodKey(methodMapping.getObfName(), methodMapping.getObfSignature()), methodMapping) == null; + boolean wasAdded = methodsByObf + .put(getMethodKey(methodMapping.getObfName(), methodMapping.getObfSignature()), methodMapping) == null; assert (wasAdded); } } - if (m_obfFullName.equals(oldObfClassName)) { + if (obfFullName.equals(oldObfClassName)) { // rename this class - m_obfFullName = newObfClassName; + obfFullName = newObfClassName; return true; } this.isDirty = true; @@ -487,7 +489,7 @@ public class ClassMapping implements Comparable { } public boolean containsArgument(BehaviorEntry obfBehaviorEntry, String name) { - MethodMapping methodMapping = m_methodsByObf.get(getMethodKey(obfBehaviorEntry.getName(), obfBehaviorEntry.getSignature())); + MethodMapping methodMapping = methodsByObf.get(getMethodKey(obfBehaviorEntry.getName(), obfBehaviorEntry.getSignature())); return methodMapping != null && methodMapping.containsArgument(name); } @@ -496,7 +498,7 @@ public class ClassMapping implements Comparable { } public ClassEntry getObfEntry() { - return new ClassEntry(m_obfFullName); + return new ClassEntry(obfFullName); } public boolean isDirty() @@ -522,11 +524,8 @@ public class ClassMapping implements Comparable { } public void setFieldModifier(String obfName, Type obfType, Mappings.EntryModifier modifier) { - FieldMapping fieldMapping = m_fieldsByObf.get(getFieldKey(obfName, obfType)); - if (fieldMapping == null) { - fieldMapping = new FieldMapping(obfName, obfType, null, Mappings.EntryModifier.UNCHANGED); - m_fieldsByObf.put(getFieldKey(obfName, obfType), fieldMapping); - } + FieldMapping fieldMapping = fieldsByObf.computeIfAbsent(getFieldKey(obfName, obfType), + k -> new FieldMapping(obfName, obfType, null, Mappings.EntryModifier.UNCHANGED)); if (fieldMapping.getModifier() != modifier) { @@ -536,11 +535,8 @@ public class ClassMapping implements Comparable { } public void setMethodModifier(String obfName, Signature sig, Mappings.EntryModifier modifier) { - MethodMapping methodMapping = m_methodsByObf.get(getMethodKey(obfName, sig)); - if (methodMapping == null) { - methodMapping = new MethodMapping(obfName, sig, null, Mappings.EntryModifier.UNCHANGED); - m_methodsByObf.put(getMethodKey(obfName, sig), methodMapping); - } + MethodMapping methodMapping = methodsByObf.computeIfAbsent(getMethodKey(obfName, sig), + k -> new MethodMapping(obfName, sig, null, Mappings.EntryModifier.UNCHANGED)); if (methodMapping.getModifier() != modifier) { diff --git a/src/main/java/cuchaz/enigma/mapping/FieldMapping.java b/src/main/java/cuchaz/enigma/mapping/FieldMapping.java index 83e2277..22ba307 100644 --- a/src/main/java/cuchaz/enigma/mapping/FieldMapping.java +++ b/src/main/java/cuchaz/enigma/mapping/FieldMapping.java @@ -92,14 +92,12 @@ public class FieldMapping implements Comparable, MemberMapping + { + if (className.equals(oldObfClassName)) { + return newObfClassName; } + return null; }); if (!newType.equals(this.obfType)) { diff --git a/src/main/java/cuchaz/enigma/mapping/MappingsEnigmaWriter.java b/src/main/java/cuchaz/enigma/mapping/MappingsEnigmaWriter.java index c09f4a6..6c57200 100644 --- a/src/main/java/cuchaz/enigma/mapping/MappingsEnigmaWriter.java +++ b/src/main/java/cuchaz/enigma/mapping/MappingsEnigmaWriter.java @@ -131,7 +131,7 @@ public class MappingsEnigmaWriter { } } - private void write(PrintWriter out, FieldMapping fieldMapping, int depth) throws IOException { + private void write(PrintWriter out, FieldMapping fieldMapping, int depth) { if (fieldMapping.getDeobfName() == null) out.format("%sFIELD %s %s%s\n", getIndent(depth), fieldMapping.getObfName(), fieldMapping.getObfType().toString(), fieldMapping.getModifier() == Mappings.EntryModifier.UNCHANGED ? "" : fieldMapping.getModifier().getFormattedName()); else @@ -150,12 +150,12 @@ public class MappingsEnigmaWriter { } } - private void write(PrintWriter out, ArgumentMapping argumentMapping, int depth) throws IOException { + private void write(PrintWriter out, ArgumentMapping argumentMapping, int depth) { out.format("%sARG %d %s\n", getIndent(depth), argumentMapping.getIndex(), argumentMapping.getName()); } private > List sorted(Iterable classes) { - List out = new ArrayList(); + List out = new ArrayList<>(); for (T t : classes) { out.add(t); } diff --git a/src/main/java/cuchaz/enigma/mapping/MappingsRenamer.java b/src/main/java/cuchaz/enigma/mapping/MappingsRenamer.java index bac6250..e1428ea 100644 --- a/src/main/java/cuchaz/enigma/mapping/MappingsRenamer.java +++ b/src/main/java/cuchaz/enigma/mapping/MappingsRenamer.java @@ -13,30 +13,28 @@ package cuchaz.enigma.mapping; import java.io.IOException; import java.io.ObjectOutputStream; import java.io.OutputStream; -import java.io.Serializable; import java.util.List; import java.util.Set; import java.util.zip.GZIPOutputStream; import com.google.common.collect.Lists; import cuchaz.enigma.analysis.JarIndex; -import cuchaz.enigma.analysis.MethodImplementationsTreeNode; import cuchaz.enigma.throwables.IllegalNameException; import cuchaz.enigma.throwables.MappingConflict; public class MappingsRenamer { - private JarIndex m_index; - private Mappings m_mappings; + private JarIndex index; + private Mappings mappings; public MappingsRenamer(JarIndex index, Mappings mappings) { - m_index = index; - m_mappings = mappings; + this.index = index; + this.mappings = mappings; } public void setMappings(Mappings mappings) { - this.m_mappings = mappings; + this.mappings = mappings; } public void setClassName(ClassEntry obf, String deobfName) { @@ -48,13 +46,13 @@ public class MappingsRenamer { if (deobfName != null) { // make sure we don't rename to an existing obf or deobf class - if (m_mappings.containsDeobfClass(deobfName) || m_index.containsObfClass(new ClassEntry(deobfName))) { + if (mappings.containsDeobfClass(deobfName) || index.containsObfClass(new ClassEntry(deobfName))) { throw new IllegalNameException(deobfName, "There is already a class with that name"); } } ClassMapping classMapping = mappingChain.get(0); - m_mappings.setClassDeobfName(classMapping, deobfName); + mappings.setClassDeobfName(classMapping, deobfName); } else { @@ -80,7 +78,7 @@ public class MappingsRenamer { List mappingChain = getOrCreateClassMappingChain(obf); if (mappingChain.size() == 1) { ClassMapping classMapping = mappingChain.get(0); - m_mappings.setClassDeobfName(classMapping, deobfName); + mappings.setClassDeobfName(classMapping, deobfName); } else { ClassMapping outerClassMapping = mappingChain.get(mappingChain.size() - 2); outerClassMapping.setInnerClassName(obf, deobfName); @@ -91,11 +89,11 @@ public class MappingsRenamer { deobfName = NameValidator.validateFieldName(deobfName); FieldEntry targetEntry = new FieldEntry(obf.getClassEntry(), deobfName, obf.getType()); ClassEntry definedClass = null; - if (m_mappings.containsDeobfField(obf.getClassEntry(), deobfName) || m_index.containsEntryWithSameName(targetEntry)) + if (mappings.containsDeobfField(obf.getClassEntry(), deobfName) || index.containsEntryWithSameName(targetEntry)) definedClass = obf.getClassEntry(); else { - for (ClassEntry ancestorEntry : this.m_index.getTranslationIndex().getAncestry(obf.getClassEntry())) { - if (m_mappings.containsDeobfField(ancestorEntry, deobfName) || m_index.containsEntryWithSameName(targetEntry.cloneToNewClass(ancestorEntry))) { + for (ClassEntry ancestorEntry : this.index.getTranslationIndex().getAncestry(obf.getClassEntry())) { + if (mappings.containsDeobfField(ancestorEntry, deobfName) || index.containsEntryWithSameName(targetEntry.cloneToNewClass(ancestorEntry))) { definedClass = ancestorEntry; break; } @@ -103,7 +101,7 @@ public class MappingsRenamer { } if (definedClass != null) { - String className = m_mappings.getTranslator(TranslationDirection.Deobfuscating, m_index.getTranslationIndex()).translateClass(definedClass.getClassName()); + String className = mappings.getTranslator(TranslationDirection.Deobfuscating, index.getTranslationIndex()).translateClass(definedClass.getClassName()); if (className == null) className = definedClass.getClassName(); throw new IllegalNameException(deobfName, "There is already a field with that name in " + className); @@ -127,23 +125,23 @@ public class MappingsRenamer { MethodEntry targetEntry = new MethodEntry(entry.getClassEntry(), deobfName, entry.getSignature()); // TODO: Verify if I don't break things - ClassMapping classMapping = m_mappings.getClassByObf(entry.getClassEntry()); + ClassMapping classMapping = mappings.getClassByObf(entry.getClassEntry()); if ((classMapping != null && classMapping.containsDeobfMethod(deobfName, entry.getSignature()) && classMapping.getMethodByObf(entry.getName(), entry.getSignature()) != classMapping.getMethodByDeobf(deobfName, entry.getSignature())) - || m_index.containsObfBehavior(targetEntry)) { - String deobfClassName = m_mappings.getTranslator(TranslationDirection.Deobfuscating, m_index.getTranslationIndex()).translateClass(entry.getClassName()); + || index.containsObfBehavior(targetEntry)) { + String deobfClassName = mappings.getTranslator(TranslationDirection.Deobfuscating, index.getTranslationIndex()).translateClass(entry.getClassName()); if (deobfClassName == null) { deobfClassName = entry.getClassName(); } throw new IllegalNameException(deobfName, "There is already a method with that name and signature in class " + deobfClassName); } - for (ClassEntry child : m_index.getTranslationIndex().getSubclass(entry.getClassEntry())) { + for (ClassEntry child : index.getTranslationIndex().getSubclass(entry.getClassEntry())) { validateMethodTreeName(entry.cloneToNewClass(child), deobfName); } } public void setMethodTreeName(MethodEntry obf, String deobfName) { - Set implementations = m_index.getRelatedMethodImplementations(obf); + Set implementations = index.getRelatedMethodImplementations(obf); deobfName = NameValidator.validateMethodName(deobfName); for (MethodEntry entry : implementations) { @@ -161,9 +159,9 @@ public class MappingsRenamer { ClassMapping classMapping = getOrCreateClassMapping(obf.getClassEntry()); // TODO: Verify if I don't break things - if ((m_mappings.containsDeobfMethod(obf.getClassEntry(), deobfName, obf.getSignature()) && classMapping.getMethodByObf(obf.getName(), obf.getSignature()) != classMapping.getMethodByDeobf(deobfName, obf.getSignature())) - || m_index.containsObfBehavior(targetEntry)) { - String deobfClassName = m_mappings.getTranslator(TranslationDirection.Deobfuscating, m_index.getTranslationIndex()).translateClass(obf.getClassName()); + if ((mappings.containsDeobfMethod(obf.getClassEntry(), deobfName, obf.getSignature()) && classMapping.getMethodByObf(obf.getName(), obf.getSignature()) != classMapping.getMethodByDeobf(deobfName, obf.getSignature())) + || index.containsObfBehavior(targetEntry)) { + String deobfClassName = mappings.getTranslator(TranslationDirection.Deobfuscating, index.getTranslationIndex()).translateClass(obf.getClassName()); if (deobfClassName == null) { deobfClassName = obf.getClassName(); } @@ -174,7 +172,7 @@ public class MappingsRenamer { } public void removeMethodTreeMapping(MethodEntry obf) { - m_index.getRelatedMethodImplementations(obf).forEach(this::removeMethodMapping); + index.getRelatedMethodImplementations(obf).forEach(this::removeMethodMapping); } public void removeMethodMapping(MethodEntry obf) { @@ -183,7 +181,7 @@ public class MappingsRenamer { } public void markMethodTreeAsDeobfuscated(MethodEntry obf) { - m_index.getRelatedMethodImplementations(obf).forEach(this::markMethodAsDeobfuscated); + index.getRelatedMethodImplementations(obf).forEach(this::markMethodAsDeobfuscated); } public void markMethodAsDeobfuscated(MethodEntry obf) { @@ -199,9 +197,9 @@ public class MappingsRenamer { MethodEntry obfMethod = (MethodEntry) obf.getBehaviorEntry(); - Set implementations = m_index.getRelatedMethodImplementations(obfMethod); + Set implementations = index.getRelatedMethodImplementations(obfMethod); for (MethodEntry entry : implementations) { - ClassMapping classMapping = m_mappings.getClassByObf(entry.getClassEntry()); + ClassMapping classMapping = mappings.getClassByObf(entry.getClassEntry()); if (classMapping != null) { MethodMapping mapping = classMapping.getMethodByObf(entry.getName(), entry.getSignature()); // NOTE: don't need to check arguments for name collisions with names determined by Procyon @@ -297,7 +295,7 @@ public class MappingsRenamer { private List getOrCreateClassMappingChain(ClassEntry obfClassEntry) { List classChain = obfClassEntry.getClassChain(); - List mappingChain = m_mappings.getClassMappingChain(obfClassEntry); + List mappingChain = mappings.getClassMappingChain(obfClassEntry); for (int i = 0; i < classChain.size(); i++) { ClassEntry classEntry = classChain.get(i); ClassMapping classMapping = mappingChain.get(i); @@ -310,7 +308,7 @@ public class MappingsRenamer { // add it to the right parent try { if (i == 0) { - m_mappings.addClassMapping(classMapping); + mappings.addClassMapping(classMapping); } else { mappingChain.get(i - 1).addInnerClassMapping(classMapping); } diff --git a/src/main/java/cuchaz/enigma/mapping/MappingsSRGWriter.java b/src/main/java/cuchaz/enigma/mapping/MappingsSRGWriter.java index 4d0c261..a3f0cc8 100644 --- a/src/main/java/cuchaz/enigma/mapping/MappingsSRGWriter.java +++ b/src/main/java/cuchaz/enigma/mapping/MappingsSRGWriter.java @@ -71,7 +71,7 @@ public class MappingsSRGWriter { private > List sorted(Iterable classes) { - List out = new ArrayList(); + List out = new ArrayList<>(); for (T t : classes) { out.add(t); } diff --git a/src/main/java/cuchaz/enigma/mapping/MethodMapping.java b/src/main/java/cuchaz/enigma/mapping/MethodMapping.java index f973d6b..e0aeea2 100644 --- a/src/main/java/cuchaz/enigma/mapping/MethodMapping.java +++ b/src/main/java/cuchaz/enigma/mapping/MethodMapping.java @@ -178,14 +178,12 @@ public class MethodMapping implements Comparable, MemberMapping + { + if (className.equals(oldObfClassName)) { + return newObfClassName; } + return null; }); if (!newSignature.equals(this.obfSignature)) { diff --git a/src/main/java/cuchaz/enigma/throwables/MappingParseException.java b/src/main/java/cuchaz/enigma/throwables/MappingParseException.java index 18dff27..d4c6673 100644 --- a/src/main/java/cuchaz/enigma/throwables/MappingParseException.java +++ b/src/main/java/cuchaz/enigma/throwables/MappingParseException.java @@ -14,18 +14,18 @@ import java.io.File; public class MappingParseException extends Exception { - private int m_line; - private String m_message; + private int line; + private String message; private String filePath; public MappingParseException(File file, int line, String message) { - m_line = line; - m_message = message; + this.line = line; + this.message = message; filePath = file.getAbsolutePath(); } @Override public String getMessage() { - return "Line " + m_line + ": " + m_message + " in file " + filePath; + return "Line " + line + ": " + message + " in file " + filePath; } } diff --git a/src/main/java/cuchaz/enigma/utils/Utils.java b/src/main/java/cuchaz/enigma/utils/Utils.java index ebc110a..474f7ed 100644 --- a/src/main/java/cuchaz/enigma/utils/Utils.java +++ b/src/main/java/cuchaz/enigma/utils/Utils.java @@ -21,6 +21,7 @@ import java.io.InputStreamReader; import java.net.URI; import java.net.URISyntaxException; import java.util.Arrays; +import java.util.List; import javax.swing.*; @@ -30,7 +31,7 @@ public class Utils { return combineHashesOrdered(Arrays.asList(objs)); } - public static int combineHashesOrdered(Iterable objs) { + public static int combineHashesOrdered(List objs) { final int prime = 67; int result = 1; for (Object obj : objs) { diff --git a/src/test/java/cuchaz/enigma/TestDeobfed.java b/src/test/java/cuchaz/enigma/TestDeobfed.java index 2f318c8..76a3d3b 100644 --- a/src/test/java/cuchaz/enigma/TestDeobfed.java +++ b/src/test/java/cuchaz/enigma/TestDeobfed.java @@ -25,20 +25,20 @@ import cuchaz.enigma.analysis.JarIndex; public class TestDeobfed { - private static JarFile m_jar; - private static JarIndex m_index; + private static JarFile jar; + private static JarIndex index; @BeforeClass public static void beforeClass() throws Exception { - m_jar = new JarFile("build/test-deobf/translation.jar"); - m_index = new JarIndex(); - m_index.indexJar(m_jar, true); + jar = new JarFile("build/test-deobf/translation.jar"); + index = new JarIndex(); + index.indexJar(jar, true); } @Test public void obfEntries() { - assertThat(m_index.getObfClassEntries(), containsInAnyOrder( + assertThat(index.getObfClassEntries(), containsInAnyOrder( newClass("cuchaz/enigma/inputs/Keep"), newClass("a"), newClass("b"), @@ -68,7 +68,7 @@ public class TestDeobfed { @Test public void decompile() throws Exception { - Deobfuscator deobfuscator = new Deobfuscator(m_jar); + Deobfuscator deobfuscator = new Deobfuscator(jar); deobfuscator.getSourceTree("a"); deobfuscator.getSourceTree("b"); deobfuscator.getSourceTree("c"); diff --git a/src/test/java/cuchaz/enigma/TestInnerClasses.java b/src/test/java/cuchaz/enigma/TestInnerClasses.java index 70765e3..64a695a 100644 --- a/src/test/java/cuchaz/enigma/TestInnerClasses.java +++ b/src/test/java/cuchaz/enigma/TestInnerClasses.java @@ -24,8 +24,8 @@ import cuchaz.enigma.mapping.ClassEntry; public class TestInnerClasses { - private JarIndex m_index; - private Deobfuscator m_deobfuscator; + private JarIndex index; + private Deobfuscator deobfuscator; private static final ClassEntry AnonymousOuter = newClass("a"); private static final ClassEntry AnonymousInner = newClass("a$1"); @@ -44,49 +44,49 @@ public class TestInnerClasses { public TestInnerClasses() throws Exception { - m_index = new JarIndex(); + index = new JarIndex(); JarFile jar = new JarFile("build/test-obf/innerClasses.jar"); - m_index.indexJar(jar, true); - m_deobfuscator = new Deobfuscator(jar); + index.indexJar(jar, true); + deobfuscator = new Deobfuscator(jar); } @Test public void simple() { - assertThat(m_index.getOuterClass(SimpleInner), is(SimpleOuter)); - assertThat(m_index.getInnerClasses(SimpleOuter), containsInAnyOrder(SimpleInner)); - assertThat(m_index.isAnonymousClass(SimpleInner), is(false)); + assertThat(index.getOuterClass(SimpleInner), is(SimpleOuter)); + assertThat(index.getInnerClasses(SimpleOuter), containsInAnyOrder(SimpleInner)); + assertThat(index.isAnonymousClass(SimpleInner), is(false)); decompile(SimpleOuter); } @Test public void anonymous() { - assertThat(m_index.getOuterClass(AnonymousInner), is(AnonymousOuter)); - assertThat(m_index.getInnerClasses(AnonymousOuter), containsInAnyOrder(AnonymousInner)); - assertThat(m_index.isAnonymousClass(AnonymousInner), is(true)); + assertThat(index.getOuterClass(AnonymousInner), is(AnonymousOuter)); + assertThat(index.getInnerClasses(AnonymousOuter), containsInAnyOrder(AnonymousInner)); + assertThat(index.isAnonymousClass(AnonymousInner), is(true)); decompile(AnonymousOuter); } @Test public void constructorArgs() { - assertThat(m_index.getOuterClass(ConstructorArgsInner), is(ConstructorArgsOuter)); - assertThat(m_index.getInnerClasses(ConstructorArgsOuter), containsInAnyOrder(ConstructorArgsInner)); - assertThat(m_index.isAnonymousClass(ConstructorArgsInner), is(false)); + assertThat(index.getOuterClass(ConstructorArgsInner), is(ConstructorArgsOuter)); + assertThat(index.getInnerClasses(ConstructorArgsOuter), containsInAnyOrder(ConstructorArgsInner)); + assertThat(index.isAnonymousClass(ConstructorArgsInner), is(false)); decompile(ConstructorArgsOuter); } @Test public void anonymousWithScopeArgs() { - assertThat(m_index.getOuterClass(AnonymousWithScopeArgsInner), is(AnonymousWithScopeArgsOuter)); - assertThat(m_index.getInnerClasses(AnonymousWithScopeArgsOuter), containsInAnyOrder(AnonymousWithScopeArgsInner)); - assertThat(m_index.isAnonymousClass(AnonymousWithScopeArgsInner), is(true)); + assertThat(index.getOuterClass(AnonymousWithScopeArgsInner), is(AnonymousWithScopeArgsOuter)); + assertThat(index.getInnerClasses(AnonymousWithScopeArgsOuter), containsInAnyOrder(AnonymousWithScopeArgsInner)); + assertThat(index.isAnonymousClass(AnonymousWithScopeArgsInner), is(true)); decompile(AnonymousWithScopeArgsOuter); } @Test public void anonymousWithOuterAccess() { - assertThat(m_index.getOuterClass(AnonymousWithOuterAccessInner), is(AnonymousWithOuterAccessOuter)); - assertThat(m_index.getInnerClasses(AnonymousWithOuterAccessOuter), containsInAnyOrder(AnonymousWithOuterAccessInner)); - assertThat(m_index.isAnonymousClass(AnonymousWithOuterAccessInner), is(true)); + assertThat(index.getOuterClass(AnonymousWithOuterAccessInner), is(AnonymousWithOuterAccessOuter)); + assertThat(index.getInnerClasses(AnonymousWithOuterAccessOuter), containsInAnyOrder(AnonymousWithOuterAccessInner)); + assertThat(index.isAnonymousClass(AnonymousWithOuterAccessInner), is(true)); decompile(AnonymousWithOuterAccessOuter); } @@ -94,26 +94,26 @@ public class TestInnerClasses { public void classTree() { // root level - assertThat(m_index.containsObfClass(ClassTreeRoot), is(true)); - assertThat(m_index.getOuterClass(ClassTreeRoot), is(nullValue())); - assertThat(m_index.getInnerClasses(ClassTreeRoot), containsInAnyOrder(ClassTreeLevel1)); + assertThat(index.containsObfClass(ClassTreeRoot), is(true)); + assertThat(index.getOuterClass(ClassTreeRoot), is(nullValue())); + assertThat(index.getInnerClasses(ClassTreeRoot), containsInAnyOrder(ClassTreeLevel1)); // level 1 ClassEntry fullClassEntry = new ClassEntry(ClassTreeRoot.getName() + "$" + ClassTreeLevel1.getInnermostClassName() ); - assertThat(m_index.containsObfClass(fullClassEntry), is(true)); - assertThat(m_index.getOuterClass(ClassTreeLevel1), is(ClassTreeRoot)); - assertThat(m_index.getInnerClasses(ClassTreeLevel1), containsInAnyOrder(ClassTreeLevel2)); + assertThat(index.containsObfClass(fullClassEntry), is(true)); + assertThat(index.getOuterClass(ClassTreeLevel1), is(ClassTreeRoot)); + assertThat(index.getInnerClasses(ClassTreeLevel1), containsInAnyOrder(ClassTreeLevel2)); // level 2 fullClassEntry = new ClassEntry(ClassTreeRoot.getName() + "$" + ClassTreeLevel1.getInnermostClassName() + "$" + ClassTreeLevel2.getInnermostClassName() ); - assertThat(m_index.containsObfClass(fullClassEntry), is(true)); - assertThat(m_index.getOuterClass(ClassTreeLevel2), is(ClassTreeLevel1)); - assertThat(m_index.getInnerClasses(ClassTreeLevel2), containsInAnyOrder(ClassTreeLevel3)); + assertThat(index.containsObfClass(fullClassEntry), is(true)); + assertThat(index.getOuterClass(ClassTreeLevel2), is(ClassTreeLevel1)); + assertThat(index.getInnerClasses(ClassTreeLevel2), containsInAnyOrder(ClassTreeLevel3)); // level 3 fullClassEntry = new ClassEntry(ClassTreeRoot.getName() @@ -121,12 +121,12 @@ public class TestInnerClasses { + "$" + ClassTreeLevel2.getInnermostClassName() + "$" + ClassTreeLevel3.getInnermostClassName() ); - assertThat(m_index.containsObfClass(fullClassEntry), is(true)); - assertThat(m_index.getOuterClass(ClassTreeLevel3), is(ClassTreeLevel2)); - assertThat(m_index.getInnerClasses(ClassTreeLevel3), is(empty())); + assertThat(index.containsObfClass(fullClassEntry), is(true)); + assertThat(index.getOuterClass(ClassTreeLevel3), is(ClassTreeLevel2)); + assertThat(index.getInnerClasses(ClassTreeLevel3), is(empty())); } private void decompile(ClassEntry classEntry) { - m_deobfuscator.getSourceTree(classEntry.getName()); + deobfuscator.getSourceTree(classEntry.getName()); } } diff --git a/src/test/java/cuchaz/enigma/TestJarIndexConstructorReferences.java b/src/test/java/cuchaz/enigma/TestJarIndexConstructorReferences.java index cb65cd0..01d4bab 100644 --- a/src/test/java/cuchaz/enigma/TestJarIndexConstructorReferences.java +++ b/src/test/java/cuchaz/enigma/TestJarIndexConstructorReferences.java @@ -27,98 +27,99 @@ import cuchaz.enigma.mapping.ClassEntry; public class TestJarIndexConstructorReferences { - private JarIndex m_index; + private JarIndex index; - private ClassEntry m_baseClass = newClass("a"); - private ClassEntry m_subClass = newClass("d"); - private ClassEntry m_subsubClass = newClass("e"); - private ClassEntry m_defaultClass = newClass("c"); - private ClassEntry m_callerClass = newClass("b"); + private ClassEntry baseClass = newClass("a"); + private ClassEntry subClass = newClass("d"); + private ClassEntry subsubClass = newClass("e"); + private ClassEntry defaultClass = newClass("c"); + private ClassEntry callerClass = newClass("b"); public TestJarIndexConstructorReferences() throws Exception { File jarFile = new File("build/test-obf/constructors.jar"); - m_index = new JarIndex(); - m_index.indexJar(new JarFile(jarFile), false); + index = new JarIndex(); + index.indexJar(new JarFile(jarFile), false); } @Test public void obfEntries() { - assertThat(m_index.getObfClassEntries(), containsInAnyOrder(newClass("cuchaz/enigma/inputs/Keep"), m_baseClass, m_subClass, m_subsubClass, m_defaultClass, m_callerClass)); + assertThat(index.getObfClassEntries(), containsInAnyOrder(newClass("cuchaz/enigma/inputs/Keep"), baseClass, + subClass, subsubClass, defaultClass, callerClass)); } @Test @SuppressWarnings("unchecked") public void baseDefault() { - BehaviorEntry source = newConstructor(m_baseClass, "()V"); - Collection> references = m_index.getBehaviorReferences(source); + BehaviorEntry source = newConstructor(baseClass, "()V"); + Collection> references = index.getBehaviorReferences(source); assertThat(references, containsInAnyOrder( - newBehaviorReferenceByMethod(source, m_callerClass.getName(), "a", "()V"), - newBehaviorReferenceByConstructor(source, m_subClass.getName(), "()V"), - newBehaviorReferenceByConstructor(source, m_subClass.getName(), "(III)V") + newBehaviorReferenceByMethod(source, callerClass.getName(), "a", "()V"), + newBehaviorReferenceByConstructor(source, subClass.getName(), "()V"), + newBehaviorReferenceByConstructor(source, subClass.getName(), "(III)V") )); } @Test @SuppressWarnings("unchecked") public void baseInt() { - BehaviorEntry source = newConstructor(m_baseClass, "(I)V"); - assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder( - newBehaviorReferenceByMethod(source, m_callerClass.getName(), "b", "()V") + BehaviorEntry source = newConstructor(baseClass, "(I)V"); + assertThat(index.getBehaviorReferences(source), containsInAnyOrder( + newBehaviorReferenceByMethod(source, callerClass.getName(), "b", "()V") )); } @Test @SuppressWarnings("unchecked") public void subDefault() { - BehaviorEntry source = newConstructor(m_subClass, "()V"); - assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder( - newBehaviorReferenceByMethod(source, m_callerClass.getName(), "c", "()V"), - newBehaviorReferenceByConstructor(source, m_subClass.getName(), "(I)V") + BehaviorEntry source = newConstructor(subClass, "()V"); + assertThat(index.getBehaviorReferences(source), containsInAnyOrder( + newBehaviorReferenceByMethod(source, callerClass.getName(), "c", "()V"), + newBehaviorReferenceByConstructor(source, subClass.getName(), "(I)V") )); } @Test @SuppressWarnings("unchecked") public void subInt() { - BehaviorEntry source = newConstructor(m_subClass, "(I)V"); - assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder( - newBehaviorReferenceByMethod(source, m_callerClass.getName(), "d", "()V"), - newBehaviorReferenceByConstructor(source, m_subClass.getName(), "(II)V"), - newBehaviorReferenceByConstructor(source, m_subsubClass.getName(), "(I)V") + BehaviorEntry source = newConstructor(subClass, "(I)V"); + assertThat(index.getBehaviorReferences(source), containsInAnyOrder( + newBehaviorReferenceByMethod(source, callerClass.getName(), "d", "()V"), + newBehaviorReferenceByConstructor(source, subClass.getName(), "(II)V"), + newBehaviorReferenceByConstructor(source, subsubClass.getName(), "(I)V") )); } @Test @SuppressWarnings("unchecked") public void subIntInt() { - BehaviorEntry source = newConstructor(m_subClass, "(II)V"); - assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder( - newBehaviorReferenceByMethod(source, m_callerClass.getName(), "e", "()V") + BehaviorEntry source = newConstructor(subClass, "(II)V"); + assertThat(index.getBehaviorReferences(source), containsInAnyOrder( + newBehaviorReferenceByMethod(source, callerClass.getName(), "e", "()V") )); } @Test public void subIntIntInt() { - BehaviorEntry source = newConstructor(m_subClass, "(III)V"); - assertThat(m_index.getBehaviorReferences(source), is(empty())); + BehaviorEntry source = newConstructor(subClass, "(III)V"); + assertThat(index.getBehaviorReferences(source), is(empty())); } @Test @SuppressWarnings("unchecked") public void subsubInt() { - BehaviorEntry source = newConstructor(m_subsubClass, "(I)V"); - assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder( - newBehaviorReferenceByMethod(source, m_callerClass.getName(), "f", "()V") + BehaviorEntry source = newConstructor(subsubClass, "(I)V"); + assertThat(index.getBehaviorReferences(source), containsInAnyOrder( + newBehaviorReferenceByMethod(source, callerClass.getName(), "f", "()V") )); } @Test @SuppressWarnings("unchecked") public void defaultConstructable() { - BehaviorEntry source = newConstructor(m_defaultClass, "()V"); - assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder( - newBehaviorReferenceByMethod(source, m_callerClass.getName(), "g", "()V") + BehaviorEntry source = newConstructor(defaultClass, "()V"); + assertThat(index.getBehaviorReferences(source), containsInAnyOrder( + newBehaviorReferenceByMethod(source, callerClass.getName(), "g", "()V") )); } } diff --git a/src/test/java/cuchaz/enigma/TestJarIndexInheritanceTree.java b/src/test/java/cuchaz/enigma/TestJarIndexInheritanceTree.java index 28408f2..4d9c8dc 100644 --- a/src/test/java/cuchaz/enigma/TestJarIndexInheritanceTree.java +++ b/src/test/java/cuchaz/enigma/TestJarIndexInheritanceTree.java @@ -41,66 +41,60 @@ import cuchaz.enigma.mapping.MethodEntry; public class TestJarIndexInheritanceTree { - private JarIndex m_index; + private JarIndex index; - private ClassEntry m_objectClass = newClass("java/lang/Object"); - private ClassEntry m_baseClass = newClass("a"); - private ClassEntry m_subClassA = newClass("b"); - private ClassEntry m_subClassAA = newClass("d"); - private ClassEntry m_subClassB = newClass("c"); - private FieldEntry m_nameField = newField(m_baseClass, "a", "Ljava/lang/String;"); - private FieldEntry m_numThingsField = newField(m_subClassB, "a", "I"); + private ClassEntry objectClass = newClass("java/lang/Object"); + private ClassEntry baseClass = newClass("a"); + private ClassEntry subClassA = newClass("b"); + private ClassEntry subClassAA = newClass("d"); + private ClassEntry subClassB = newClass("c"); + private FieldEntry nameField = newField(baseClass, "a", "Ljava/lang/String;"); + private FieldEntry numThingsField = newField(subClassB, "a", "I"); public TestJarIndexInheritanceTree() throws Exception { - m_index = new JarIndex(); - m_index.indexJar(new JarFile("build/test-obf/inheritanceTree.jar"), false); + index = new JarIndex(); + index.indexJar(new JarFile("build/test-obf/inheritanceTree.jar"), false); } @Test public void obfEntries() { - assertThat(m_index.getObfClassEntries(), containsInAnyOrder( - newClass("cuchaz/enigma/inputs/Keep"), - m_baseClass, - m_subClassA, - m_subClassAA, - m_subClassB + assertThat(index.getObfClassEntries(), containsInAnyOrder( + newClass("cuchaz/enigma/inputs/Keep"), baseClass, subClassA, subClassAA, subClassB )); } @Test public void translationIndex() { - TranslationIndex index = m_index.getTranslationIndex(); + TranslationIndex index = this.index.getTranslationIndex(); // base class - assertThat(index.getSuperclass(m_baseClass), is(m_objectClass)); - assertThat(index.getAncestry(m_baseClass), contains(m_objectClass)); - assertThat(index.getSubclass(m_baseClass), containsInAnyOrder( - m_subClassA, - m_subClassB + assertThat(index.getSuperclass(baseClass), is(objectClass)); + assertThat(index.getAncestry(baseClass), contains(objectClass)); + assertThat(index.getSubclass(baseClass), containsInAnyOrder(subClassA, subClassB )); // subclass a - assertThat(index.getSuperclass(m_subClassA), is(m_baseClass)); - assertThat(index.getAncestry(m_subClassA), contains(m_baseClass, m_objectClass)); - assertThat(index.getSubclass(m_subClassA), contains(m_subClassAA)); + assertThat(index.getSuperclass(subClassA), is(baseClass)); + assertThat(index.getAncestry(subClassA), contains(baseClass, objectClass)); + assertThat(index.getSubclass(subClassA), contains(subClassAA)); // subclass aa - assertThat(index.getSuperclass(m_subClassAA), is(m_subClassA)); - assertThat(index.getAncestry(m_subClassAA), contains(m_subClassA, m_baseClass, m_objectClass)); - assertThat(index.getSubclass(m_subClassAA), is(empty())); + assertThat(index.getSuperclass(subClassAA), is(subClassA)); + assertThat(index.getAncestry(subClassAA), contains(subClassA, baseClass, objectClass)); + assertThat(index.getSubclass(subClassAA), is(empty())); // subclass b - assertThat(index.getSuperclass(m_subClassB), is(m_baseClass)); - assertThat(index.getAncestry(m_subClassB), contains(m_baseClass, m_objectClass)); - assertThat(index.getSubclass(m_subClassB), is(empty())); + assertThat(index.getSuperclass(subClassB), is(baseClass)); + assertThat(index.getAncestry(subClassB), contains(baseClass, objectClass)); + assertThat(index.getSubclass(subClassB), is(empty())); } @Test public void access() { - assertThat(m_index.getAccess(m_nameField), is(Access.Private)); - assertThat(m_index.getAccess(m_numThingsField), is(Access.Private)); + assertThat(index.getAccess(nameField), is(Access.PRIVATE)); + assertThat(index.getAccess(numThingsField), is(Access.PRIVATE)); } @Test @@ -109,40 +103,40 @@ public class TestJarIndexInheritanceTree { Set entries; // getName() - entries = m_index.getRelatedMethodImplementations(newMethod(m_baseClass, "a", "()Ljava/lang/String;")); + entries = index.getRelatedMethodImplementations(newMethod(baseClass, "a", "()Ljava/lang/String;")); assertThat(entries, containsInAnyOrder( - newMethod(m_baseClass, "a", "()Ljava/lang/String;"), - newMethod(m_subClassAA, "a", "()Ljava/lang/String;") + newMethod(baseClass, "a", "()Ljava/lang/String;"), + newMethod(subClassAA, "a", "()Ljava/lang/String;") )); - entries = m_index.getRelatedMethodImplementations(newMethod(m_subClassAA, "a", "()Ljava/lang/String;")); + entries = index.getRelatedMethodImplementations(newMethod(subClassAA, "a", "()Ljava/lang/String;")); assertThat(entries, containsInAnyOrder( - newMethod(m_baseClass, "a", "()Ljava/lang/String;"), - newMethod(m_subClassAA, "a", "()Ljava/lang/String;") + newMethod(baseClass, "a", "()Ljava/lang/String;"), + newMethod(subClassAA, "a", "()Ljava/lang/String;") )); // doBaseThings() - entries = m_index.getRelatedMethodImplementations(newMethod(m_baseClass, "a", "()V")); + entries = index.getRelatedMethodImplementations(newMethod(baseClass, "a", "()V")); assertThat(entries, containsInAnyOrder( - newMethod(m_baseClass, "a", "()V"), - newMethod(m_subClassAA, "a", "()V"), - newMethod(m_subClassB, "a", "()V") + newMethod(baseClass, "a", "()V"), + newMethod(subClassAA, "a", "()V"), + newMethod(subClassB, "a", "()V") )); - entries = m_index.getRelatedMethodImplementations(newMethod(m_subClassAA, "a", "()V")); + entries = index.getRelatedMethodImplementations(newMethod(subClassAA, "a", "()V")); assertThat(entries, containsInAnyOrder( - newMethod(m_baseClass, "a", "()V"), - newMethod(m_subClassAA, "a", "()V"), - newMethod(m_subClassB, "a", "()V") + newMethod(baseClass, "a", "()V"), + newMethod(subClassAA, "a", "()V"), + newMethod(subClassB, "a", "()V") )); - entries = m_index.getRelatedMethodImplementations(newMethod(m_subClassB, "a", "()V")); + entries = index.getRelatedMethodImplementations(newMethod(subClassB, "a", "()V")); assertThat(entries, containsInAnyOrder( - newMethod(m_baseClass, "a", "()V"), - newMethod(m_subClassAA, "a", "()V"), - newMethod(m_subClassB, "a", "()V") + newMethod(baseClass, "a", "()V"), + newMethod(subClassAA, "a", "()V"), + newMethod(subClassB, "a", "()V") )); // doBThings - entries = m_index.getRelatedMethodImplementations(newMethod(m_subClassB, "b", "()V")); - assertThat(entries, containsInAnyOrder(newMethod(m_subClassB, "b", "()V"))); + entries = index.getRelatedMethodImplementations(newMethod(subClassB, "b", "()V")); + assertThat(entries, containsInAnyOrder(newMethod(subClassB, "b", "()V"))); } @Test @@ -151,17 +145,17 @@ public class TestJarIndexInheritanceTree { Collection> references; // name - references = m_index.getFieldReferences(m_nameField); + references = index.getFieldReferences(nameField); assertThat(references, containsInAnyOrder( - newFieldReferenceByConstructor(m_nameField, m_baseClass.getName(), "(Ljava/lang/String;)V"), - newFieldReferenceByMethod(m_nameField, m_baseClass.getName(), "a", "()Ljava/lang/String;") + newFieldReferenceByConstructor(nameField, baseClass.getName(), "(Ljava/lang/String;)V"), + newFieldReferenceByMethod(nameField, baseClass.getName(), "a", "()Ljava/lang/String;") )); // numThings - references = m_index.getFieldReferences(m_numThingsField); + references = index.getFieldReferences(numThingsField); assertThat(references, containsInAnyOrder( - newFieldReferenceByConstructor(m_numThingsField, m_subClassB.getName(), "()V"), - newFieldReferenceByMethod(m_numThingsField, m_subClassB.getName(), "b", "()V") + newFieldReferenceByConstructor(numThingsField, subClassB.getName(), "()V"), + newFieldReferenceByMethod(numThingsField, subClassB.getName(), "b", "()V") )); } @@ -173,33 +167,33 @@ public class TestJarIndexInheritanceTree { Collection> references; // baseClass constructor - source = newConstructor(m_baseClass, "(Ljava/lang/String;)V"); - references = m_index.getBehaviorReferences(source); + source = newConstructor(baseClass, "(Ljava/lang/String;)V"); + references = index.getBehaviorReferences(source); assertThat(references, containsInAnyOrder( - newBehaviorReferenceByConstructor(source, m_subClassA.getName(), "(Ljava/lang/String;)V"), - newBehaviorReferenceByConstructor(source, m_subClassB.getName(), "()V") + newBehaviorReferenceByConstructor(source, subClassA.getName(), "(Ljava/lang/String;)V"), + newBehaviorReferenceByConstructor(source, subClassB.getName(), "()V") )); // subClassA constructor - source = newConstructor(m_subClassA, "(Ljava/lang/String;)V"); - references = m_index.getBehaviorReferences(source); + source = newConstructor(subClassA, "(Ljava/lang/String;)V"); + references = index.getBehaviorReferences(source); assertThat(references, containsInAnyOrder( - newBehaviorReferenceByConstructor(source, m_subClassAA.getName(), "()V") + newBehaviorReferenceByConstructor(source, subClassAA.getName(), "()V") )); // baseClass.getName() - source = newMethod(m_baseClass, "a", "()Ljava/lang/String;"); - references = m_index.getBehaviorReferences(source); + source = newMethod(baseClass, "a", "()Ljava/lang/String;"); + references = index.getBehaviorReferences(source); assertThat(references, containsInAnyOrder( - newBehaviorReferenceByMethod(source, m_subClassAA.getName(), "a", "()Ljava/lang/String;"), - newBehaviorReferenceByMethod(source, m_subClassB.getName(), "a", "()V") + newBehaviorReferenceByMethod(source, subClassAA.getName(), "a", "()Ljava/lang/String;"), + newBehaviorReferenceByMethod(source, subClassB.getName(), "a", "()V") )); // subclassAA.getName() - source = newMethod(m_subClassAA, "a", "()Ljava/lang/String;"); - references = m_index.getBehaviorReferences(source); + source = newMethod(subClassAA, "a", "()Ljava/lang/String;"); + references = index.getBehaviorReferences(source); assertThat(references, containsInAnyOrder( - newBehaviorReferenceByMethod(source, m_subClassAA.getName(), "a", "()V") + newBehaviorReferenceByMethod(source, subClassAA.getName(), "a", "()V") )); } @@ -207,33 +201,33 @@ public class TestJarIndexInheritanceTree { public void containsEntries() { // classes - assertThat(m_index.containsObfClass(m_baseClass), is(true)); - assertThat(m_index.containsObfClass(m_subClassA), is(true)); - assertThat(m_index.containsObfClass(m_subClassAA), is(true)); - assertThat(m_index.containsObfClass(m_subClassB), is(true)); + assertThat(index.containsObfClass(baseClass), is(true)); + assertThat(index.containsObfClass(subClassA), is(true)); + assertThat(index.containsObfClass(subClassAA), is(true)); + assertThat(index.containsObfClass(subClassB), is(true)); // fields - assertThat(m_index.containsObfField(m_nameField), is(true)); - assertThat(m_index.containsObfField(m_numThingsField), is(true)); + assertThat(index.containsObfField(nameField), is(true)); + assertThat(index.containsObfField(numThingsField), is(true)); // methods // getName() - assertThat(m_index.containsObfBehavior(newMethod(m_baseClass, "a", "()Ljava/lang/String;")), is(true)); - assertThat(m_index.containsObfBehavior(newMethod(m_subClassA, "a", "()Ljava/lang/String;")), is(false)); - assertThat(m_index.containsObfBehavior(newMethod(m_subClassAA, "a", "()Ljava/lang/String;")), is(true)); - assertThat(m_index.containsObfBehavior(newMethod(m_subClassB, "a", "()Ljava/lang/String;")), is(false)); + assertThat(index.containsObfBehavior(newMethod(baseClass, "a", "()Ljava/lang/String;")), is(true)); + assertThat(index.containsObfBehavior(newMethod(subClassA, "a", "()Ljava/lang/String;")), is(false)); + assertThat(index.containsObfBehavior(newMethod(subClassAA, "a", "()Ljava/lang/String;")), is(true)); + assertThat(index.containsObfBehavior(newMethod(subClassB, "a", "()Ljava/lang/String;")), is(false)); // doBaseThings() - assertThat(m_index.containsObfBehavior(newMethod(m_baseClass, "a", "()V")), is(true)); - assertThat(m_index.containsObfBehavior(newMethod(m_subClassA, "a", "()V")), is(false)); - assertThat(m_index.containsObfBehavior(newMethod(m_subClassAA, "a", "()V")), is(true)); - assertThat(m_index.containsObfBehavior(newMethod(m_subClassB, "a", "()V")), is(true)); + assertThat(index.containsObfBehavior(newMethod(baseClass, "a", "()V")), is(true)); + assertThat(index.containsObfBehavior(newMethod(subClassA, "a", "()V")), is(false)); + assertThat(index.containsObfBehavior(newMethod(subClassAA, "a", "()V")), is(true)); + assertThat(index.containsObfBehavior(newMethod(subClassB, "a", "()V")), is(true)); // doBThings() - assertThat(m_index.containsObfBehavior(newMethod(m_baseClass, "b", "()V")), is(false)); - assertThat(m_index.containsObfBehavior(newMethod(m_subClassA, "b", "()V")), is(false)); - assertThat(m_index.containsObfBehavior(newMethod(m_subClassAA, "b", "()V")), is(false)); - assertThat(m_index.containsObfBehavior(newMethod(m_subClassB, "b", "()V")), is(true)); + assertThat(index.containsObfBehavior(newMethod(baseClass, "b", "()V")), is(false)); + assertThat(index.containsObfBehavior(newMethod(subClassA, "b", "()V")), is(false)); + assertThat(index.containsObfBehavior(newMethod(subClassAA, "b", "()V")), is(false)); + assertThat(index.containsObfBehavior(newMethod(subClassB, "b", "()V")), is(true)); } } diff --git a/src/test/java/cuchaz/enigma/TestJarIndexLoneClass.java b/src/test/java/cuchaz/enigma/TestJarIndexLoneClass.java index 65af6d8..8efa57c 100644 --- a/src/test/java/cuchaz/enigma/TestJarIndexLoneClass.java +++ b/src/test/java/cuchaz/enigma/TestJarIndexLoneClass.java @@ -34,17 +34,17 @@ import cuchaz.enigma.mapping.Translator; public class TestJarIndexLoneClass { - private JarIndex m_index; + private JarIndex index; public TestJarIndexLoneClass() throws Exception { - m_index = new JarIndex(); - m_index.indexJar(new JarFile("build/test-obf/loneClass.jar"), false); + index = new JarIndex(); + index.indexJar(new JarFile("build/test-obf/loneClass.jar"), false); } @Test public void obfEntries() { - assertThat(m_index.getObfClassEntries(), containsInAnyOrder( + assertThat(index.getObfClassEntries(), containsInAnyOrder( newClass("cuchaz/enigma/inputs/Keep"), newClass("a") )); @@ -52,25 +52,25 @@ public class TestJarIndexLoneClass { @Test public void translationIndex() { - assertThat(m_index.getTranslationIndex().getSuperclass(new ClassEntry("a")), is(new ClassEntry("java/lang/Object"))); - assertThat(m_index.getTranslationIndex().getSuperclass(new ClassEntry("cuchaz/enigma/inputs/Keep")), is(new ClassEntry("java/lang/Object"))); - assertThat(m_index.getTranslationIndex().getAncestry(new ClassEntry("a")), contains(new ClassEntry("java/lang/Object"))); - assertThat(m_index.getTranslationIndex().getAncestry(new ClassEntry("cuchaz/enigma/inputs/Keep")), contains(new ClassEntry("java/lang/Object"))); - assertThat(m_index.getTranslationIndex().getSubclass(new ClassEntry("a")), is(empty())); - assertThat(m_index.getTranslationIndex().getSubclass(new ClassEntry("cuchaz/enigma/inputs/Keep")), is(empty())); + assertThat(index.getTranslationIndex().getSuperclass(new ClassEntry("a")), is(new ClassEntry("java/lang/Object"))); + assertThat(index.getTranslationIndex().getSuperclass(new ClassEntry("cuchaz/enigma/inputs/Keep")), is(new ClassEntry("java/lang/Object"))); + assertThat(index.getTranslationIndex().getAncestry(new ClassEntry("a")), contains(new ClassEntry("java/lang/Object"))); + assertThat(index.getTranslationIndex().getAncestry(new ClassEntry("cuchaz/enigma/inputs/Keep")), contains(new ClassEntry("java/lang/Object"))); + assertThat(index.getTranslationIndex().getSubclass(new ClassEntry("a")), is(empty())); + assertThat(index.getTranslationIndex().getSubclass(new ClassEntry("cuchaz/enigma/inputs/Keep")), is(empty())); } @Test public void access() { - assertThat(m_index.getAccess(newField("a", "a", "Ljava/lang/String;")), is(Access.Private)); - assertThat(m_index.getAccess(newMethod("a", "a", "()Ljava/lang/String;")), is(Access.Public)); - assertThat(m_index.getAccess(newField("a", "b", "Ljava/lang/String;")), is(nullValue())); - assertThat(m_index.getAccess(newField("a", "a", "LFoo;")), is(nullValue())); + assertThat(index.getAccess(newField("a", "a", "Ljava/lang/String;")), is(Access.PRIVATE)); + assertThat(index.getAccess(newMethod("a", "a", "()Ljava/lang/String;")), is(Access.PUBLIC)); + assertThat(index.getAccess(newField("a", "b", "Ljava/lang/String;")), is(nullValue())); + assertThat(index.getAccess(newField("a", "a", "LFoo;")), is(nullValue())); } @Test public void classInheritance() { - ClassInheritanceTreeNode node = m_index.getClassInheritance(new Translator(), newClass("a")); + ClassInheritanceTreeNode node = index.getClassInheritance(new Translator(), newClass("a")); assertThat(node, is(not(nullValue()))); assertThat(node.getObfClassName(), is("a")); assertThat(node.getChildCount(), is(0)); @@ -79,7 +79,7 @@ public class TestJarIndexLoneClass { @Test public void methodInheritance() { MethodEntry source = newMethod("a", "a", "()Ljava/lang/String;"); - MethodInheritanceTreeNode node = m_index.getMethodInheritance(new Translator(), source); + MethodInheritanceTreeNode node = index.getMethodInheritance(new Translator(), source); assertThat(node, is(not(nullValue()))); assertThat(node.getMethodEntry(), is(source)); assertThat(node.getChildCount(), is(0)); @@ -87,19 +87,19 @@ public class TestJarIndexLoneClass { @Test public void classImplementations() { - ClassImplementationsTreeNode node = m_index.getClassImplementations(new Translator(), newClass("a")); + ClassImplementationsTreeNode node = index.getClassImplementations(new Translator(), newClass("a")); assertThat(node, is(nullValue())); } @Test public void methodImplementations() { MethodEntry source = newMethod("a", "a", "()Ljava/lang/String;"); - assertThat(m_index.getMethodImplementations(new Translator(), source), is(empty())); + assertThat(index.getMethodImplementations(new Translator(), source), is(empty())); } @Test public void relatedMethodImplementations() { - Set entries = m_index.getRelatedMethodImplementations(newMethod("a", "a", "()Ljava/lang/String;")); + Set entries = index.getRelatedMethodImplementations(newMethod("a", "a", "()Ljava/lang/String;")); assertThat(entries, containsInAnyOrder( newMethod("a", "a", "()Ljava/lang/String;") )); @@ -109,7 +109,7 @@ public class TestJarIndexLoneClass { @SuppressWarnings("unchecked") public void fieldReferences() { FieldEntry source = newField("a", "a", "Ljava/lang/String;"); - Collection> references = m_index.getFieldReferences(source); + Collection> references = index.getFieldReferences(source); assertThat(references, containsInAnyOrder( newFieldReferenceByConstructor(source, "a", "(Ljava/lang/String;)V"), newFieldReferenceByMethod(source, "a", "a", "()Ljava/lang/String;") @@ -118,47 +118,47 @@ public class TestJarIndexLoneClass { @Test public void behaviorReferences() { - assertThat(m_index.getBehaviorReferences(newMethod("a", "a", "()Ljava/lang/String;")), is(empty())); + assertThat(index.getBehaviorReferences(newMethod("a", "a", "()Ljava/lang/String;")), is(empty())); } @Test public void innerClasses() { - assertThat(m_index.getInnerClasses(newClass("a")), is(empty())); + assertThat(index.getInnerClasses(newClass("a")), is(empty())); } @Test public void outerClass() { - assertThat(m_index.getOuterClass(newClass("a")), is(nullValue())); + assertThat(index.getOuterClass(newClass("a")), is(nullValue())); } @Test public void isAnonymousClass() { - assertThat(m_index.isAnonymousClass(newClass("a")), is(false)); + assertThat(index.isAnonymousClass(newClass("a")), is(false)); } @Test public void interfaces() { - assertThat(m_index.getInterfaces("a"), is(empty())); + assertThat(index.getInterfaces("a"), is(empty())); } @Test public void implementingClasses() { - assertThat(m_index.getImplementingClasses("a"), is(empty())); + assertThat(index.getImplementingClasses("a"), is(empty())); } @Test public void isInterface() { - assertThat(m_index.isInterface("a"), is(false)); + assertThat(index.isInterface("a"), is(false)); } @Test public void testContains() { - assertThat(m_index.containsObfClass(newClass("a")), is(true)); - assertThat(m_index.containsObfClass(newClass("b")), is(false)); - assertThat(m_index.containsObfField(newField("a", "a", "Ljava/lang/String;")), is(true)); - assertThat(m_index.containsObfField(newField("a", "b", "Ljava/lang/String;")), is(false)); - assertThat(m_index.containsObfField(newField("a", "a", "LFoo;")), is(false)); - assertThat(m_index.containsObfBehavior(newMethod("a", "a", "()Ljava/lang/String;")), is(true)); - assertThat(m_index.containsObfBehavior(newMethod("a", "b", "()Ljava/lang/String;")), is(false)); + assertThat(index.containsObfClass(newClass("a")), is(true)); + assertThat(index.containsObfClass(newClass("b")), is(false)); + assertThat(index.containsObfField(newField("a", "a", "Ljava/lang/String;")), is(true)); + assertThat(index.containsObfField(newField("a", "b", "Ljava/lang/String;")), is(false)); + assertThat(index.containsObfField(newField("a", "a", "LFoo;")), is(false)); + assertThat(index.containsObfBehavior(newMethod("a", "a", "()Ljava/lang/String;")), is(true)); + assertThat(index.containsObfBehavior(newMethod("a", "b", "()Ljava/lang/String;")), is(false)); } } diff --git a/src/test/java/cuchaz/enigma/TestTranslator.java b/src/test/java/cuchaz/enigma/TestTranslator.java index c8af307..2c54603 100644 --- a/src/test/java/cuchaz/enigma/TestTranslator.java +++ b/src/test/java/cuchaz/enigma/TestTranslator.java @@ -22,21 +22,21 @@ import cuchaz.enigma.mapping.Translator; public class TestTranslator { - private static Deobfuscator m_deobfuscator; - private static Mappings m_mappings; - private static Translator m_deobfTranslator; - private static Translator m_obfTranslator; + private static Deobfuscator deobfuscator; + private static Mappings mappings; + private static Translator deobfTranslator; + private static Translator obfTranslator; @BeforeClass public static void beforeClass() throws Exception { //TODO FIx - //m_deobfuscator = new Deobfuscator(new JarFile("build/test-obf/translation.jar")); + //deobfuscator = new Deobfuscator(new JarFile("build/test-obf/translation.jar")); //try (InputStream in = TestTranslator.class.getResourceAsStream("/cuchaz/enigma/resources/translation.mappings")) { - // m_mappings = new MappingsJsonReader().read(new InputStreamReader(in)); - // m_deobfuscator.setMappings(m_mappings); - // m_deobfTranslator = m_deobfuscator.getTranslator(TranslationDirection.Deobfuscating); - // m_obfTranslator = m_deobfuscator.getTranslator(TranslationDirection.Obfuscating); + // mappings = new MappingsJsonReader().read(new InputStreamReader(in)); + // deobfuscator.setMappings(mappings); + // deobfTranslator = deobfuscator.getTranslator(TranslationDirection.Deobfuscating); + // obfTranslator = deobfuscator.getTranslator(TranslationDirection.Obfuscating); //} } @@ -147,15 +147,15 @@ public class TestTranslator { } private void assertMapping(Entry obf, Entry deobf) { - //assertThat(m_deobfTranslator.translateEntry(obf), is(deobf)); - //assertThat(m_obfTranslator.translateEntry(deobf), is(obf)); + //assertThat(deobfTranslator.translateEntry(obf), is(deobf)); + //assertThat(obfTranslator.translateEntry(deobf), is(obf)); - //String deobfName = m_deobfTranslator.translate(obf); + //String deobfName = deobfTranslator.translate(obf); //if (deobfName != null) { // assertThat(deobfName, is(deobf.getName())); //} - //String obfName = m_obfTranslator.translate(deobf); + //String obfName = obfTranslator.translate(deobf); //if (obfName != null) { // assertThat(obfName, is(obf.getName())); //} diff --git a/src/test/java/cuchaz/enigma/TokenChecker.java b/src/test/java/cuchaz/enigma/TokenChecker.java index 7afb4cf..0746320 100644 --- a/src/test/java/cuchaz/enigma/TokenChecker.java +++ b/src/test/java/cuchaz/enigma/TokenChecker.java @@ -25,20 +25,20 @@ import cuchaz.enigma.mapping.Entry; public class TokenChecker { - private Deobfuscator m_deobfuscator; + private Deobfuscator deobfuscator; protected TokenChecker(JarFile jarFile) throws IOException { - m_deobfuscator = new Deobfuscator(jarFile); + deobfuscator = new Deobfuscator(jarFile); } protected String getDeclarationToken(Entry entry) { // decompile the class - CompilationUnit tree = m_deobfuscator.getSourceTree(entry.getClassName()); + CompilationUnit tree = deobfuscator.getSourceTree(entry.getClassName()); // DEBUG // tree.acceptVisitor( new TreeDumpVisitor( new File( "tree." + entry.getClassName().replace( '/', '.' ) + ".txt" ) ), null ); - String source = m_deobfuscator.getSource(tree); - SourceIndex index = m_deobfuscator.getSourceIndex(tree, source); + String source = deobfuscator.getSource(tree); + SourceIndex index = deobfuscator.getSourceIndex(tree, source); // get the token value Token token = index.getDeclarationToken(entry); @@ -51,9 +51,9 @@ public class TokenChecker { @SuppressWarnings("unchecked") protected Collection getReferenceTokens(EntryReference reference) { // decompile the class - CompilationUnit tree = m_deobfuscator.getSourceTree(reference.context.getClassName()); - String source = m_deobfuscator.getSource(tree); - SourceIndex index = m_deobfuscator.getSourceIndex(tree, source); + CompilationUnit tree = deobfuscator.getSourceTree(reference.context.getClassName()); + String source = deobfuscator.getSource(tree); + SourceIndex index = deobfuscator.getSourceIndex(tree, source); // get the token values List values = Lists.newArrayList(); diff --git a/src/test/java/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java b/src/test/java/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java index d676ba2..1b1f369 100644 --- a/src/test/java/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java +++ b/src/test/java/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java @@ -14,16 +14,16 @@ package cuchaz.enigma.inputs.inheritanceTree; public abstract class BaseClass { // a - private String m_name; + private String name; // (Ljava/lang/String;)V protected BaseClass(String name) { - m_name = name; + this.name = name; } // a()Ljava/lang/String; public String getName() { - return m_name; + return name; } // a()V diff --git a/src/test/java/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java b/src/test/java/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java index 751fdd1..6d3b0d0 100644 --- a/src/test/java/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java +++ b/src/test/java/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java @@ -14,7 +14,7 @@ package cuchaz.enigma.inputs.inheritanceTree; public class SubclassB extends BaseClass { // a - private int m_numThings; + private int numThings; // ()V protected SubclassB() { @@ -22,7 +22,7 @@ public class SubclassB extends BaseClass { super("B"); // access to a - m_numThings = 4; + numThings = 4; } @Override @@ -35,6 +35,6 @@ public class SubclassB extends BaseClass { // b()V public void doBThings() { // access to a - System.out.println("" + m_numThings + " B things!"); + System.out.println("" + numThings + " B things!"); } } diff --git a/src/test/java/cuchaz/enigma/inputs/loneClass/LoneClass.java b/src/test/java/cuchaz/enigma/inputs/loneClass/LoneClass.java index bf264fa..d28ae97 100644 --- a/src/test/java/cuchaz/enigma/inputs/loneClass/LoneClass.java +++ b/src/test/java/cuchaz/enigma/inputs/loneClass/LoneClass.java @@ -12,13 +12,13 @@ package cuchaz.enigma.inputs.loneClass; public class LoneClass { - private String m_name; + private String name; public LoneClass(String name) { - m_name = name; + this.name = name; } public String getName() { - return m_name; + return name; } } diff --git a/src/test/java/cuchaz/enigma/inputs/translation/F_ObjectMethods.java b/src/test/java/cuchaz/enigma/inputs/translation/F_ObjectMethods.java index 32c246c..845d62b 100644 --- a/src/test/java/cuchaz/enigma/inputs/translation/F_ObjectMethods.java +++ b/src/test/java/cuchaz/enigma/inputs/translation/F_ObjectMethods.java @@ -10,6 +10,7 @@ ******************************************************************************/ package cuchaz.enigma.inputs.translation; +@SuppressWarnings("FinalizeCalledExplicitly") public class F_ObjectMethods { public void callEmAll() -- cgit v1.2.3