finished reference navigation system. Still need to debug and polish it, but the basic idea seems to work. =)

1 files changed, 50 insertions, 55 deletions

diff --git a/src/cuchaz/enigma/Deobfuscator.java b/src/cuchaz/enigma/Deobfuscator.java
index 293e1c2..34e6033 100644
--- a/src/cuchaz/enigma/Deobfuscator.java
+++ b/src/cuchaz/enigma/Deobfuscator.java
@@ -26,6 +26,7 @@ import com.strobel.decompiler.languages.java.ast.AstBuilder;
 import com.strobel.decompiler.languages.java.ast.CompilationUnit;
 import com.strobel.decompiler.languages.java.ast.InsertParenthesesVisitor;
 
+import cuchaz.enigma.analysis.EntryReference;
 import cuchaz.enigma.analysis.JarIndex;
 import cuchaz.enigma.analysis.SourceIndex;
 import cuchaz.enigma.analysis.SourceIndexVisitor;
@@ -169,98 +170,92 @@ public class Deobfuscator
                 SourceIndex index = new SourceIndex( buf.toString() );
                 root.acceptVisitor( new SourceIndexVisitor(), index );
                 
-                return index;
-        }
-        
-        // NOTE: these methods are a bit messy... oh well
-
-        public void rename( Entry obfEntry, String newName )
-        {
-                if( obfEntry instanceof ClassEntry )
+                /* DEBUG
+                for( Token token : index.referenceTokens() )
                 {
-                        m_renamer.setClassName( (ClassEntry)obfEntry, newName );
-                }
-                else if( obfEntry instanceof FieldEntry )
-                {
-                        m_renamer.setFieldName( (FieldEntry)obfEntry, newName );
-                }
-                else if( obfEntry instanceof MethodEntry )
-                {
-                        m_renamer.setMethodTreeName( (MethodEntry)obfEntry, newName );
-                }
-                else if( obfEntry instanceof ConstructorEntry )
-                {
-                        m_renamer.setClassName( obfEntry.getClassEntry(), newName );
-                }
-                else if( obfEntry instanceof ArgumentEntry )
-                {
-                        m_renamer.setArgumentName( (ArgumentEntry)obfEntry, newName );
-                }
-                else
-                {
-                        throw new Error( "Unknown entry type: " + obfEntry.getClass().getName() );
+                        EntryReference<Entry,Entry> reference = index.getDeobfReference( token );
+                        System.out.println( token + " -> " + reference + " -> " + index.getReferenceToken( reference ) );
                 }
+                */
                 
-                // clear the type loader cache
-                m_typeLoader.clearCache();
+                return index;
         }
         
         public Entry obfuscateEntry( Entry deobfEntry )
         {
-                Translator translator = getTranslator( TranslationDirection.Obfuscating );
-                if( deobfEntry instanceof ClassEntry )
-                {
-                        return translator.translateEntry( (ClassEntry)deobfEntry );
-                }
-                else if( deobfEntry instanceof FieldEntry )
-                {
-                        return translator.translateEntry( (FieldEntry)deobfEntry );
-                }
-                else if( deobfEntry instanceof MethodEntry )
+                if( deobfEntry == null )
                 {
-                        return translator.translateEntry( (MethodEntry)deobfEntry );
+                        return null;
                 }
-                else if( deobfEntry instanceof ConstructorEntry )
+                return getTranslator( TranslationDirection.Obfuscating ).translateEntry( deobfEntry );
+        }
+        
+        public Entry deobfuscateEntry( Entry obfEntry )
+        {
+                if( obfEntry == null )
                 {
-                        return translator.translateEntry( (ConstructorEntry)deobfEntry );
+                        return null;
                 }
-                else if( deobfEntry instanceof ArgumentEntry )
+                return getTranslator( TranslationDirection.Deobfuscating ).translateEntry( obfEntry );
+        }
+        
+        public EntryReference<Entry,Entry> obfuscateReference( EntryReference<Entry,Entry> deobfReference )
+        {
+                if( deobfReference == null )
                 {
-                        return translator.translateEntry( (ArgumentEntry)deobfEntry );
+                        return null;
                 }
-                else
+                return new EntryReference<Entry,Entry>(
+                        obfuscateEntry( deobfReference.entry ),
+                        obfuscateEntry( deobfReference.context ),
+                        deobfReference.pos
+                );
+        }
+        
+        public EntryReference<Entry,Entry> deobfuscateReference( EntryReference<Entry,Entry> obfReference )
+        {
+                if( obfReference == null )
                 {
-                        throw new Error( "Unknown entry type: " + deobfEntry.getClass().getName() );
+                        return null;
                 }
+                return new EntryReference<Entry,Entry>(
+                        deobfuscateEntry( obfReference.entry ),
+                        deobfuscateEntry( obfReference.context ),
+                        obfReference.pos
+                );
         }
         
-        public Entry deobfuscateEntry( Entry obfEntry )
+        // NOTE: these methods are a bit messy... oh well
+
+        public void rename( Entry obfEntry, String newName )
         {
-                Translator translator = getTranslator( TranslationDirection.Deobfuscating );
                 if( obfEntry instanceof ClassEntry )
                 {
-                        return translator.translateEntry( (ClassEntry)obfEntry );
+                        m_renamer.setClassName( (ClassEntry)obfEntry, newName );
                 }
                 else if( obfEntry instanceof FieldEntry )
                 {
-                        return translator.translateEntry( (FieldEntry)obfEntry );
+                        m_renamer.setFieldName( (FieldEntry)obfEntry, newName );
                 }
                 else if( obfEntry instanceof MethodEntry )
                 {
-                        return translator.translateEntry( (MethodEntry)obfEntry );
+                        m_renamer.setMethodTreeName( (MethodEntry)obfEntry, newName );
                 }
                 else if( obfEntry instanceof ConstructorEntry )
                 {
-                        return translator.translateEntry( (ConstructorEntry)obfEntry );
+                        m_renamer.setClassName( obfEntry.getClassEntry(), newName );
                 }
                 else if( obfEntry instanceof ArgumentEntry )
                 {
-                        return translator.translateEntry( (ArgumentEntry)obfEntry );
+                        m_renamer.setArgumentName( (ArgumentEntry)obfEntry, newName );
                 }
                 else
                 {
                         throw new Error( "Unknown entry type: " + obfEntry.getClass().getName() );
                 }
+                
+                // clear the type loader cache
+                m_typeLoader.clearCache();
         }
         
         public boolean hasMapping( Entry obfEntry )