fixed nasty issue with renaming inner classes, but alas, more bugs remain

3 files changed, 22 insertions, 35 deletions

diff --git a/src/cuchaz/enigma/bytecode/ClassRenamer.java b/src/cuchaz/enigma/bytecode/ClassRenamer.java
index 9f0845d..849a323 100644
--- a/src/cuchaz/enigma/bytecode/ClassRenamer.java
+++ b/src/cuchaz/enigma/bytecode/ClassRenamer.java
@@ -37,34 +37,25 @@ public class ClassRenamer
                 {
                         nameMap.put( entry.getKey().getName(), entry.getValue().getName() );
                 }
+                
                 c.replaceClassName( nameMap );
                 
-                // translate the names in the InnerClasses attribute
+                // replace simple names in the InnerClasses attribute too
                 ConstPool constants = c.getClassFile().getConstPool();
                 InnerClassesAttribute attr = (InnerClassesAttribute)c.getClassFile().getAttribute( InnerClassesAttribute.tag );
                 if( attr != null )
                 {
                         for( int i=0; i<attr.tableLength(); i++ )
                         {
-                                ClassEntry inClassEntry = new ClassEntry( Descriptor.toJvmName( attr.innerClass( i ) ) );
-                                ClassEntry outClassEntry = map.get( inClassEntry );
-                                if( outClassEntry == null )
-                                {
-                                        continue;
-                                }
-                                attr.setInnerClassIndex( i, constants.addClassInfo( outClassEntry.getName() ) );
-                                if( attr.outerClassIndex( i ) != 0 )
-                                {
-                                        attr.setOuterClassIndex( i, constants.addClassInfo( outClassEntry.getOuterClassName() ) );
-                                }
+                                ClassEntry classEntry = new ClassEntry( Descriptor.toJvmName( attr.innerClass( i ) ) );
                                 if( attr.innerNameIndex( i ) != 0 )
                                 {
-                                        attr.setInnerNameIndex( i, constants.addUtf8Info( outClassEntry.getInnerClassName() ) );
+                                        attr.setInnerNameIndex( i, constants.addUtf8Info( classEntry.getInnerClassName() ) );
                                 }
                                 
                                 /* DEBUG
-                                System.out.println( String.format( "\tOBF: %s DEOBF: %s-> ATTR: %s,%s,%s",
-                                        obfClassEntry, deobfClassEntry,
+                                System.out.println( String.format( "\tDEOBF: %s-> ATTR: %s,%s,%s",
+                                        classEntry,
                                         attr.outerClass( i ),
                                         attr.innerClass( i ),
                                         attr.innerName( i )
@@ -109,16 +100,6 @@ public class ClassRenamer
                 };
                 c.replaceClassName( map );
                 
-                // also check InnerClassesAttribute
-                InnerClassesAttribute attr = (InnerClassesAttribute)c.getClassFile().getAttribute( InnerClassesAttribute.tag );
-                if( attr != null )
-                {
-                        for( int i=0; i<attr.tableLength(); i++ )
-                        {
-                                entries.add( new ClassEntry( Descriptor.toJvmName( attr.innerClass( i ) ) ) );
-                        }
-                }
-                
                 return entries;
         }
         
diff --git a/src/cuchaz/enigma/bytecode/ClassTranslator.java b/src/cuchaz/enigma/bytecode/ClassTranslator.java
index db28f21..181fadb 100644
--- a/src/cuchaz/enigma/bytecode/ClassTranslator.java
+++ b/src/cuchaz/enigma/bytecode/ClassTranslator.java
@@ -132,7 +132,11 @@ public class ClassTranslator
                 Map<ClassEntry,ClassEntry> map = Maps.newHashMap();
                 for( ClassEntry obfClassEntry : ClassRenamer.getAllClassEntries( c ) )
                 {
-                        map.put( obfClassEntry, m_translator.translateEntry( obfClassEntry ) );
+                        ClassEntry deobfClassEntry = m_translator.translateEntry( obfClassEntry );
+                        if( !obfClassEntry.equals( deobfClassEntry ) )
+                        {
+                                map.put( obfClassEntry, deobfClassEntry );
+                        }
                 }
                 ClassRenamer.renameClasses( c, map );
         }
diff --git a/src/cuchaz/enigma/bytecode/InnerClassWriter.java b/src/cuchaz/enigma/bytecode/InnerClassWriter.java
index a061792..5e59307 100644
--- a/src/cuchaz/enigma/bytecode/InnerClassWriter.java
+++ b/src/cuchaz/enigma/bytecode/InnerClassWriter.java
@@ -18,6 +18,7 @@ import javassist.bytecode.ConstPool;
 import javassist.bytecode.Descriptor;
 import javassist.bytecode.EnclosingMethodAttribute;
 import javassist.bytecode.InnerClassesAttribute;
+import cuchaz.enigma.Constants;
 import cuchaz.enigma.analysis.JarIndex;
 import cuchaz.enigma.mapping.BehaviorEntry;
 import cuchaz.enigma.mapping.ClassEntry;
@@ -33,21 +34,21 @@ public class InnerClassWriter
         
         public void write( CtClass c )
         {
-                // get the outer class name
-                String obfClassName = Descriptor.toJvmName( c.getName() );
-                String obfOuterClassName = m_jarIndex.getOuterClass( obfClassName );
+                // is this an inner or outer class?
+                String obfInnerClassName = new ClassEntry( Descriptor.toJvmName( c.getName() ) ).getSimpleName();
+                String obfOuterClassName = m_jarIndex.getOuterClass( obfInnerClassName );
                 if( obfOuterClassName == null )
                 {
                         // this is an outer class
-                        obfOuterClassName = obfClassName;
+                        obfOuterClassName = Descriptor.toJvmName( c.getName() );
                 }
                 else
                 {
                         // this is an inner class, rename it to outer$inner
-                        ClassEntry obfClassEntry = new ClassEntry( obfOuterClassName + "$" + new ClassEntry( obfClassName ).getSimpleName() );
+                        ClassEntry obfClassEntry = new ClassEntry( obfOuterClassName + "$" + obfInnerClassName );
                         c.setName( obfClassEntry.getName() );
                         
-                        BehaviorEntry caller = m_jarIndex.getAnonymousClassCaller( obfClassName );
+                        BehaviorEntry caller = m_jarIndex.getAnonymousClassCaller( obfInnerClassName );
                         if( caller != null )
                         {
                                 // write the enclosing method attribute
@@ -85,7 +86,7 @@ public class InnerClassWriter
                 for( String obfInnerClassName : obfInnerClassNames )
                 {
                         // get the new inner class name
-                        ClassEntry obfClassEntry = new ClassEntry( obfOuterClassName + "$" + new ClassEntry( obfInnerClassName ).getSimpleName() );
+                        ClassEntry obfClassEntry = new ClassEntry( obfOuterClassName + "$" + obfInnerClassName );
                         
                         // here's what the JVM spec says about the InnerClasses attribute
                         // append( inner, outer of inner if inner is member of outer 0 ow, name after $ if inner not anonymous 0 ow, flags ); 
@@ -114,12 +115,13 @@ public class InnerClassWriter
                                 attr.outerClass( attr.tableLength() - 1 ),
                                 attr.innerClass( attr.tableLength() - 1 ),
                                 attr.innerName( attr.tableLength() - 1 ),
-                                obfInnerClassName, obfClassEntry.getName()
+                                Constants.NonePackage + "/" + obfInnerClassName,
+                                obfClassEntry.getName()
                         ) );
                         */
                         
                         // make sure the outer class references only the new inner class names
-                        c.replaceClassName( obfInnerClassName, obfClassEntry.getName() );
+                        c.replaceClassName( Constants.NonePackage + "/" + obfInnerClassName, obfClassEntry.getName() );
                 }
         }
 }