1 files changed, 27 insertions, 38 deletions

diff --git a/src/cuchaz/enigma/bytecode/MethodParametersAttribute.java b/src/cuchaz/enigma/bytecode/MethodParametersAttribute.java
index baf1ac1..bf95956 100644
--- a/src/cuchaz/enigma/bytecode/MethodParametersAttribute.java
+++ b/src/cuchaz/enigma/bytecode/MethodParametersAttribute.java
@@ -20,45 +20,38 @@ import javassist.bytecode.AttributeInfo;
 import javassist.bytecode.ConstPool;
 import javassist.bytecode.MethodInfo;
 
-public class MethodParametersAttribute extends AttributeInfo
-{
-        private MethodParametersAttribute( ConstPool pool, List<Integer> parameterNameIndices )
-        {
-                super( pool, "MethodParameters", writeStruct( parameterNameIndices ) );
+public class MethodParametersAttribute extends AttributeInfo {
+        
+        private MethodParametersAttribute(ConstPool pool, List<Integer> parameterNameIndices) {
+                super(pool, "MethodParameters", writeStruct(parameterNameIndices));
         }
         
-        public static void updateClass( MethodInfo info, List<String> names )
-        {
+        public static void updateClass(MethodInfo info, List<String> names) {
                 // 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 );
+                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 ) );
+                info.addAttribute(new MethodParametersAttribute(constPool, parameterNameIndices));
         }
         
-        private static byte[] writeStruct( List<Integer> 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
                 // uint8 num_params
                 // for each param:
-                //    uint16 name_index -> points to UTF8 entry in constant pool, or 0 for no entry
-                //    uint16 access_flags -> don't care, just set to 0
+                // uint16 name_index -> points to UTF8 entry in constant pool, or 0 for no entry
+                // uint16 access_flags -> don't care, just set to 0
                 
                 ByteArrayOutputStream buf = new ByteArrayOutputStream();
-                DataOutputStream out = new DataOutputStream( buf );
+                DataOutputStream out = new DataOutputStream(buf);
                 
                 // NOTE: java hates unsigned integers, so we have to be careful here
                 // the writeShort(), writeByte() methods will read 16,8 low-order bits from the int argument
@@ -66,31 +59,27 @@ public class MethodParametersAttribute extends AttributeInfo
                 // 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 int MAX_UINT8 = (1 << 8) - 1;
+                final int MAX_UINT16 = (1 << 16) - 1;
                 
-                try
-                {
-                        assert( parameterNameIndices.size() >= 0 && parameterNameIndices.size() <= MAX_UINT8 );
-                        out.writeByte( parameterNameIndices.size() );
+                try {
+                        assert (parameterNameIndices.size() >= 0 && parameterNameIndices.size() <= MAX_UINT8);
+                        out.writeByte(parameterNameIndices.size());
                         
-                        for( Integer index : parameterNameIndices )
-                        {
-                                assert( index >= 0 && index <= MAX_UINT16 );
-                                out.writeShort( index );
+                        for (Integer index : parameterNameIndices) {
+                                assert (index >= 0 && index <= MAX_UINT16);
+                                out.writeShort(index);
                                 
                                 // just write 0 for the access flags
-                                out.writeShort( 0 );
+                                out.writeShort(0);
                         }
                         
                         out.close();
                         byte[] data = buf.toByteArray();
-                        assert( data.length == SIZEOF_UINT8 + parameterNameIndices.size()*( SIZEOF_UINT16 + SIZEOF_UINT16 ) );
+                        assert (data.length == SIZEOF_UINT8 + parameterNameIndices.size() * (SIZEOF_UINT16 + SIZEOF_UINT16));
                         return data;
-                }
-                catch( IOException ex )
-                {
-                        throw new Error( ex );
+                } catch (IOException ex) {
+                        throw new Error(ex);
                 }
         }
 }