switched to line-by-line mergable, human-readable file format for mappings

14 files changed, 655 insertions, 267 deletions

diff --git a/src/cuchaz/enigma/Deobfuscator.java b/src/cuchaz/enigma/Deobfuscator.java
index bc7065f..7be5706 100644
--- a/src/cuchaz/enigma/Deobfuscator.java
+++ b/src/cuchaz/enigma/Deobfuscator.java
@@ -32,9 +32,10 @@ import cuchaz.enigma.mapping.ArgumentEntry;
 import cuchaz.enigma.mapping.ClassEntry;
 import cuchaz.enigma.mapping.Entry;
 import cuchaz.enigma.mapping.FieldEntry;
+import cuchaz.enigma.mapping.Mappings;
 import cuchaz.enigma.mapping.MethodEntry;
+import cuchaz.enigma.mapping.Renamer;
 import cuchaz.enigma.mapping.TranslationDirection;
-import cuchaz.enigma.mapping.TranslationMappings;
 import cuchaz.enigma.mapping.Translator;
 
 public class Deobfuscator
@@ -43,7 +44,8 @@ public class Deobfuscator
         private JarFile m_jar;
         private DecompilerSettings m_settings;
         private Ancestries m_ancestries;
-        private TranslationMappings m_mappings;
+        private Mappings m_mappings;
+        private Renamer m_renamer;
         
         private static Comparator<ClassFile> m_obfuscatedClassSorter;
         
@@ -89,7 +91,7 @@ public class Deobfuscator
                 m_settings.setShowSyntheticMembers( true );
                 
                 // init mappings
-                setMappings( new TranslationMappings( m_ancestries ) );
+                setMappings( new Mappings() );
         }
         
         public String getJarName( )
@@ -97,23 +99,24 @@ public class Deobfuscator
                 return m_file.getName();
         }
         
-        public TranslationMappings getMappings( )
+        public Mappings getMappings( )
         {
                 return m_mappings;
         }
-        public void setMappings( TranslationMappings val )
+        public void setMappings( Mappings val )
         {
                 if( val == null )
                 {
-                        val = new TranslationMappings( m_ancestries );
+                        val = new Mappings();
                 }
                 m_mappings = val;
+                m_renamer = new Renamer( m_ancestries, m_mappings );
                 
                 // update decompiler options
                 m_settings.setTypeLoader( new TranslatingTypeLoader(
                         m_jar,
-                        m_mappings.getTranslator( TranslationDirection.Deobfuscating ),
-                        m_mappings.getTranslator( TranslationDirection.Obfuscating )
+                        m_mappings.getTranslator( m_ancestries, TranslationDirection.Deobfuscating ),
+                        m_mappings.getTranslator( m_ancestries, TranslationDirection.Obfuscating )
                 ) );
         }
         
