added identifier renaming capability

copied some code over from M3L to handle the heavy bytecode magic.
It's ok... M3L will eventually depend on Enigma.
Completely restructured the mappings though. This way is better. =)

1 files changed, 113 insertions, 2 deletions

diff --git a/src/cuchaz/enigma/Deobfuscator.java b/src/cuchaz/enigma/Deobfuscator.java
index 97c5750..b1abd9e 100644
--- a/src/cuchaz/enigma/Deobfuscator.java
+++ b/src/cuchaz/enigma/Deobfuscator.java
@@ -11,7 +11,9 @@
 package cuchaz.enigma;
 
 import java.io.File;
+import java.io.FileInputStream;
 import java.io.IOException;
+import java.io.InputStream;
 import java.io.StringWriter;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -21,16 +23,27 @@ import java.util.List;
 import java.util.jar.JarEntry;
 import java.util.jar.JarFile;
 
-import com.strobel.assembler.metadata.JarTypeLoader;
 import com.strobel.decompiler.Decompiler;
 import com.strobel.decompiler.DecompilerSettings;
 import com.strobel.decompiler.PlainTextOutput;
 
+import cuchaz.enigma.mapping.Ancestries;
+import cuchaz.enigma.mapping.ArgumentEntry;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.Entry;
+import cuchaz.enigma.mapping.FieldEntry;
+import cuchaz.enigma.mapping.MethodEntry;
+import cuchaz.enigma.mapping.TranslationDirection;
+import cuchaz.enigma.mapping.TranslationMappings;
+import cuchaz.enigma.mapping.Translator;
+
 public class Deobfuscator
 {
         private File m_file;
         private JarFile m_jar;
         private DecompilerSettings m_settings;
+        private Ancestries m_ancestries;
+        private TranslationMappings m_mappings;
         
         private static Comparator<ClassFile> m_obfuscatedClassSorter;
         
@@ -56,8 +69,30 @@ public class Deobfuscator
         {
                 m_file = file;
                 m_jar = new JarFile( m_file );
+                
+                // build the ancestries
+                InputStream jarIn = null;
+                try
+                {
+                        m_ancestries = new Ancestries();
+                        jarIn = new FileInputStream( m_file );
+                        m_ancestries.readFromJar( jarIn );
+                }
+                finally
+                {
+                        Util.closeQuietly( jarIn );
+                }
+                
+                // init mappings
+                m_mappings = new TranslationMappings( m_ancestries );
+                
+                // config the decompiler
                 m_settings = DecompilerSettings.javaDefaults();
-                m_settings.setTypeLoader( new JarTypeLoader( m_jar ) );
+                m_settings.setTypeLoader( new TranslatingTypeLoader(
+                        m_jar,
+                        m_mappings.getTranslator( TranslationDirection.Deobfuscating ),
+                        m_mappings.getTranslator( TranslationDirection.Obfuscating )
+                ) );
                 m_settings.setForceExplicitImports( true );
                 m_settings.setShowSyntheticMembers( true );
         }
@@ -111,4 +146,80 @@ public class Deobfuscator
                 Decompiler.decompile( classFile.getName(), new PlainTextOutput( buf ), m_settings );
                 return buf.toString();
         }
+        
+        // NOTE: these methods are a bit messy... oh well
+
+        public void rename( Entry entry, String newName )
+        {
+                if( entry instanceof ClassEntry )
+                {
+                        m_mappings.setClassName( (ClassEntry)entry, newName );
+                }
+                else if( entry instanceof FieldEntry )
+                {
+                        m_mappings.setFieldName( (FieldEntry)entry, newName );
+                }
+                else if( entry instanceof MethodEntry )
+                {
+                        m_mappings.setMethodName( (MethodEntry)entry, newName );
+                }
+                else if( entry instanceof ArgumentEntry )
+                {
+                        m_mappings.setArgumentName( (ArgumentEntry)entry, newName );
+                }
+                else
+                {
+                        throw new Error( "Unknown entry type: " + entry.getClass().getName() );
+                }
+        }
+        
+        public Entry obfuscate( Entry in )
+        {
+                Translator translator = m_mappings.getTranslator( TranslationDirection.Obfuscating );
+                if( in instanceof ClassEntry )
+                {
+                        return translator.translateEntry( (ClassEntry)in );
+                }
+                else if( in instanceof FieldEntry )
+                {
+                        return translator.translateEntry( (FieldEntry)in );
+                }
+                else if( in instanceof MethodEntry )
+                {
+                        return translator.translateEntry( (MethodEntry)in );
+                }
+                else if( in instanceof ArgumentEntry )
+                {
+                        return translator.translateEntry( (ArgumentEntry)in );
+                }
+                else
+                {
+                        throw new Error( "Unknown entry type: " + in.getClass().getName() );
+                }
+        }
+        
+        public Entry deobfuscate( Entry in )
+        {
+                Translator translator = m_mappings.getTranslator( TranslationDirection.Deobfuscating );
+                if( in instanceof ClassEntry )
+                {
+                        return translator.translateEntry( (ClassEntry)in );
+                }
+                else if( in instanceof FieldEntry )
+                {
+                        return translator.translateEntry( (FieldEntry)in );
+                }
+                else if( in instanceof MethodEntry )
+                {
+                        return translator.translateEntry( (MethodEntry)in );
+                }
+                else if( in instanceof ArgumentEntry )
+                {
+                        return translator.translateEntry( (ArgumentEntry)in );
+                }
+                else
+                {
+                        throw new Error( "Unknown entry type: " + in.getClass().getName() );
+                }
+        }
 }