fixed bugs with saving mappings

got argument renaming to work

2 files changed, 55 insertions, 17 deletions

diff --git a/src/cuchaz/enigma/bytecode/MethodParameterWriter.java b/src/cuchaz/enigma/bytecode/MethodParameterWriter.java
index 1e5d1f0..a8d3983 100644
--- a/src/cuchaz/enigma/bytecode/MethodParameterWriter.java
+++ b/src/cuchaz/enigma/bytecode/MethodParameterWriter.java
@@ -10,9 +10,15 @@
  ******************************************************************************/
 package cuchaz.enigma.bytecode;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import javassist.CtBehavior;
 import javassist.CtClass;
-import javassist.bytecode.AttributeInfo;
+import javassist.bytecode.Descriptor;
+import cuchaz.enigma.mapping.ArgumentEntry;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.MethodEntry;
 import cuchaz.enigma.mapping.Translator;
 
 public class MethodParameterWriter
@@ -27,9 +33,25 @@ public class MethodParameterWriter
         public void writeMethodArguments( CtClass c )
         {
                 // Procyon will read method arguments from the "MethodParameters" attribute, so write those
+                ClassEntry classEntry = new ClassEntry( Descriptor.toJvmName( c.getName() ) );
                 for( CtBehavior behavior : c.getDeclaredBehaviors() )
                 {
-                        AttributeInfo attribute = behavior.getMethodInfo().getAttribute( "MethodParameter" );
+                        int numParams = Descriptor.numOfParameters( behavior.getMethodInfo().getDescriptor() );
+                        if( numParams <= 0 )
+                        {
+                                continue;
+                        }
+                        
+                        // get the list of parameter names
+                        MethodEntry methodEntry = new MethodEntry( classEntry, behavior.getMethodInfo().getName(), behavior.getSignature() );
+                        List<String> names = new ArrayList<String>( numParams );
+                        for( int i=0; i<numParams; i++ )
+                        {
+                                names.add( m_translator.translate( new ArgumentEntry( methodEntry, i, "" ) ) );
+                        }
+                        
+                        // save the mappings to the class
+                        MethodParametersAttribute.updateClass( behavior.getMethodInfo(), names );
                 }
         }
 }
diff --git a/src/cuchaz/enigma/bytecode/MethodParametersAttribute.java b/src/cuchaz/enigma/bytecode/MethodParametersAttribute.java
index 0b29403..baf1ac1 100644
--- a/src/cuchaz/enigma/bytecode/MethodParametersAttribute.java
+++ b/src/cuchaz/enigma/bytecode/MethodParametersAttribute.java
@@ -13,24 +13,45 @@ package cuchaz.enigma.bytecode;
 import java.io.ByteArrayOutputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
+import java.util.ArrayList;
 import java.util.List;
 
 import javassist.bytecode.AttributeInfo;
 import javassist.bytecode.ConstPool;
+import javassist.bytecode.MethodInfo;
 
 public class MethodParametersAttribute extends AttributeInfo
 {
-        public MethodParametersAttribute( ConstPool pool, int attributeNameIndex, List<Integer> parameterNameIndices )
+        private MethodParametersAttribute( ConstPool pool, List<Integer> parameterNameIndices )
         {
-                super( pool, "MethodParameters", writeStruct( attributeNameIndex, parameterNameIndices ) );
+                super( pool, "MethodParameters", writeStruct( parameterNameIndices ) );
         }
         
-        private static byte[] writeStruct( int attributeNameIndex, List<Integer> parameterNameIndices )
+        public static void updateClass( MethodInfo info, List<String> names )
         {
-                // JVM Spec says the struct looks like this:
+                // add the names to the class const pool
+                ConstPool constPool = info.getConstPool();
+                List<Integer> parameterNameIndices = new ArrayList<Integer>();
+                for( String name : names )
+                {
+                        if( name != null )
+                        {
+                                parameterNameIndices.add( constPool.addUtf8Info( name ) );
+                        }
+                        else
+                        {
+                                parameterNameIndices.add( 0 );
+                        }
+                }
+                
+                // add the attribute to the method
+                info.addAttribute( new MethodParametersAttribute( constPool, parameterNameIndices ) );
+        }
+        
+        private static byte[] writeStruct( List<Integer> parameterNameIndices )
+        {
+                // JVM 8 Spec says the struct looks like this:
                 // http://cr.openjdk.java.net/~mr/se/8/java-se-8-fr-spec-01/java-se-8-jvms-fr-diffs.pdf
-                // uint16 name_index -> points to UTF8 entry in constant pool that says "MethodParameters"
-                // uint32 length -> length of this struct, minus 6 bytes (ie, length of num_params and parameter array)
                 // uint8 num_params
                 // for each param:
                 //    uint16 name_index -> points to UTF8 entry in constant pool, or 0 for no entry
@@ -43,20 +64,13 @@ public class MethodParametersAttribute extends AttributeInfo
                 // the writeShort(), writeByte() methods will read 16,8 low-order bits from the int argument
                 // as long as the int argument is in range of the unsigned short/byte type, it will be written as an unsigned short/byte
                 // if the int is out of range, the byte stream won't look the way we want and weird things will happen
+                final int SIZEOF_UINT8 = 1;
                 final int SIZEOF_UINT16 = 2;
                 final int MAX_UINT8 = ( 1 << 8 ) - 1;
                 final int MAX_UINT16 = ( 1 << 16 ) - 1;
-                final long MAX_UINT32 = ( 1 << 32 ) - 1;
                 
                 try
                 {
-                        assert( attributeNameIndex >= 0 && attributeNameIndex <= MAX_UINT16 );
-                        out.writeShort( attributeNameIndex );
-                        
-                        long length = SIZEOF_UINT16 + parameterNameIndices.size()*( SIZEOF_UINT16 + SIZEOF_UINT16 );
-                        assert( length >= 0 && length <= MAX_UINT32 );
-                        out.writeInt( (int)length );
-                        
                         assert( parameterNameIndices.size() >= 0 && parameterNameIndices.size() <= MAX_UINT8 );
                         out.writeByte( parameterNameIndices.size() );
                         
@@ -70,7 +84,9 @@ public class MethodParametersAttribute extends AttributeInfo
                         }
                         
                         out.close();
-                        return buf.toByteArray();
+                        byte[] data = buf.toByteArray();
+                        assert( data.length == SIZEOF_UINT8 + parameterNameIndices.size()*( SIZEOF_UINT16 + SIZEOF_UINT16 ) );
+                        return data;
                 }
                 catch( IOException ex )
                 {