@@ -168,19 +171,19 @@ public class Deobfuscator
         {
                 if( entry instanceof ClassEntry )
                 {
-                        m_mappings.setClassName( (ClassEntry)entry, newName );
+                        m_renamer.setClassName( (ClassEntry)entry, newName );
                 }
                 else if( entry instanceof FieldEntry )
                 {
-                        m_mappings.setFieldName( (FieldEntry)entry, newName );
+                        m_renamer.setFieldName( (FieldEntry)entry, newName );
                 }
                 else if( entry instanceof MethodEntry )
                 {
-                        m_mappings.setMethodName( (MethodEntry)entry, newName );
+                        m_renamer.setMethodName( (MethodEntry)entry, newName );
                 }
                 else if( entry instanceof ArgumentEntry )
                 {
-                        m_mappings.setArgumentName( (ArgumentEntry)entry, newName );
+                        m_renamer.setArgumentName( (ArgumentEntry)entry, newName );
                 }
                 else
                 {
@@ -190,7 +193,7 @@ public class Deobfuscator
         
         public Entry obfuscate( Entry in )
         {
-                Translator translator = m_mappings.getTranslator( TranslationDirection.Obfuscating );
+                Translator translator = m_mappings.getTranslator( m_ancestries, TranslationDirection.Obfuscating );
                 if( in instanceof ClassEntry )
                 {
                         return translator.translateEntry( (ClassEntry)in );
@@ -215,7 +218,7 @@ public class Deobfuscator
         
         public Entry deobfuscate( Entry in )
         {
-                Translator translator = m_mappings.getTranslator( TranslationDirection.Deobfuscating );
+                Translator translator = m_mappings.getTranslator( m_ancestries, TranslationDirection.Deobfuscating );
                 if( in instanceof ClassEntry )
                 {
                         return translator.translateEntry( (ClassEntry)in );
diff --git a/src/cuchaz/enigma/gui/GuiController.java b/src/cuchaz/enigma/gui/GuiController.java
index 5df2d43..fb22b96 100644
--- a/src/cuchaz/enigma/gui/GuiController.java
+++ b/src/cuchaz/enigma/gui/GuiController.java
@@ -11,8 +11,8 @@
 package cuchaz.enigma.gui;
 
 import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.FileWriter;
 import java.io.IOException;
 
 import cuchaz.enigma.ClassFile;
@@ -22,7 +22,8 @@ import cuchaz.enigma.analysis.SourceIndex;
 import cuchaz.enigma.mapping.ClassEntry;
 import cuchaz.enigma.mapping.Entry;
 import cuchaz.enigma.mapping.EntryPair;
-import cuchaz.enigma.mapping.TranslationMappings;
+import cuchaz.enigma.mapping.MappingsReader;
+import cuchaz.enigma.mapping.MappingsWriter;
 
 public class GuiController
 {
@@ -56,17 +57,19 @@ public class GuiController
         public void openMappings( File file )
         throws IOException
         {
-                FileInputStream in = new FileInputStream( file );
-                m_deobfuscator.setMappings( TranslationMappings.newFromStream( in ) );
+                FileReader in = new FileReader( file );
+                m_deobfuscator.setMappings( new MappingsReader().read( in ) );
                 in.close();
+                // TEMP
+                System.out.println( m_deobfuscator.getMappings() );
                 refreshOpenFiles();
         }
 
         public void saveMappings( File file )
         throws IOException
         {
-                FileOutputStream out = new FileOutputStream( file );
-                m_deobfuscator.getMappings().write( out );
+                FileWriter out = new FileWriter( file );
+                new MappingsWriter().write( out, m_deobfuscator.getMappings() );
                 out.close();
         }
 
diff --git a/src/cuchaz/enigma/mapping/ArgumentMapping.java b/src/cuchaz/enigma/mapping/ArgumentMapping.java
new file mode 100644
index 0000000..d5e020a
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/ArgumentMapping.java
@@ -0,0 +1,42 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.Serializable;
+
+public class ArgumentMapping implements Serializable
+{
+        private static final long serialVersionUID = 8610742471440861315L;
+        
+        private int m_index;
+        private String m_name;
+        
+        // NOTE: this argument order is important for the MethodReader/MethodWriter
+        public ArgumentMapping( int index, String name )
+        {
+                m_index = index;
+                m_name = name;
+        }
+        
+        public int getIndex( )
+        {
+                return m_index;
+        }
+        
+        public String getName( )
+        {
+                return m_name;
+        }
+        public void setName( String val )
+        {
+                m_name = val;
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/ClassIndex.java b/src/cuchaz/enigma/mapping/ClassMapping.java
index 699807b..3ba3569 100644
--- a/src/cuchaz/enigma/mapping/ClassIndex.java
+++ b/src/cuchaz/enigma/mapping/ClassMapping.java
@@ -14,24 +14,25 @@ import java.io.Serializable;
 import java.util.Map;
 
 import com.beust.jcommander.internal.Maps;
-import com.google.common.collect.BiMap;
-import com.google.common.collect.HashBiMap;
 
-public class ClassIndex implements Serializable
+public class ClassMapping implements Serializable
 {
         private static final long serialVersionUID = -5148491146902340107L;
         
         private String m_obfName;
         private String m_deobfName;
-        private BiMap<String,String> m_fieldsObfToDeobf;
-        private Map<String,MethodIndex> m_methodsByObf;
-        private Map<String,MethodIndex> m_methodsByDeobf;
+        private Map<String,FieldMapping> m_fieldsByObf;
+        private Map<String,FieldMapping> m_fieldsByDeobf;
+        private Map<String,MethodMapping> m_methodsByObf;
+        private Map<String,MethodMapping> m_methodsByDeobf;
         
-        public ClassIndex( String obfName, String deobfName )
+        // NOTE: this argument order is important for the MethodReader/MethodWriter
+        public ClassMapping( String obfName, String deobfName )
         {
                 m_obfName = obfName;
                 m_deobfName = deobfName;
-                m_fieldsObfToDeobf = HashBiMap.create();
+                m_fieldsByObf = Maps.newHashMap();
+                m_fieldsByDeobf = Maps.newHashMap();
                 m_methodsByObf = Maps.newHashMap();
                 m_methodsByDeobf = Maps.newHashMap();
         }
@@ -49,34 +50,91 @@ public class ClassIndex implements Serializable
         {
                 m_deobfName = val;
         }
+        
+        public Iterable<FieldMapping> fields( )
+        {
+                assert( m_fieldsByObf.size() == m_fieldsByDeobf.size() );
+                return m_fieldsByObf.values();
+        }
+        
+        protected void addFieldMapping( FieldMapping fieldMapping )
+        {
+                m_fieldsByObf.put( fieldMapping.getObfName(), fieldMapping );
+                m_fieldsByDeobf.put( fieldMapping.getDeobfName(), fieldMapping );
+        }
+
+        public Iterable<MethodMapping> methods( )
+        {
+                assert( m_methodsByObf.size() == m_methodsByDeobf.size() );
+                return m_methodsByObf.values();
+        }
+        
+        protected void addMethodMapping( MethodMapping methodMapping )
+        {
+                m_methodsByObf.put( getMethodKey( methodMapping.getObfName(), methodMapping.getObfSignature() ), methodMapping );
+                m_methodsByDeobf.put( getMethodKey( methodMapping.getDeobfName(), methodMapping.getDeobfSignature() ), methodMapping );
+        }
 
         public String getObfFieldName( String deobfName )
         {
-                return m_fieldsObfToDeobf.inverse().get( deobfName );
+                FieldMapping fieldMapping = m_fieldsByDeobf.get( deobfName );
+                if( fieldMapping != null )
+                {
+                        return fieldMapping.getObfName();
+                }
+                return null;
         }
         
         public String getDeobfFieldName( String obfName )
         {
-                return m_fieldsObfToDeobf.get( obfName );
+                FieldMapping fieldMapping = m_fieldsByObf.get( obfName );
+                if( fieldMapping != null )
+                {
+                        return fieldMapping.getDeobfName();
+                }
+                return null;
         }
         
         public void setFieldName( String obfName, String deobfName )
         {
-                m_fieldsObfToDeobf.put( obfName, deobfName );
+                if( deobfName == null )
+                {
+                        throw new IllegalArgumentException( "deobf name cannot be null!" );
+                }
+                
+                FieldMapping fieldMapping = m_fieldsByObf.get( obfName );
+                if( fieldMapping == null )
+                {
+                        fieldMapping = new FieldMapping( obfName, deobfName );
+                        m_fieldsByObf.put( obfName, fieldMapping );
+                        m_fieldsByDeobf.put( deobfName, fieldMapping );
+                }
+                
+                m_fieldsByDeobf.remove( fieldMapping.getDeobfName() );
+                fieldMapping.setDeobfName( deobfName );
+                m_fieldsByDeobf.put( deobfName, fieldMapping );
         }
         
-        public MethodIndex getMethodByObf( String obfName, String signature )
+        public MethodMapping getMethodByObf( String obfName, String signature )
         {
                 return m_methodsByObf.get( getMethodKey( obfName, signature ) );
         }
         
-        public MethodIndex getMethodByDeobf( String deobfName, String signature )
+        public MethodMapping getMethodByDeobf( String deobfName, String signature )
         {
                 return m_methodsByDeobf.get( getMethodKey( deobfName, signature ) );
         }
         
         private String getMethodKey( String name, String signature )
         {
+                if( name == null )
+                {
+                        throw new IllegalArgumentException( "name cannot be null!" );
+                }
+                if( signature == null )
+                {
+                        throw new IllegalArgumentException( "signature cannot be null!" );
+                }
                 return name + signature;
         }
         
@@ -87,7 +145,7 @@ public class ClassIndex implements Serializable
                         throw new IllegalArgumentException( "deobf name cannot be null!" );
                 }
                 
-                MethodIndex methodIndex = m_methodsByObf.get( getMethodKey( obfName, obfSignature ) );
+                MethodMapping methodIndex = m_methodsByObf.get( getMethodKey( obfName, obfSignature ) );
                 if( methodIndex == null )
                 {
                         methodIndex = createMethodIndex( obfName, obfSignature );
@@ -101,30 +159,30 @@ public class ClassIndex implements Serializable
         
         public void updateDeobfMethodSignatures( Translator translator )
         {
-                for( MethodIndex methodIndex : m_methodsByObf.values() )
+                for( MethodMapping methodIndex : m_methodsByObf.values() )
                 {
                         methodIndex.setDeobfSignature( translator.translateSignature( methodIndex.getObfSignature() ) );
                 }
         }
 
-        public void setArgumentName( String obfMethodName, String obfMethodSignature, int index, String obfName, String deobfName )
+        public void setArgumentName( String obfMethodName, String obfMethodSignature, int argumentIndex, String argumentName )
         {
-                if( deobfName == null )
+                if( argumentName == null )
                 {
-                        throw new IllegalArgumentException( "deobf name cannot be null!" );
+                        throw new IllegalArgumentException( "argument name cannot be null!" );
                 }
                 
-                MethodIndex methodIndex = m_methodsByObf.get( getMethodKey( obfMethodName, obfMethodSignature ) );
+                MethodMapping methodIndex = m_methodsByObf.get( getMethodKey( obfMethodName, obfMethodSignature ) );
                 if( methodIndex == null )
                 {
                         methodIndex = createMethodIndex( obfMethodName, obfMethodSignature );
                 }
-                methodIndex.setArgumentName( index, obfName, deobfName );
+                methodIndex.setArgumentName( argumentIndex, argumentName );
         }
 
-        private MethodIndex createMethodIndex( String obfName, String obfSignature )
+        private MethodMapping createMethodIndex( String obfName, String obfSignature )
         {
-                MethodIndex methodIndex = new MethodIndex( obfName, obfSignature, obfName, obfSignature );
+                MethodMapping methodIndex = new MethodMapping( obfName, obfName, obfSignature, obfSignature );
                 String key = getMethodKey( obfName, obfSignature );
                 m_methodsByObf.put( key, methodIndex );
                 m_methodsByDeobf.put( key, methodIndex );
@@ -140,16 +198,16 @@ public class ClassIndex implements Serializable
                 buf.append( m_deobfName );
                 buf.append( "\n" );
                 buf.append( "Fields:\n" );
-                for( Map.Entry<String,String> entry : m_fieldsObfToDeobf.entrySet() )
+                for( FieldMapping fieldMapping : fields() )
                 {
                         buf.append( "\t" );
-                        buf.append( entry.getKey() );
+                        buf.append( fieldMapping.getObfName() );
                         buf.append( " <-> " );
-                        buf.append( entry.getValue() );
+                        buf.append( fieldMapping.getDeobfName() );
                         buf.append( "\n" );
                 }
                 buf.append( "Methods:\n" );
-                for( MethodIndex methodIndex : m_methodsByObf.values() )
+                for( MethodMapping methodIndex : m_methodsByObf.values() )
                 {
                         buf.append( methodIndex.toString() );
                         buf.append( "\n" );
diff --git a/src/cuchaz/enigma/mapping/DeobfuscatedAncestries.java b/src/cuchaz/enigma/mapping/DeobfuscatedAncestries.java
index 5320f11..dcb0741 100644
--- a/src/cuchaz/enigma/mapping/DeobfuscatedAncestries.java
+++ b/src/cuchaz/enigma/mapping/DeobfuscatedAncestries.java
@@ -17,10 +17,10 @@ public class DeobfuscatedAncestries extends Ancestries
         private static final long serialVersionUID = 8316248774892618324L;
         
         private Ancestries m_ancestries;
-        private Map<String,ClassIndex> m_classesByObf;
-        private Map<String,ClassIndex> m_classesByDeobf;
+        private Map<String,ClassMapping> m_classesByObf;
+        private Map<String,ClassMapping> m_classesByDeobf;
         
-        protected DeobfuscatedAncestries( Ancestries ancestries, Map<String,ClassIndex> classesByObf, Map<String,ClassIndex> classesByDeobf )
+        protected DeobfuscatedAncestries( Ancestries ancestries, Map<String,ClassMapping> classesByObf, Map<String,ClassMapping> classesByDeobf )
         {
                 m_ancestries = ancestries;
                 m_classesByObf = classesByObf;
@@ -31,7 +31,7 @@ public class DeobfuscatedAncestries extends Ancestries
         public String getSuperclassName( String deobfClassName )
         {
                 // obfuscate the class name
-                ClassIndex classIndex = m_classesByDeobf.get( deobfClassName );
+                ClassMapping classIndex = m_classesByDeobf.get( deobfClassName );
                 if( classIndex == null )
                 {
                         return null;
diff --git a/src/cuchaz/enigma/mapping/FieldEntry.java b/src/cuchaz/enigma/mapping/FieldEntry.java
index b9f4239..eefc4c4 100644
--- a/src/cuchaz/enigma/mapping/FieldEntry.java
+++ b/src/cuchaz/enigma/mapping/FieldEntry.java
@@ -21,6 +21,7 @@ public class FieldEntry implements Entry, Serializable
         private ClassEntry m_classEntry;
         private String m_name;
         
+        // NOTE: this argument order is important for the MethodReader/MethodWriter
         public FieldEntry( ClassEntry classEntry, String name )
         {
                 if( classEntry == null )
diff --git a/src/cuchaz/enigma/mapping/ArgumentIndex.java b/src/cuchaz/enigma/mapping/FieldMapping.java
index 57488d1..618f45c 100644
--- a/src/cuchaz/enigma/mapping/ArgumentIndex.java
+++ b/src/cuchaz/enigma/mapping/FieldMapping.java
@@ -12,14 +12,14 @@ package cuchaz.enigma.mapping;
 
 import java.io.Serializable;
 
-public class ArgumentIndex implements Serializable
+public class FieldMapping implements Serializable
 {
         private static final long serialVersionUID = 8610742471440861315L;
         
         private String m_obfName;
         private String m_deobfName;
         
-        public ArgumentIndex( String obfName, String deobfName )
+        public FieldMapping( String obfName, String deobfName )
         {
                 m_obfName = obfName;
                 m_deobfName = deobfName;
diff --git a/src/cuchaz/enigma/mapping/Mappings.java b/src/cuchaz/enigma/mapping/Mappings.java
new file mode 100644
index 0000000..2a39057
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/Mappings.java
@@ -0,0 +1,128 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.ObjectInputStream;
+import java.io.Serializable;
+import java.util.Map;
+import java.util.zip.GZIPInputStream;
+
+import com.beust.jcommander.internal.Maps;
+
+import cuchaz.enigma.Util;
+
+public class Mappings implements Serializable
+{
+        private static final long serialVersionUID = 4649790259460259026L;
+        
+        protected Map<String,ClassMapping> m_classesByObf;
+        protected Map<String,ClassMapping> m_classesByDeobf;
+        
+        public Mappings( )
+        {
+                m_classesByObf = Maps.newHashMap();
+                m_classesByDeobf = Maps.newHashMap();
+        }
+        
+        public Mappings( Iterable<ClassMapping> classes )
+        {
+                this();
+                
+                for( ClassMapping classMapping : classes )
+                {
+                        m_classesByObf.put( classMapping.getObfName(), classMapping );
+                        m_classesByDeobf.put( classMapping.getDeobfName(), classMapping );
+                }
+        }
+        
+        public static Mappings newFromResource( String resource )
+        throws IOException
+        {
+                InputStream in = null;
+                try
+                {
+                        in = Mappings.class.getResourceAsStream( resource );
+                        return newFromStream( in );
+                }
+                finally
+                {
+                        Util.closeQuietly( in );
+                }
+        }
+        
+        public Iterable<ClassMapping> classes( )
+        {
+                assert( m_classesByObf.size() == m_classesByDeobf.size() );
+                return m_classesByObf.values();
+        }
+        
+        protected void addClassMapping( ClassMapping classMapping )
+        {
+                m_classesByObf.put( classMapping.getObfName(), classMapping );
+                m_classesByDeobf.put( classMapping.getDeobfName(), classMapping );
+        }
+        
+        public ClassMapping getClassByObf( ClassEntry entry )
+        {
+                return getClassByObf( entry.getName() );
+        }
+        
+        public ClassMapping getClassByObf( String obfName )
+        {
+                return m_classesByObf.get( obfName );
+        }
+        
+        public ClassMapping getClassByDeobf( ClassEntry entry )
+        {
+                return getClassByObf( entry.getName() );
+        }
+        
+        public ClassMapping getClassByDeobf( String deobfName )
+        {
+                return m_classesByDeobf.get( deobfName );
+        }
+        
+        public Translator getTranslator( Ancestries ancestries, TranslationDirection direction )
+        {
+                return new Translator(
+                        direction,
+                        direction.choose( m_classesByObf, m_classesByDeobf ),
+                        direction.choose( ancestries, new DeobfuscatedAncestries( ancestries, m_classesByObf, m_classesByDeobf ) )
+                );
+        }
+        
+        public static Mappings newFromStream( InputStream in )
+        throws IOException
+        {
+                try
+                {
+                        return (Mappings)new ObjectInputStream( new GZIPInputStream( in ) ).readObject();
+                }
+                catch( ClassNotFoundException ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        @Override
+        public String toString( )
+        {
+                StringBuilder buf = new StringBuilder();
+                for( ClassMapping classMapping : m_classesByObf.values() )
+                {
+                        buf.append( classMapping.toString() );
+                        buf.append( "\n" );
+                }
+                return buf.toString();
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/MappingsReader.java b/src/cuchaz/enigma/mapping/MappingsReader.java
new file mode 100644
index 0000000..b039409
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/MappingsReader.java
@@ -0,0 +1,129 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.Reader;
+import java.util.NoSuchElementException;
+import java.util.Scanner;
+
+import cuchaz.enigma.Util;
+
+public class MappingsReader
+{
+        public Mappings read( Reader in )
+        throws IOException
+        {
+                return read( new BufferedReader( in ) );
+        }
+        
+        public Mappings read( BufferedReader in )
+        throws IOException
+        {
+                Mappings mappings = new Mappings();
+                ClassMapping classMapping = null;
+                MethodMapping methodMapping = null;
+                
+                int lineNumber = 0;
+                String line = null;
+                while( ( line = in.readLine() ) != null )
+                {
+                        lineNumber++;
+                        
+                        // strip comments
+                        int commentPos = line.indexOf( '#' );
+                        if( commentPos >= 0 )
+                        {
+                                line = line.substring( 0, commentPos );
+                        }
+                        
+                        // skip blank lines
+                        line = line.trim();
+                        if( line.length() <= 0 )
+                        {
+                                continue;
+                        }
+                        
+                        Scanner scanner = new Scanner( line );
+                        try
+                        {
+                                while( scanner.hasNext() )
+                                {
+                                        // read the first token
+                                        String token = scanner.next();
+                                        
+                                        if( token.equalsIgnoreCase( "CLASS" ) )
+                                        {
+                                                classMapping = readClass( scanner );
+                                                mappings.addClassMapping( classMapping );
+                                                methodMapping = null;
+                                        }
+                                        else if( token.equalsIgnoreCase( "FIELD" ) )
+                                        {
+                                                if( classMapping == null )
+                                                {
+                                                        throw new IllegalArgumentException( "Line " + lineNumber + ": Unexpected FIELD entry here!" );
+                                                }
+                                                classMapping.addFieldMapping( readField( scanner ) );
+                                        }
+                                        else if( token.equalsIgnoreCase( "METHOD" ) )
+                                        {
+                                                if( classMapping == null )
+                                                {
+                                                        throw new IllegalArgumentException( "Line " + lineNumber + ": Unexpected METHOD entry here!" );
+                                                }
+                                                methodMapping = readMethod( scanner );
+                                                classMapping.addMethodMapping( methodMapping );
+                                        }
+                                        else if( token.equalsIgnoreCase( "ARG" ) )
+                                        {
+                                                if( classMapping == null || methodMapping == null )
+                                                {
+                                                        throw new IllegalArgumentException( "Line " + lineNumber + ": Unexpected ARG entry here!" );
+                                                }
+                                                methodMapping.addArgumentMapping( readArgument( scanner ) );
+                                        }
+                                }
+                        }
+                        catch( NoSuchElementException ex )
+                        {
+                                throw new IllegalArgumentException( "Line " + lineNumber + ": malformed line!" );
+                        }
+                        finally
+                        {
+                                Util.closeQuietly( scanner );
+                        }
+                }
+                
+                return mappings;
+        }
+
+        private ArgumentMapping readArgument( Scanner scanner )
+        {
+                return new ArgumentMapping( scanner.nextInt(), scanner.next() );
+        }
+
+        private ClassMapping readClass( Scanner scanner )
+        {
+                return new ClassMapping( scanner.next(), scanner.next() );
+        }
+        
+        private FieldMapping readField( Scanner scanner )
+        {
+                return new FieldMapping( scanner.next(), scanner.next() );
+        }
+        
+        private MethodMapping readMethod( Scanner scanner )
+        {
+                return new MethodMapping( scanner.next(), scanner.next(), scanner.next(), scanner.next() );
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/MappingsWriter.java b/src/cuchaz/enigma/mapping/MappingsWriter.java
new file mode 100644
index 0000000..2086368
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/MappingsWriter.java
@@ -0,0 +1,75 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.Writer;
+
+public class MappingsWriter
+{
+        public void write( Writer out, Mappings mappings )
+        throws IOException
+        {
+                write( new PrintWriter( out ), mappings );
+        }
+        
+        public void write( PrintWriter out, Mappings mappings )
+        throws IOException
+        {
+                for( ClassMapping classMapping : mappings.classes() )
+                {
+                        write( out, classMapping );
+                }
+        }
+        
+        public void write( PrintWriter out, ClassMapping classMapping )
+        throws IOException
+        {
+                out.format( "CLASS %s %s\n", classMapping.getObfName(), classMapping.getDeobfName() );
+                
+                for( FieldMapping fieldMapping : classMapping.fields() )
+                {
+                        write( out, fieldMapping );
+                }
+                
+                for( MethodMapping methodMapping : classMapping.methods() )
+                {
+                        write( out, methodMapping );
+                }
+        }
+
+        public void write( PrintWriter out, FieldMapping fieldMapping )
+        throws IOException
+        {
+                out.format( "\tFIELD %s %s\n", fieldMapping.getObfName(), fieldMapping.getDeobfName() );
+        }
+        
+        public void write( PrintWriter out, MethodMapping methodMapping )
+        throws IOException
+        {
+                out.format( "\tMETHOD %s %s %s %s\n",
+                        methodMapping.getObfName(), methodMapping.getDeobfName(),
+                        methodMapping.getObfSignature(), methodMapping.getDeobfSignature()
+                );
+                
+                for( ArgumentMapping argumentMapping : methodMapping.arguments() )
+                {
+                        write( out, argumentMapping );
+                }
+        }
+
+        public void write( PrintWriter out, ArgumentMapping argumentMapping )
+        throws IOException
+        {
+                out.format( "\t\tARG %d %s\n", argumentMapping.getIndex(), argumentMapping.getName() );
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/MethodIndex.java b/src/cuchaz/enigma/mapping/MethodMapping.java
index f965355..f2bc54d 100644
--- a/src/cuchaz/enigma/mapping/MethodIndex.java
+++ b/src/cuchaz/enigma/mapping/MethodMapping.java
@@ -14,7 +14,7 @@ import java.io.Serializable;
 import java.util.Map;
 import java.util.TreeMap;
 
-public class MethodIndex implements Serializable
+public class MethodMapping implements Serializable
 {
         private static final long serialVersionUID = -4409570216084263978L;
         
@@ -22,15 +22,16 @@ public class MethodIndex implements Serializable
         private String m_deobfName;
         private String m_obfSignature;
         private String m_deobfSignature;
-        private Map<Integer,ArgumentIndex> m_arguments;
+        private Map<Integer,ArgumentMapping> m_arguments;
         
-        public MethodIndex( String obfName, String obfSignature, String deobfName, String deobfSignature )
+        // NOTE: this argument order is important for the MethodReader/MethodWriter
+        public MethodMapping( String obfName, String deobfName, String obfSignature, String deobfSignature )
         {
                 m_obfName = obfName;
                 m_deobfName = deobfName;
                 m_obfSignature = obfSignature;
                 m_deobfSignature = deobfSignature;
-                m_arguments = new TreeMap<Integer,ArgumentIndex>();
+                m_arguments = new TreeMap<Integer,ArgumentMapping>();
         }
 
         public String getObfName( )
@@ -61,12 +62,22 @@ public class MethodIndex implements Serializable
                 m_deobfSignature = val;
         }
         
+        public Iterable<ArgumentMapping> arguments( )
+        {
+                return m_arguments.values();
+        }
+        
+        protected void addArgumentMapping( ArgumentMapping argumentMapping )
+        {
+                m_arguments.put( argumentMapping.getIndex(), argumentMapping );
+        }
+        
         public String getObfArgumentName( int index )
         {
-                ArgumentIndex argumentIndex = m_arguments.get( index );
-                if( argumentIndex != null )
+                ArgumentMapping argumentMapping = m_arguments.get( index );
+                if( argumentMapping != null )
                 {
-                        return argumentIndex.getObfName();
+                        return argumentMapping.getName();
                 }
                 
                 return null;
@@ -74,26 +85,26 @@ public class MethodIndex implements Serializable
         
         public String getDeobfArgumentName( int index )
         {
-                ArgumentIndex argumentIndex = m_arguments.get( index );
-                if( argumentIndex != null )
+                ArgumentMapping argumentMapping = m_arguments.get( index );
+                if( argumentMapping != null )
                 {
-                        return argumentIndex.getDeobfName();
+                        return argumentMapping.getName();
                 }
                 
                 return null;
         }
         
-        public void setArgumentName( int index, String obfName, String deobfName )
+        public void setArgumentName( int index, String name )
         {
-                ArgumentIndex argumentIndex = m_arguments.get( index );
-                if( argumentIndex == null )
+                ArgumentMapping argumentMapping = m_arguments.get( index );
+                if( argumentMapping == null )
                 {
-                        argumentIndex = new ArgumentIndex( obfName, deobfName );
-                        m_arguments.put( index, argumentIndex );
+                        argumentMapping = new ArgumentMapping( index, name );
+                        m_arguments.put( index, argumentMapping );
                 }
                 else
                 {
-                        argumentIndex.setDeobfName( deobfName );
+                        argumentMapping.setName( name );
                 }
         }
         
@@ -112,12 +123,12 @@ public class MethodIndex implements Serializable
                 buf.append( m_deobfSignature );
                 buf.append( "\n" );
                 buf.append( "\tArguments:\n" );
-                for( ArgumentIndex argumentIndex : m_arguments.values() )
+                for( ArgumentMapping argumentMapping : m_arguments.values() )
                 {
                         buf.append( "\t\t" );
-                        buf.append( argumentIndex.getObfName() );
+                        buf.append( argumentMapping.getIndex() );
                         buf.append( " <-> " );
-                        buf.append( argumentIndex.getDeobfName() );
+                        buf.append( argumentMapping.getName() );
                         buf.append( "\n" );
                 }
                 return buf.toString();
diff --git a/src/cuchaz/enigma/mapping/Renamer.java b/src/cuchaz/enigma/mapping/Renamer.java
new file mode 100644
index 0000000..4a648ad
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/Renamer.java
@@ -0,0 +1,125 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.IOException;
+import java.io.ObjectOutputStream;
+import java.io.OutputStream;
+import java.util.zip.GZIPOutputStream;
+
+public class Renamer
+{
+        private Ancestries m_ancestries;
+        private Mappings m_mappings;
+        
+        public Renamer( Ancestries ancestries, Mappings mappings )
+        {
+                m_ancestries = ancestries;
+                m_mappings = mappings;
+        }
+        
+        public void setClassName( ClassEntry obf, String deobfName )
+        {
+                ClassMapping classMapping = m_mappings.m_classesByObf.get( obf.getName() );
+                if( classMapping == null )
+                {
+                        classMapping = createClassMapping( obf );
+                }
+                
+                m_mappings.m_classesByDeobf.remove( classMapping.getDeobfName() );
+                classMapping.setDeobfName( deobfName );
+                m_mappings.m_classesByDeobf.put( deobfName, classMapping );
+                
+                updateDeobfMethodSignatures();
+                
+                // TEMP
+                String translatedName = m_mappings.getTranslator( m_ancestries, TranslationDirection.Deobfuscating ).translate( obf );
+                assert( translatedName != null && translatedName.equals( deobfName ) );
+        }
+        
+        public void setFieldName( FieldEntry obf, String deobfName )
+        {
+                ClassMapping classMapping = m_mappings.m_classesByObf.get( obf.getClassName() );
+                if( classMapping == null )
+                {
+                        classMapping = createClassMapping( obf.getClassEntry() );
+                }
+                
+                classMapping.setFieldName( obf.getName(), deobfName );
+                
+                // TEMP
+                System.out.println( classMapping );
+                String translatedName = m_mappings.getTranslator( m_ancestries, TranslationDirection.Deobfuscating ).translate( obf );
+                assert( translatedName != null && translatedName.equals( deobfName ) );
+        }
+        
+        public void setMethodName( MethodEntry obf, String deobfName )
+        {
+                ClassMapping classMapping = m_mappings.m_classesByObf.get( obf.getClassName() );
+                if( classMapping == null )
+                {
+                        classMapping = createClassMapping( obf.getClassEntry() );
+                }
+                
+                String deobfSignature = m_mappings.getTranslator( m_ancestries, TranslationDirection.Deobfuscating ).translateSignature( obf.getSignature() );
+                classMapping.setMethodNameAndSignature( obf.getName(), obf.getSignature(), deobfName, deobfSignature );
+                
+                // TODO: update ancestor/descendant methods in other classes in the inheritance hierarchy too
+                
+                // TEMP
+                System.out.println( classMapping );
+                String translatedName = m_mappings.getTranslator( m_ancestries, TranslationDirection.Deobfuscating ).translate( obf );
+                assert( translatedName != null && translatedName.equals( deobfName ) );
+        }
+        
+        public void setArgumentName( ArgumentEntry obf, String deobfName )
+        {
+                ClassMapping classMapping = m_mappings.m_classesByObf.get( obf.getClassName() );
+                if( classMapping == null )
+                {
+                        classMapping = createClassMapping( obf.getClassEntry() );
+                }
+                
+                classMapping.setArgumentName( obf.getMethodName(), obf.getMethodSignature(), obf.getIndex(), deobfName );
+                
+                // TEMP
+                System.out.println( classMapping );
+                String translatedName = m_mappings.getTranslator( m_ancestries, TranslationDirection.Deobfuscating ).translate( obf );
+                assert( translatedName != null && translatedName.equals( deobfName ) );
+        }
+        
+        public void write( OutputStream out )
+        throws IOException
+        {
+                // TEMP: just use the object output for now. We can find a more efficient storage format later
+                GZIPOutputStream gzipout = new GZIPOutputStream( out );
+                ObjectOutputStream oout = new ObjectOutputStream( gzipout );
+                oout.writeObject( this );
+                gzipout.finish();
+        }
+        
+        private ClassMapping createClassMapping( ClassEntry obf )
+        {
+                ClassMapping classMapping = new ClassMapping( obf.getName(), obf.getName() );
+                m_mappings.m_classesByObf.put( classMapping.getObfName(), classMapping );
+                m_mappings.m_classesByDeobf.put( classMapping.getDeobfName(), classMapping );
+                return classMapping;
+        }
+        
+        private void updateDeobfMethodSignatures( )
+        {
+                Translator translator = m_mappings.getTranslator( m_ancestries, TranslationDirection.Deobfuscating );
+                for( ClassMapping classMapping : m_mappings.m_classesByObf.values() )
+                {
+                        classMapping.updateDeobfMethodSignatures( translator );
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/TranslationMappings.java b/src/cuchaz/enigma/mapping/TranslationMappings.java
deleted file mode 100644
index d6cd449..0000000
--- a/src/cuchaz/enigma/mapping/TranslationMappings.java
+++ /dev/null
@@ -1,187 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2014 Jeff Martin.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- * 
- * Contributors:
- *     Jeff Martin - initial API and implementation
- ******************************************************************************/
-package cuchaz.enigma.mapping;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
-import java.io.OutputStream;
-import java.io.Serializable;
-import java.util.Map;
-import java.util.zip.GZIPInputStream;
-import java.util.zip.GZIPOutputStream;
-
-import com.beust.jcommander.internal.Maps;
-
-import cuchaz.enigma.Util;
-
-public class TranslationMappings implements Serializable
-{
-        private static final long serialVersionUID = 4649790259460259026L;
-        
-        private Map<String,ClassIndex> m_classesByObf;
-        private Map<String,ClassIndex> m_classesByDeobf;
-        private Ancestries m_ancestries;
-        
-        public TranslationMappings( Ancestries ancestries )
-        {
-                m_classesByObf = Maps.newHashMap();
-                m_classesByDeobf = Maps.newHashMap();
-                m_ancestries = ancestries;
-        }
-        
-        public static TranslationMappings newFromResource( String resource )
-        throws IOException
-        {
-                InputStream in = null;
-                try
-                {
-                        in = TranslationMappings.class.getResourceAsStream( resource );
-                        return newFromStream( in );
-                }
-                finally
-                {
-                        Util.closeQuietly( in );
-                }
-        }
-        
-        public Translator getTranslator( TranslationDirection direction )
-        {
-                return new Translator(
-                        direction,
-                        direction.choose( m_classesByObf, m_classesByDeobf ),
-                        direction.choose( m_ancestries, new DeobfuscatedAncestries( m_ancestries, m_classesByObf, m_classesByDeobf ) )
-                );
-        }
-        
-        public void setClassName( ClassEntry obf, String deobfName )
-        {
-                ClassIndex classIndex = m_classesByObf.get( obf.getName() );
-                if( classIndex == null )
-                {
-                        classIndex = createClassIndex( obf );
-                }
-                
-                m_classesByDeobf.remove( classIndex.getDeobfName() );
-                classIndex.setDeobfName( deobfName );
-                m_classesByDeobf.put( deobfName, classIndex );
-                
-                updateDeobfMethodSignatures();
-                
-                // TEMP
-                String translatedName = getTranslator( TranslationDirection.Deobfuscating ).translate( obf );
-                assert( translatedName != null && translatedName.equals( deobfName ) );
-        }
-        
-        public void setFieldName( FieldEntry obf, String deobfName )
-        {
-                ClassIndex classIndex = m_classesByObf.get( obf.getClassName() );
-                if( classIndex == null )
-                {
-                        classIndex = createClassIndex( obf.getClassEntry() );
-                }
-                
-                classIndex.setFieldName( obf.getName(), deobfName );
-                
-                // TEMP
-                System.out.println( classIndex );
-                String translatedName = getTranslator( TranslationDirection.Deobfuscating ).translate( obf );
-                assert( translatedName != null && translatedName.equals( deobfName ) );
-        }
-        
-        public void setMethodName( MethodEntry obf, String deobfName )
-        {
-                ClassIndex classIndex = m_classesByObf.get( obf.getClassName() );
-                if( classIndex == null )
-                {
-                        classIndex = createClassIndex( obf.getClassEntry() );
-                }
-                
-                String deobfSignature = getTranslator( TranslationDirection.Deobfuscating ).translateSignature( obf.getSignature() );
-                classIndex.setMethodNameAndSignature( obf.getName(), obf.getSignature(), deobfName, deobfSignature );
-                
-                // TODO: update ancestor/descendant methods in other classes in the inheritance hierarchy too
-                
-                // TEMP
-                System.out.println( classIndex );
-                String translatedName = getTranslator( TranslationDirection.Deobfuscating ).translate( obf );
-                assert( translatedName != null && translatedName.equals( deobfName ) );
-        }
-        
-        public void setArgumentName( ArgumentEntry obf, String deobfName )
-        {
-                ClassIndex classIndex = m_classesByObf.get( obf.getClassName() );
-                if( classIndex == null )
-                {
-                        classIndex = createClassIndex( obf.getClassEntry() );
-                }
-                
-                classIndex.setArgumentName( obf.getMethodName(), obf.getMethodSignature(), obf.getIndex(), obf.getName(), deobfName );
-                
-                // TEMP
-                System.out.println( classIndex );
-                String translatedName = getTranslator( TranslationDirection.Deobfuscating ).translate( obf );
-                assert( translatedName != null && translatedName.equals( deobfName ) );
-        }
-        
-        public void write( OutputStream out )
-        throws IOException
-        {
-                // TEMP: just use the object output for now. We can find a more efficient storage format later
-                GZIPOutputStream gzipout = new GZIPOutputStream( out );
-                ObjectOutputStream oout = new ObjectOutputStream( gzipout );
-                oout.writeObject( this );
-                gzipout.finish();
-        }
-        
-        public static TranslationMappings newFromStream( InputStream in )
-        throws IOException
-        {
-                try
-                {
-                        return (TranslationMappings)new ObjectInputStream( new GZIPInputStream( in ) ).readObject();
-                }
-                catch( ClassNotFoundException ex )
-                {
-                        throw new Error( ex );
-                }
-        }
-        
-        private ClassIndex createClassIndex( ClassEntry obf )
-        {
-                ClassIndex classIndex = new ClassIndex( obf.getName(), obf.getName() );
-                m_classesByObf.put( classIndex.getObfName(), classIndex );
-                m_classesByDeobf.put( classIndex.getDeobfName(), classIndex );
-                return classIndex;
-        }
-        
-        private void updateDeobfMethodSignatures( )
-        {
-                Translator translator = getTranslator( TranslationDirection.Deobfuscating );
-                for( ClassIndex classIndex : m_classesByObf.values() )
-                {
-                        classIndex.updateDeobfMethodSignatures( translator );
-                }
-        }
-        
-        @Override
-        public String toString( )
-        {
-                StringBuilder buf = new StringBuilder();
-                for( ClassIndex classIndex : m_classesByObf.values() )
-                {
-                        buf.append( classIndex.toString() );
-                        buf.append( "\n" );
-                }
-                return buf.toString();
-        }
-}
diff --git a/src/cuchaz/enigma/mapping/Translator.java b/src/cuchaz/enigma/mapping/Translator.java
index bae0dce..3dbc103 100644
--- a/src/cuchaz/enigma/mapping/Translator.java
+++ b/src/cuchaz/enigma/mapping/Translator.java
@@ -19,10 +19,10 @@ import cuchaz.enigma.mapping.SignatureUpdater.ClassNameUpdater;
 public class Translator
 {
         private TranslationDirection m_direction;
-        private Map<String,ClassIndex> m_classes;
+        private Map<String,ClassMapping> m_classes;
         private Ancestries m_ancestries;
         
-        protected Translator( TranslationDirection direction, Map<String,ClassIndex> classes, Ancestries ancestries )
+        protected Translator( TranslationDirection direction, Map<String,ClassMapping> classes, Ancestries ancestries )
         {
                 m_direction = direction;
                 m_classes = classes;
@@ -36,7 +36,7 @@ public class Translator
         
         public String translateClass( String in )
         {
-                ClassIndex classIndex = m_classes.get( in );
+                ClassMapping classIndex = m_classes.get( in );
                 if( classIndex != null )
                 {
                         return m_direction.choose(
@@ -63,7 +63,7 @@ public class Translator
                 for( String className : getSelfAndAncestors( in.getClassName() ) )
                 {
                         // look for the class
-                        ClassIndex classIndex = m_classes.get( className );
+                        ClassMapping classIndex = m_classes.get( className );
                         if( classIndex != null )
                         {
                                 // look for the field
@@ -99,11 +99,11 @@ public class Translator
                 for( String className : getSelfAndAncestors( in.getClassName() ) )
                 {
                         // look for the class
-                        ClassIndex classIndex = m_classes.get( className );
+                        ClassMapping classIndex = m_classes.get( className );
                         if( classIndex != null )
                         {
                                 // look for the method
-                                MethodIndex methodIndex = m_direction.choose(
+                                MethodMapping methodIndex = m_direction.choose(
                                         classIndex.getMethodByObf( in.getName(), in.getSignature() ),
                                         classIndex.getMethodByDeobf( in.getName(), in.getSignature() )
                                 );
@@ -139,11 +139,11 @@ public class Translator
                 for( String className : getSelfAndAncestors( in.getClassName() ) )
                 {
                         // look for the class
-                        ClassIndex classIndex = m_classes.get( className );
+                        ClassMapping classIndex = m_classes.get( className );
                         if( classIndex != null )
                         {
                                 // look for the method
-                                MethodIndex methodIndex = m_direction.choose(
+                                MethodMapping methodIndex = m_direction.choose(
                                         classIndex.getMethodByObf( in.getMethodName(), in.getMethodSignature() ),
                                         classIndex.getMethodByDeobf( in.getMethodName(), in.getMethodSignature() )
                                 );