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

5 files changed, 59 insertions, 29 deletions

diff --git a/src/cuchaz/enigma/mapping/ClassMapping.java b/src/cuchaz/enigma/mapping/ClassMapping.java
index 88106df..ee02781 100644
--- a/src/cuchaz/enigma/mapping/ClassMapping.java
+++ b/src/cuchaz/enigma/mapping/ClassMapping.java
@@ -37,7 +37,7 @@ public class ClassMapping implements Serializable, Comparable<ClassMapping>
         public ClassMapping( String obfName, String deobfName )
         {
                 m_obfName = obfName;
-                m_deobfName = NameValidator.validateClassName( deobfName );
+                m_deobfName = NameValidator.validateClassName( deobfName, false );
                 m_innerClassesByObf = Maps.newHashMap();
                 m_innerClassesByDeobf = Maps.newHashMap();
                 m_fieldsByObf = Maps.newHashMap();
@@ -57,7 +57,7 @@ public class ClassMapping implements Serializable, Comparable<ClassMapping>
         }
         public void setDeobfName( String val )
         {
-                m_deobfName = NameValidator.validateClassName( val );
+                m_deobfName = NameValidator.validateClassName( val, false );
         }
         
         //// INNER CLASSES ////////
@@ -70,10 +70,12 @@ public class ClassMapping implements Serializable, Comparable<ClassMapping>
         
         public void addInnerClassMapping( ClassMapping classMapping )
         {
+                assert( isSimpleClassName( classMapping.getObfName() ) );
                 boolean obfWasAdded = m_innerClassesByObf.put( classMapping.getObfName(), classMapping ) == null;
                 assert( obfWasAdded );
                 if( classMapping.getDeobfName() != null )
                 {
+                        assert( isSimpleClassName( classMapping.getDeobfName() ) );
                         boolean deobfWasAdded = m_innerClassesByDeobf.put( classMapping.getDeobfName(), classMapping ) == null;
                         assert( deobfWasAdded );
                 }
@@ -92,6 +94,7 @@ public class ClassMapping implements Serializable, Comparable<ClassMapping>
         
         public ClassMapping getOrCreateInnerClass( String obfName )
         {
+                assert( isSimpleClassName( obfName ) );
                 ClassMapping classMapping = m_innerClassesByObf.get( obfName );
                 if( classMapping == null )
                 {
@@ -104,16 +107,19 @@ public class ClassMapping implements Serializable, Comparable<ClassMapping>
         
         public ClassMapping getInnerClassByObf( String obfName )
         {
+                assert( isSimpleClassName( obfName ) );
                 return m_innerClassesByObf.get( obfName );
         }
         
         public ClassMapping getInnerClassByDeobf( String deobfName )
         {
+                assert( isSimpleClassName( deobfName ) );
                 return m_innerClassesByDeobf.get( deobfName );
         }
         
         public String getObfInnerClassName( String deobfName )
         {
+                assert( isSimpleClassName( deobfName ) );
                 ClassMapping classMapping = m_innerClassesByDeobf.get( deobfName );
                 if( classMapping != null )
                 {
@@ -124,6 +130,7 @@ public class ClassMapping implements Serializable, Comparable<ClassMapping>
         
         public String getDeobfInnerClassName( String obfName )
         {
+                assert( isSimpleClassName( obfName ) );
                 ClassMapping classMapping = m_innerClassesByObf.get( obfName );
                 if( classMapping != null )
                 {
@@ -134,6 +141,7 @@ public class ClassMapping implements Serializable, Comparable<ClassMapping>
         
         public void setInnerClassName( String obfName, String deobfName )
         {
+                assert( isSimpleClassName( obfName ) );
                 ClassMapping classMapping = getOrCreateInnerClass( obfName );
                 if( classMapping.getDeobfName() != null )
                 {
@@ -143,6 +151,7 @@ public class ClassMapping implements Serializable, Comparable<ClassMapping>
                 classMapping.setDeobfName( deobfName );
                 if( deobfName != null )
                 {
+                        assert( isSimpleClassName( deobfName ) );
                         boolean wasAdded = m_innerClassesByDeobf.put( deobfName, classMapping ) == null;
                         assert( wasAdded );
                 }
@@ -442,4 +451,9 @@ public class ClassMapping implements Serializable, Comparable<ClassMapping>
                 }
                 return false;
         }
+        
+        public static boolean isSimpleClassName( String name )
+        {
+                return name.indexOf( '/' ) < 0 && name.indexOf( '$' ) < 0;
+        }
 }
diff --git a/src/cuchaz/enigma/mapping/MappingsReader.java b/src/cuchaz/enigma/mapping/MappingsReader.java
index 5cbad59..4bd9f12 100644
--- a/src/cuchaz/enigma/mapping/MappingsReader.java
+++ b/src/cuchaz/enigma/mapping/MappingsReader.java
@@ -78,10 +78,11 @@ public class MappingsReader
                                 
                                 if( token.equalsIgnoreCase( "CLASS" ) )
                                 {
-                                        ClassMapping classMapping = readClass( parts );
+                                        ClassMapping classMapping;
                                         if( indent == 0 )
                                         {
                                                 // outer class
+                                                classMapping = readClass( parts, false );
                                                 mappings.addClassMapping( classMapping );
                                         }
                                         else if( indent == 1 )
@@ -91,11 +92,13 @@ public class MappingsReader
                                                 {
                                                         throw new MappingParseException( lineNumber, "Unexpected CLASS entry here!" );
                                                 }
+                                                
+                                                classMapping = readClass( parts, true );
                                                 ((ClassMapping)mappingStack.getFirst()).addInnerClassMapping( classMapping );
                                         }
                                         else
                                         {
-                                                throw new MappingParseException( lineNumber, "Unexpected CLASS entry here!" );
+                                                throw new MappingParseException( lineNumber, "Unexpected CLASS entry nesting!" );
                                         }
                                         mappingStack.push( classMapping );
                                 }
@@ -140,28 +143,30 @@ public class MappingsReader
                 return new ArgumentMapping( Integer.parseInt( parts[1] ), parts[2] );
         }
 
-        private ClassMapping readClass( String[] parts )
+        private ClassMapping readClass( String[] parts, boolean makeSimple )
         {
                 if( parts.length == 2 )
                 {
-                        String obfName = parts[1];
-                        return new ClassMapping( moveClassOutOfDefaultPackage( obfName, Constants.NonePackage ) );
+                        String obfName = processName( parts[1], makeSimple );
+                        return new ClassMapping( obfName );
                 }
                 else
                 {
-                        String obfName = parts[1];
-                        String deobfName = parts[2];
-                        if( obfName.equals( deobfName ) )
-                        {
-                                return new ClassMapping( moveClassOutOfDefaultPackage( obfName, Constants.NonePackage ) );
-                        }
-                        else
-                        {
-                                return new ClassMapping(
-                                        moveClassOutOfDefaultPackage( parts[1], Constants.NonePackage ),
-                                        moveClassOutOfDefaultPackage( parts[2], Constants.NonePackage )
-                                );
-                        }
+                        String obfName = processName( parts[1], makeSimple );
+                        String deobfName = processName( parts[2], makeSimple );
+                        return new ClassMapping( obfName, deobfName );
+                }
+        }
+        
+        private String processName( String name, boolean makeSimple )
+        {
+                if( makeSimple )
+                {
+                        return new ClassEntry( name ).getSimpleName();
+                }
+                else
+                {
+                        return moveClassOutOfDefaultPackage( name, Constants.NonePackage );
                 }
         }
         
diff --git a/src/cuchaz/enigma/mapping/MappingsRenamer.java b/src/cuchaz/enigma/mapping/MappingsRenamer.java
index 957b6d6..24ec731 100644
--- a/src/cuchaz/enigma/mapping/MappingsRenamer.java
+++ b/src/cuchaz/enigma/mapping/MappingsRenamer.java
@@ -16,6 +16,7 @@ import java.io.OutputStream;
 import java.util.Set;
 import java.util.zip.GZIPOutputStream;
 
+import cuchaz.enigma.Constants;
 import cuchaz.enigma.analysis.JarIndex;
 
 public class MappingsRenamer
@@ -31,7 +32,7 @@ public class MappingsRenamer
         
         public void setClassName( ClassEntry obf, String deobfName )
         {
-                deobfName = NameValidator.validateClassName( deobfName );
+                deobfName = NameValidator.validateClassName( deobfName, !obf.isInnerClass() );
                 ClassEntry targetEntry = new ClassEntry( deobfName );
                 if( m_mappings.containsDeobfClass( deobfName ) || m_index.containsObfClass( targetEntry ) )
                 {
@@ -77,7 +78,8 @@ public class MappingsRenamer
                 ClassMapping classMapping = getOrCreateClassMapping( obf );
                 if( obf.isInnerClass() )
                 {
-                        classMapping.setInnerClassName( obf.getName(), obf.getName() );
+                        String innerClassName = Constants.NonePackage + "/" + obf.getInnerClassName();
+                        classMapping.setInnerClassName( innerClassName, innerClassName );
                 }
                 else
                 {
diff --git a/src/cuchaz/enigma/mapping/NameValidator.java b/src/cuchaz/enigma/mapping/NameValidator.java
index 9adf1ac..c6ae596 100644
--- a/src/cuchaz/enigma/mapping/NameValidator.java
+++ b/src/cuchaz/enigma/mapping/NameValidator.java
@@ -55,7 +55,7 @@ public class NameValidator
                 ClassPattern = Pattern.compile( String.format( "^(%s(\\.|/))*(%s)$", identifierRegex, identifierRegex ) );
         }
         
-        public static String validateClassName( String name )
+        public static String validateClassName( String name, boolean packageRequired )
         {
                 if( name == null )
                 {
@@ -65,9 +65,9 @@ public class NameValidator
                 {
                         throw new IllegalNameException( name, "This doesn't look like a legal class name" );
                 }
-                if( new ClassEntry( name ).getPackageName() == null )
+                if( packageRequired && new ClassEntry( name ).getPackageName() == null )
                 {
-                        throw new IllegalNameException( name, "Classes must be in a package" );
+                        throw new IllegalNameException( name, "Class must be in a package" );
                 }
                 return Descriptor.toJvmName( name );
         }
diff --git a/src/cuchaz/enigma/mapping/Translator.java b/src/cuchaz/enigma/mapping/Translator.java
index 7904ef5..1c69b2f 100644
--- a/src/cuchaz/enigma/mapping/Translator.java
+++ b/src/cuchaz/enigma/mapping/Translator.java
@@ -80,19 +80,26 @@ public class Translator
                 {
                         if( in.isInnerClass() )
                         {
-                                // look for the inner class
+                                // translate the inner class
                                 String translatedInnerClassName = m_direction.choose(
                                         classMapping.getDeobfInnerClassName( in.getInnerClassName() ),
                                         classMapping.getObfInnerClassName( in.getInnerClassName() )
                                 );
                                 if( translatedInnerClassName != null )
                                 {
-                                        // return outer$inner
+                                        // try to translate the outer name
                                         String translatedOuterClassName = m_direction.choose(
                                                 classMapping.getDeobfName(),
                                                 classMapping.getObfName()
                                         );
-                                        return translatedOuterClassName + "$" + translatedInnerClassName;
+                                        if( translatedOuterClassName != null )
+                                        {
+                                                return translatedOuterClassName + "$" + translatedInnerClassName;
+                                        }
+                                        else
+                                        {
+                                                return in.getOuterClassName() + "$" + translatedInnerClassName;
+                                        }
                                 }
                         }
                         else
@@ -109,6 +116,7 @@ public class Translator
         
         public ClassEntry translateEntry( ClassEntry in )
         {
+                // can we translate the inner class?
                 String name = translate( in );
                 if( name != null )
                 {
@@ -117,13 +125,14 @@ public class Translator
                 
                 if( in.isInnerClass() )
                 {
-                        // just translate the outer class name
+                        // guess not. just translate the outer class name then
                         String outerClassName = translate( in.getOuterClassEntry() );
                         if( outerClassName != null )
                         {
                                 return new ClassEntry( outerClassName + "$" + in.getInnerClassName() );
                         }
                 }
+                
                 return in;
         }