source format change

don't hate me too much if you were planning a big merge. =P

1 files changed, 115 insertions, 154 deletions

diff --git a/src/cuchaz/enigma/bytecode/BytecodeTools.java b/src/cuchaz/enigma/bytecode/BytecodeTools.java
index 4407a90..2e456f4 100644
--- a/src/cuchaz/enigma/bytecode/BytecodeTools.java
+++ b/src/cuchaz/enigma/bytecode/BytecodeTools.java
@@ -34,256 +34,222 @@ import cuchaz.enigma.Util;
 import cuchaz.enigma.bytecode.BytecodeIndexIterator.Index;
 import cuchaz.enigma.bytecode.accessors.ConstInfoAccessor;
 
-public class BytecodeTools
-{
-        public static byte[] writeBytecode( Bytecode bytecode )
-        throws IOException
-        {
+public class BytecodeTools {
+        
+        public static byte[] writeBytecode(Bytecode bytecode) throws IOException {
+                
                 ByteArrayOutputStream buf = new ByteArrayOutputStream();
-                DataOutputStream out = new DataOutputStream( buf );
-                try
-                {
+                DataOutputStream out = new DataOutputStream(buf);
+                
+                try {
                         // write the constant pool
-                        new ConstPoolEditor( bytecode.getConstPool() ).writePool( out );
+                        new ConstPoolEditor(bytecode.getConstPool()).writePool(out);
                         
                         // write metadata
-                        out.writeShort( bytecode.getMaxStack() );
-                        out.writeShort( bytecode.getMaxLocals() );
-                        out.writeShort( bytecode.getStackDepth() );
+                        out.writeShort(bytecode.getMaxStack());
+                        out.writeShort(bytecode.getMaxLocals());
+                        out.writeShort(bytecode.getStackDepth());
                         
                         // write the code
-                        out.writeShort( bytecode.getSize() );
-                        out.write( bytecode.get() );
+                        out.writeShort(bytecode.getSize());
+                        out.write(bytecode.get());
                         
                         // write the exception table
                         int numEntries = bytecode.getExceptionTable().size();
-                        out.writeShort( numEntries );
-                        for( int i=0; i<numEntries; i++ )
-                        {
-                                out.writeShort( bytecode.getExceptionTable().startPc( i ) );
-                                out.writeShort( bytecode.getExceptionTable().endPc( i ) );
-                                out.writeShort( bytecode.getExceptionTable().handlerPc( i ) );
-                                out.writeShort( bytecode.getExceptionTable().catchType( i ) );
+                        out.writeShort(numEntries);
+                        for (int i = 0; i < numEntries; i++) {
+                                out.writeShort(bytecode.getExceptionTable().startPc(i));
+                                out.writeShort(bytecode.getExceptionTable().endPc(i));
+                                out.writeShort(bytecode.getExceptionTable().handlerPc(i));
+                                out.writeShort(bytecode.getExceptionTable().catchType(i));
                         }
                         
                         out.close();
                         return buf.toByteArray();
-                }
-                catch( Exception ex )
-                {
-                        Util.closeQuietly( out );
-                        throw new Error( ex );
+                } catch (Exception ex) {
+                        Util.closeQuietly(out);
+                        throw new Error(ex);
                 }
         }
         
-        public static Bytecode readBytecode( byte[] bytes )
-        throws IOException
-        {
-                ByteArrayInputStream buf = new ByteArrayInputStream( bytes );
-                DataInputStream in = new DataInputStream( buf );
-                try
-                {
+        public static Bytecode readBytecode(byte[] bytes) throws IOException {
+                
+                ByteArrayInputStream buf = new ByteArrayInputStream(bytes);
+                DataInputStream in = new DataInputStream(buf);
+                
+                try {
                         // read the constant pool entries and update the class
-                        ConstPool pool = ConstPoolEditor.readPool( in );
+                        ConstPool pool = ConstPoolEditor.readPool(in);
                         
                         // read metadata
                         int maxStack = in.readShort();
                         int maxLocals = in.readShort();
                         int stackDepth = in.readShort();
                         
-                        Bytecode bytecode = new Bytecode( pool, maxStack, maxLocals );
-                        bytecode.setStackDepth( stackDepth );
+                        Bytecode bytecode = new Bytecode(pool, maxStack, maxLocals);
+                        bytecode.setStackDepth(stackDepth);
                         
                         // read the code
                         int size = in.readShort();
                         byte[] code = new byte[size];
-                        in.read( code );
-                        setBytecode( bytecode, code );
+                        in.read(code);
+                        setBytecode(bytecode, code);
                         
                         // read the exception table
                         int numEntries = in.readShort();
-                        for( int i=0; i<numEntries; i++ )
-                        {
-                                bytecode.getExceptionTable().add( in.readShort(), in.readShort(), in.readShort(), in.readShort() );
+                        for (int i = 0; i < numEntries; i++) {
+                                bytecode.getExceptionTable().add(in.readShort(), in.readShort(), in.readShort(), in.readShort());
                         }
                         
                         in.close();
                         return bytecode;
-                }
-                catch( Exception ex )
-                {
-                        Util.closeQuietly( in );
-                        throw new Error( ex );
+                } catch (Exception ex) {
+                        Util.closeQuietly(in);
+                        throw new Error(ex);
                 }
         }
         
-        public static Bytecode prepareMethodForBytecode( CtBehavior behavior, Bytecode bytecode )
-        throws BadBytecode
-        {
+        public static Bytecode prepareMethodForBytecode(CtBehavior behavior, Bytecode bytecode) throws BadBytecode {
+                
                 // update the destination class const pool
-                bytecode = copyBytecodeToConstPool( behavior.getMethodInfo().getConstPool(), bytecode );
+                bytecode = copyBytecodeToConstPool(behavior.getMethodInfo().getConstPool(), bytecode);
                 
                 // update method locals and stack
                 CodeAttribute attribute = behavior.getMethodInfo().getCodeAttribute();
-                if( bytecode.getMaxLocals() > attribute.getMaxLocals() )
-                {
-                        attribute.setMaxLocals( bytecode.getMaxLocals() );
+                if (bytecode.getMaxLocals() > attribute.getMaxLocals()) {
+                        attribute.setMaxLocals(bytecode.getMaxLocals());
                 }
-                if( bytecode.getMaxStack() > attribute.getMaxStack() )
-                {
-                        attribute.setMaxStack( bytecode.getMaxStack() );
+                if (bytecode.getMaxStack() > attribute.getMaxStack()) {
+                        attribute.setMaxStack(bytecode.getMaxStack());
                 }
                 
                 return bytecode;
         }
         
-        public static Bytecode copyBytecodeToConstPool( ConstPool dest, Bytecode bytecode )
-        throws BadBytecode
-        {
+        public static Bytecode copyBytecodeToConstPool(ConstPool dest, Bytecode bytecode) throws BadBytecode {
+                
                 // get the entries this bytecode needs from the const pool
                 Set<Integer> indices = Sets.newTreeSet();
-                ConstPoolEditor editor = new ConstPoolEditor( bytecode.getConstPool() );
-                BytecodeIndexIterator iterator = new BytecodeIndexIterator( bytecode );
-                for( Index index : iterator.indices() )
-                {
-                        assert( index.isValid( bytecode ) );
-                        InfoType.gatherIndexTree( indices, editor, index.getIndex() );
+                ConstPoolEditor editor = new ConstPoolEditor(bytecode.getConstPool());
+                BytecodeIndexIterator iterator = new BytecodeIndexIterator(bytecode);
+                for (Index index : iterator.indices()) {
+                        assert (index.isValid(bytecode));
+                        InfoType.gatherIndexTree(indices, editor, index.getIndex());
                 }
                 
                 Map<Integer,Integer> indexMap = Maps.newTreeMap();
                 
                 ConstPool src = bytecode.getConstPool();
-                ConstPoolEditor editorSrc = new ConstPoolEditor( src );
-                ConstPoolEditor editorDest = new ConstPoolEditor( dest );
+                ConstPoolEditor editorSrc = new ConstPoolEditor(src);
+                ConstPoolEditor editorDest = new ConstPoolEditor(dest);
                 
                 // copy entries over in order of level so the index mapping is easier
-                for( InfoType type : InfoType.getSortedByLevel() )
-                {
-                        for( int index : indices )
-                        {
-                                ConstInfoAccessor entry = editorSrc.getItem( index );
+                for (InfoType type : InfoType.getSortedByLevel()) {
+                        for (int index : indices) {
+                                ConstInfoAccessor entry = editorSrc.getItem(index);
                                 
                                 // skip entries that aren't this type
-                                if( entry.getType() != type )
-                                {
+                                if (entry.getType() != type) {
                                         continue;
                                 }
                                 
                                 // make sure the source entry is valid before we copy it
-                                assert( type.subIndicesAreValid( entry, editorSrc ) );
-                                assert( type.selfIndexIsValid( entry, editorSrc ) );
+                                assert (type.subIndicesAreValid(entry, editorSrc));
+                                assert (type.selfIndexIsValid(entry, editorSrc));
                                 
                                 // make a copy of the entry so we can modify it safely
-                                ConstInfoAccessor entryCopy = editorSrc.getItem( index ).copy();
-                                assert( type.subIndicesAreValid( entryCopy, editorSrc ) );
-                                assert( type.selfIndexIsValid( entryCopy, editorSrc ) );
+                                ConstInfoAccessor entryCopy = editorSrc.getItem(index).copy();
+                                assert (type.subIndicesAreValid(entryCopy, editorSrc));
+                                assert (type.selfIndexIsValid(entryCopy, editorSrc));
                                 
                                 // remap the indices
-                                type.remapIndices( indexMap, entryCopy );
-                                assert( type.subIndicesAreValid( entryCopy, editorDest ) );
+                                type.remapIndices(indexMap, entryCopy);
+                                assert (type.subIndicesAreValid(entryCopy, editorDest));
                                 
                                 // put the copy in the destination pool
-                                int newIndex = editorDest.addItem( entryCopy.getItem() );
-                                entryCopy.setIndex( newIndex );
-                                assert( type.selfIndexIsValid( entryCopy, editorDest ) ) : type + ", self: " + entryCopy + " dest: " + editorDest.getItem( entryCopy.getIndex() );
+                                int newIndex = editorDest.addItem(entryCopy.getItem());
+                                entryCopy.setIndex(newIndex);
+                                assert (type.selfIndexIsValid(entryCopy, editorDest)) : type + ", self: " + entryCopy + " dest: " + editorDest.getItem(entryCopy.getIndex());
                                 
                                 // make sure the source entry is unchanged
-                                assert( type.subIndicesAreValid( entry, editorSrc ) );
-                                assert( type.selfIndexIsValid( entry, editorSrc ) );
+                                assert (type.subIndicesAreValid(entry, editorSrc));
+                                assert (type.selfIndexIsValid(entry, editorSrc));
                                 
                                 // add the index mapping so we can update the bytecode later
-                                if( indexMap.containsKey( index ) )
-                                {
-                                        throw new Error( "Entry at index " + index + " already copied!" );
+                                if (indexMap.containsKey(index)) {
+                                        throw new Error("Entry at index " + index + " already copied!");
                                 }
-                                indexMap.put( index, newIndex );
+                                indexMap.put(index, newIndex);
                         }
                 }
                 
                 // make a new bytecode
-                Bytecode newBytecode = new Bytecode( dest, bytecode.getMaxStack(), bytecode.getMaxLocals() );
-                bytecode.setStackDepth( bytecode.getStackDepth() );
-                setBytecode( newBytecode, bytecode.get() );
-                setExceptionTable( newBytecode, bytecode.getExceptionTable() );
+                Bytecode newBytecode = new Bytecode(dest, bytecode.getMaxStack(), bytecode.getMaxLocals());
+                bytecode.setStackDepth(bytecode.getStackDepth());
+                setBytecode(newBytecode, bytecode.get());
+                setExceptionTable(newBytecode, bytecode.getExceptionTable());
                 
                 // apply the mappings to the bytecode
-                BytecodeIndexIterator iter = new BytecodeIndexIterator( newBytecode );
-                for( Index index : iter.indices() )
-                {
+                BytecodeIndexIterator iter = new BytecodeIndexIterator(newBytecode);
+                for (Index index : iter.indices()) {
                         int oldIndex = index.getIndex();
-                        Integer newIndex = indexMap.get( oldIndex );
-                        if( newIndex != null )
-                        {
+                        Integer newIndex = indexMap.get(oldIndex);
+                        if (newIndex != null) {
                                 // make sure this mapping makes sense
-                                InfoType typeSrc = editorSrc.getItem( oldIndex ).getType();
-                                InfoType typeDest = editorDest.getItem( newIndex ).getType();
-                                assert( typeSrc == typeDest );
+                                InfoType typeSrc = editorSrc.getItem(oldIndex).getType();
+                                InfoType typeDest = editorDest.getItem(newIndex).getType();
+                                assert (typeSrc == typeDest);
                                 
                                 // apply the mapping
-                                index.setIndex( newIndex );
+                                index.setIndex(newIndex);
                         }
                 }
                 iter.saveChangesToBytecode();
                 
                 // make sure all the indices are valid
-                iter = new BytecodeIndexIterator( newBytecode );
-                for( Index index : iter.indices() )
-                {
-                        assert( index.isValid( newBytecode ) );
+                iter = new BytecodeIndexIterator(newBytecode);
+                for (Index index : iter.indices()) {
+                        assert (index.isValid(newBytecode));
                 }
                 
                 return newBytecode;
         }
         
-        public static void setBytecode( Bytecode dest, byte[] src )
-        {
-                if( src.length > dest.getSize() )
-                {
-                        dest.addGap( src.length - dest.getSize() );
+        public static void setBytecode(Bytecode dest, byte[] src) {
+                if (src.length > dest.getSize()) {
+                        dest.addGap(src.length - dest.getSize());
                 }
-                assert( dest.getSize() == src.length );
-                for( int i=0; i<src.length; i++ )
-                {
-                        dest.write( i, src[i] );
+                assert (dest.getSize() == src.length);
+                for (int i = 0; i < src.length; i++) {
+                        dest.write(i, src[i]);
                 }
         }
         
-        public static void setExceptionTable( Bytecode dest, ExceptionTable src )
-        {
+        public static void setExceptionTable(Bytecode dest, ExceptionTable src) {
+                
                 // clear the dest exception table
                 int size = dest.getExceptionTable().size();
-                for( int i=size-1; i>=0; i-- )
-                {
-                        dest.getExceptionTable().remove( i );
+                for (int i = size - 1; i >= 0; i--) {
+                        dest.getExceptionTable().remove(i);
                 }
                 
                 // copy the exception table
-                for( int i=0; i<src.size(); i++ )
-                {
-                        dest.getExceptionTable().add(
-                                src.startPc( i ),
-                                src.endPc( i ),
-                                src.handlerPc( i ),
-                                src.catchType( i )
-                        );
+                for (int i = 0; i < src.size(); i++) {
+                        dest.getExceptionTable().add(src.startPc(i), src.endPc(i), src.handlerPc(i), src.catchType(i));
                 }
         }
         
-        public static List<String> getParameterTypes( String signature )
-        {
+        public static List<String> getParameterTypes(String signature) {
                 List<String> types = Lists.newArrayList();
-                for( int i=0; i<signature.length(); )
-                {
-                        char c = signature.charAt( i );
+                for (int i = 0; i < signature.length();) {
+                        char c = signature.charAt(i);
                         
                         // handle parens
-                        if( c == '(' )
-                        {
+                        if (c == '(') {
                                 i++;
-                                c = signature.charAt( i );
+                                c = signature.charAt(i);
                         }
-                        if( c == ')' )
-                        {
+                        if (c == ')') {
                                 break;
                         }
                         
@@ -291,35 +257,30 @@ public class BytecodeTools
                         String type = null;
                         
                         int arrayDim = 0;
-                        while( c == '[' )
-                        {
+                        while (c == '[') {
                                 // advance to array type
                                 arrayDim++;
                                 i++;
-                                c = signature.charAt( i );
+                                c = signature.charAt(i);
                         }
                         
-                        if( c == 'L' )
-                        {
+                        if (c == 'L') {
                                 // read class type
-                                int pos = signature.indexOf( ';', i + 1 );
-                                String className = signature.substring( i + 1, pos );
+                                int pos = signature.indexOf(';', i + 1);
+                                String className = signature.substring(i + 1, pos);
                                 type = "L" + className + ";";
                                 i = pos + 1;
-                        }
-                        else
-                        {
+                        } else {
                                 // read primitive type
-                                type = signature.substring( i, i + 1 );
+                                type = signature.substring(i, i + 1);
                                 i++;
                         }
                         
                         // was it an array?
-                        while( arrayDim-- > 0 )
-                        {
+                        while (arrayDim-- > 0) {
                                 type = "[" + type;
                         }
-                        types.add( type );
+                        types.add(type);
                 }
                 return types;
         }