From 59e189bef2b5e6d129fb7c2c988ed0b2130e36ac Mon Sep 17 00:00:00 2001 From: lclc98 Date: Mon, 4 Jul 2016 18:14:22 +1000 Subject: Reformat --- src/main/java/cuchaz/enigma/Deobfuscator.java | 120 +++++++++++++------------- 1 file changed, 58 insertions(+), 62 deletions(-) (limited to 'src/main/java/cuchaz/enigma/Deobfuscator.java') diff --git a/src/main/java/cuchaz/enigma/Deobfuscator.java b/src/main/java/cuchaz/enigma/Deobfuscator.java index f917deb..d22260f 100644 --- a/src/main/java/cuchaz/enigma/Deobfuscator.java +++ b/src/main/java/cuchaz/enigma/Deobfuscator.java @@ -47,50 +47,46 @@ public class Deobfuscator { void onProgress(int numDone, String message); } - private JarFile m_jar; - private DecompilerSettings m_settings; - private JarIndex m_jarIndex; - private Mappings m_mappings; - private MappingsRenamer m_renamer; - private Map m_translatorCache; + private JarFile jar; + private DecompilerSettings settings; + private JarIndex jarIndex; + private Mappings mappings; + private MappingsRenamer renamer; + private Map translatorCache; - public Deobfuscator(JarFile jar) throws IOException { - m_jar = jar; + public Deobfuscator(JarFile jar) { + this.jar = jar; // build the jar index - m_jarIndex = new JarIndex(); - m_jarIndex.indexJar(m_jar, true); + this.jarIndex = new JarIndex(); + this.jarIndex.indexJar(this.jar, true); // config the decompiler - m_settings = DecompilerSettings.javaDefaults(); - m_settings.setMergeVariables(true); - m_settings.setForceExplicitImports(true); - m_settings.setForceExplicitTypeArguments(true); - m_settings.setShowDebugLineNumbers(true); + this.settings = DecompilerSettings.javaDefaults(); + this.settings.setMergeVariables(true); + this.settings.setForceExplicitImports(true); + this.settings.setForceExplicitTypeArguments(true); + this.settings.setShowDebugLineNumbers(true); // DEBUG - //m_settings.setShowSyntheticMembers(true); + //this.settings.setShowSyntheticMembers(true); // init defaults - m_translatorCache = Maps.newTreeMap(); + this.translatorCache = Maps.newTreeMap(); // init mappings setMappings(new Mappings()); } - public JarFile getJar() { - return m_jar; - } - public String getJarName() { - return m_jar.getName(); + return this.jar.getName(); } public JarIndex getJarIndex() { - return m_jarIndex; + return this.jarIndex; } public Mappings getMappings() { - return m_mappings; + return this.mappings; } public void setMappings(Mappings val) { @@ -103,7 +99,7 @@ public class Deobfuscator { } // drop mappings that don't match the jar - MappingsChecker checker = new MappingsChecker(m_jarIndex); + MappingsChecker checker = new MappingsChecker(this.jarIndex); checker.dropBrokenMappings(val); if (warnAboutDrops) { for (java.util.Map.Entry mapping : checker.getDroppedClassMappings().entrySet()) { @@ -120,22 +116,22 @@ public class Deobfuscator { } } - m_mappings = val; - m_renamer = new MappingsRenamer(m_jarIndex, val); - m_translatorCache.clear(); + this.mappings = val; + this.renamer = new MappingsRenamer(this.jarIndex, val); + this.translatorCache.clear(); } public Translator getTranslator(TranslationDirection direction) { - Translator translator = m_translatorCache.get(direction); + Translator translator = this.translatorCache.get(direction); if (translator == null) { - translator = m_mappings.getTranslator(direction, m_jarIndex.getTranslationIndex()); - m_translatorCache.put(direction, translator); + translator = this.mappings.getTranslator(direction, this.jarIndex.getTranslationIndex()); + this.translatorCache.put(direction, translator); } return translator; } public void getSeparatedClasses(List obfClasses, List deobfClasses) { - for (ClassEntry obfClassEntry : m_jarIndex.getObfClassEntries()) { + for (ClassEntry obfClassEntry : this.jarIndex.getObfClassEntries()) { // skip inner classes if (obfClassEntry.isInnerClass()) { continue; @@ -166,19 +162,19 @@ public class Deobfuscator { String deobfClassName = className; // if it wasn't actually deobf, then we can find a mapping for it and get the deobf name - ClassMapping classMapping = m_mappings.getClassByObf(className); + ClassMapping classMapping = this.mappings.getClassByObf(className); if (classMapping != null && classMapping.getDeobfName() != null) { deobfClassName = classMapping.getDeobfName(); } // set the type loader TranslatingTypeLoader loader = new TranslatingTypeLoader( - m_jar, - m_jarIndex, + this.jar, + this.jarIndex, getTranslator(TranslationDirection.Obfuscating), getTranslator(TranslationDirection.Deobfuscating) ); - m_settings.setTypeLoader(loader); + this.settings.setTypeLoader(loader); // see if procyon can find the type TypeReference type = new MetadataSystem(loader).lookupType(deobfClassName); @@ -192,7 +188,7 @@ public class Deobfuscator { // decompile it! DecompilerContext context = new DecompilerContext(); context.setCurrentType(resolvedType); - context.setSettings(m_settings); + context.setSettings(this.settings); AstBuilder builder = new AstBuilder(context); builder.addType(resolvedType); builder.runTransformations(null); @@ -225,7 +221,7 @@ public class Deobfuscator { Entry obfEntry = obfuscateEntry(deobfReference.entry); // try to resolve the class - ClassEntry resolvedObfClassEntry = m_jarIndex.getTranslationIndex().resolveEntryClass(obfEntry); + ClassEntry resolvedObfClassEntry = this.jarIndex.getTranslationIndex().resolveEntryClass(obfEntry); if (resolvedObfClassEntry != null && !resolvedObfClassEntry.equals(obfEntry.getClassEntry())) { // change the class of the entry obfEntry = obfEntry.cloneToNewClass(resolvedObfClassEntry); @@ -246,14 +242,14 @@ public class Deobfuscator { // render the AST into source StringWriter buf = new StringWriter(); sourceTree.acceptVisitor(new InsertParenthesesVisitor(), null); - sourceTree.acceptVisitor(new JavaOutputVisitor(new PlainTextOutput(buf), m_settings), null); + sourceTree.acceptVisitor(new JavaOutputVisitor(new PlainTextOutput(buf), this.settings), null); return buf.toString(); } - public void writeSources(File dirOut, ProgressListener progress) throws IOException { + public void writeSources(File dirOut, ProgressListener progress) { // get the classes to decompile Set classEntries = Sets.newHashSet(); - for (ClassEntry obfClassEntry : m_jarIndex.getObfClassEntries()) { + for (ClassEntry obfClassEntry : this.jarIndex.getObfClassEntries()) { // skip inner classes if (obfClassEntry.isInnerClass()) { continue; @@ -298,8 +294,8 @@ public class Deobfuscator { public void writeJar(File out, ProgressListener progress) { final TranslatingTypeLoader loader = new TranslatingTypeLoader( - m_jar, - m_jarIndex, + this.jar, + this.jarIndex, getTranslator(TranslationDirection.Obfuscating), getTranslator(TranslationDirection.Deobfuscating) ); @@ -321,11 +317,11 @@ public class Deobfuscator { private void transformJar(File out, ProgressListener progress, ClassTransformer transformer) { try (JarOutputStream outJar = new JarOutputStream(new FileOutputStream(out))) { if (progress != null) { - progress.init(JarClassIterator.getClassEntries(m_jar).size(), "Transforming classes..."); + progress.init(JarClassIterator.getClassEntries(this.jar).size(), "Transforming classes..."); } int i = 0; - for (CtClass c : JarClassIterator.classes(m_jar)) { + for (CtClass c : JarClassIterator.classes(this.jar)) { if (progress != null) { progress.onProgress(i++, c.getName()); } @@ -410,7 +406,7 @@ public class Deobfuscator { } } - return m_jarIndex.containsObfEntry(obfEntry); + return this.jarIndex.containsObfEntry(obfEntry); } public boolean isRenameable(EntryReference obfReference) { @@ -423,7 +419,7 @@ public class Deobfuscator { Translator translator = getTranslator(TranslationDirection.Deobfuscating); if (obfEntry instanceof ClassEntry) { ClassEntry obfClass = (ClassEntry) obfEntry; - List mappingChain = m_mappings.getClassMappingChain(obfClass); + List mappingChain = this.mappings.getClassMappingChain(obfClass); ClassMapping classMapping = mappingChain.get(mappingChain.size() - 1); return classMapping != null && classMapping.getDeobfName() != null; } else if (obfEntry instanceof FieldEntry) { @@ -442,58 +438,58 @@ public class Deobfuscator { public void rename(Entry obfEntry, String newName) { if (obfEntry instanceof ClassEntry) { - m_renamer.setClassName((ClassEntry) obfEntry, Descriptor.toJvmName(newName)); + this.renamer.setClassName((ClassEntry) obfEntry, Descriptor.toJvmName(newName)); } else if (obfEntry instanceof FieldEntry) { - m_renamer.setFieldName((FieldEntry) obfEntry, newName); + this.renamer.setFieldName((FieldEntry) obfEntry, newName); } else if (obfEntry instanceof MethodEntry) { - m_renamer.setMethodTreeName((MethodEntry) obfEntry, newName); + this.renamer.setMethodTreeName((MethodEntry) obfEntry, newName); } else if (obfEntry instanceof ConstructorEntry) { throw new IllegalArgumentException("Cannot rename constructors"); } else if (obfEntry instanceof ArgumentEntry) { - m_renamer.setArgumentName((ArgumentEntry) obfEntry, newName); + this.renamer.setArgumentName((ArgumentEntry) obfEntry, newName); } else { throw new Error("Unknown entry type: " + obfEntry.getClass().getName()); } // clear caches - m_translatorCache.clear(); + this.translatorCache.clear(); } public void removeMapping(Entry obfEntry) { if (obfEntry instanceof ClassEntry) { - m_renamer.removeClassMapping((ClassEntry) obfEntry); + this.renamer.removeClassMapping((ClassEntry) obfEntry); } else if (obfEntry instanceof FieldEntry) { - m_renamer.removeFieldMapping((FieldEntry) obfEntry); + this.renamer.removeFieldMapping((FieldEntry) obfEntry); } else if (obfEntry instanceof MethodEntry) { - m_renamer.removeMethodTreeMapping((MethodEntry) obfEntry); + this.renamer.removeMethodTreeMapping((MethodEntry) obfEntry); } else if (obfEntry instanceof ConstructorEntry) { throw new IllegalArgumentException("Cannot rename constructors"); } else if (obfEntry instanceof ArgumentEntry) { - m_renamer.removeArgumentMapping((ArgumentEntry) obfEntry); + this.renamer.removeArgumentMapping((ArgumentEntry) obfEntry); } else { throw new Error("Unknown entry type: " + obfEntry); } // clear caches - m_translatorCache.clear(); + this.translatorCache.clear(); } public void markAsDeobfuscated(Entry obfEntry) { if (obfEntry instanceof ClassEntry) { - m_renamer.markClassAsDeobfuscated((ClassEntry) obfEntry); + this.renamer.markClassAsDeobfuscated((ClassEntry) obfEntry); } else if (obfEntry instanceof FieldEntry) { - m_renamer.markFieldAsDeobfuscated((FieldEntry) obfEntry); + this.renamer.markFieldAsDeobfuscated((FieldEntry) obfEntry); } else if (obfEntry instanceof MethodEntry) { - m_renamer.markMethodTreeAsDeobfuscated((MethodEntry) obfEntry); + this.renamer.markMethodTreeAsDeobfuscated((MethodEntry) obfEntry); } else if (obfEntry instanceof ConstructorEntry) { throw new IllegalArgumentException("Cannot rename constructors"); } else if (obfEntry instanceof ArgumentEntry) { - m_renamer.markArgumentAsDeobfuscated((ArgumentEntry) obfEntry); + this.renamer.markArgumentAsDeobfuscated((ArgumentEntry) obfEntry); } else { throw new Error("Unknown entry type: " + obfEntry); } // clear caches - m_translatorCache.clear(); + this.translatorCache.clear(); } } -- cgit v1.2.3