added identifier renaming capability

copied some code over from M3L to handle the heavy bytecode magic.
It's ok... M3L will eventually depend on Enigma.
Completely restructured the mappings though. This way is better. =)

14 files changed, 2123 insertions, 0 deletions

diff --git a/src/cuchaz/enigma/bytecode/BytecodeIndexIterator.java b/src/cuchaz/enigma/bytecode/BytecodeIndexIterator.java
new file mode 100644
index 0000000..aadbeb2
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/BytecodeIndexIterator.java
@@ -0,0 +1,180 @@
+/*******************************************************************************
+ * 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.bytecode;
+
+import java.util.Iterator;
+
+import javassist.bytecode.BadBytecode;
+import javassist.bytecode.Bytecode;
+import javassist.bytecode.CodeAttribute;
+import javassist.bytecode.CodeIterator;
+import javassist.bytecode.Opcode;
+
+public class BytecodeIndexIterator implements Iterator<BytecodeIndexIterator.Index>
+{
+        public static class Index
+        {
+                private CodeIterator m_iter;
+                private int m_pos;
+                private boolean m_isWide;
+                
+                protected Index( CodeIterator iter, int pos, boolean isWide )
+                {
+                        m_iter = iter;
+                        m_pos = pos;
+                        m_isWide = isWide;
+                }
+                
+                public int getIndex( )
+                {
+                        if( m_isWide )
+                        {
+                                return m_iter.s16bitAt( m_pos );
+                        }
+                        else
+                        {
+                                return m_iter.byteAt( m_pos );
+                        }
+                }
+                
+                public void setIndex( int val )
+                throws BadBytecode
+                {
+                        if( m_isWide )
+                        {
+                                m_iter.write16bit( val, m_pos );
+                        }
+                        else
+                        {
+                                if( val < 256 )
+                                {
+                                        // we can write the byte
+                                        m_iter.writeByte( val, m_pos );
+                                }
+                                else
+                                {
+                                        // we need to upgrade this instruction to LDC_W
+                                        assert( m_iter.byteAt( m_pos - 1 ) == Opcode.LDC );
+                                        m_iter.insertGap( m_pos - 1, 1 );
+                                        m_iter.writeByte( Opcode.LDC_W, m_pos - 1 );
+                                        m_iter.write16bit( val, m_pos );
+                                        m_isWide = true;
+                                        
+                                        // move the iterator to the next opcode
+                                        m_iter.move( m_pos + 2 );
+                                }
+                        }
+                        
+                        // sanity check
+                        assert( val == getIndex() );
+                }
+                
+                public boolean isValid( Bytecode bytecode )
+                {
+                        return getIndex() >= 0 && getIndex() < bytecode.getConstPool().getSize();
+                }
+        }
+        
+        private Bytecode m_bytecode;
+        private CodeAttribute m_attribute;
+        private CodeIterator m_iter;
+        private Index m_next;
+        
+        public BytecodeIndexIterator( Bytecode bytecode )
+        throws BadBytecode
+        {
+                m_bytecode = bytecode;
+                m_attribute = bytecode.toCodeAttribute();
+                m_iter = m_attribute.iterator();
+                
+                m_next = getNext();
+        }
+        
+        @Override
+        public boolean hasNext( )
+        {
+                return m_next != null;
+        }
+
+        @Override
+        public Index next( )
+        {
+                Index out = m_next;
+                try
+                {
+                        m_next = getNext();
+                }
+                catch( BadBytecode ex )
+                {
+                        throw new Error( ex );
+                }
+                return out;
+        }
+
+        @Override
+        public void remove( )
+        {
+                throw new UnsupportedOperationException();
+        }
+        
+        private Index getNext( )
+        throws BadBytecode
+        {
+                while( m_iter.hasNext() )
+                {
+                        int pos = m_iter.next();
+                        int opcode = m_iter.byteAt( pos );
+                        switch( opcode )
+                        {
+                                // for only these opcodes, the next two bytes are a const pool reference
+                                case Opcode.ANEWARRAY:
+                                case Opcode.CHECKCAST:
+                                case Opcode.INSTANCEOF:
+                                case Opcode.INVOKEDYNAMIC:
+                                case Opcode.INVOKEINTERFACE:
+                                case Opcode.INVOKESPECIAL:
+                                case Opcode.INVOKESTATIC:
+                                case Opcode.INVOKEVIRTUAL:
+                                case Opcode.LDC_W:
+                                case Opcode.LDC2_W:
+                                case Opcode.MULTIANEWARRAY:
+                                case Opcode.NEW:
+                                case Opcode.PUTFIELD:
+                                case Opcode.PUTSTATIC:
+                                case Opcode.GETFIELD:
+                                case Opcode.GETSTATIC:
+                                        return new Index( m_iter, pos + 1, true );
+                                
+                                case Opcode.LDC:
+                                        return new Index( m_iter, pos + 1, false );
+                        }
+                }
+                
+                return null;
+        }
+        
+        public Iterable<Index> indices( )
+        {
+                return new Iterable<Index>( )
+                {
+                        @Override
+                        public Iterator<Index> iterator( )
+                        {
+                                return BytecodeIndexIterator.this;
+                        }
+                };
+        }
+        
+        public void saveChangesToBytecode( )
+        {
+                BytecodeTools.setBytecode( m_bytecode, m_attribute.getCode() );
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/BytecodeTools.java b/src/cuchaz/enigma/bytecode/BytecodeTools.java
new file mode 100644
index 0000000..664350e
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/BytecodeTools.java
@@ -0,0 +1,269 @@
+/*******************************************************************************
+ * 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.bytecode;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.Map;
+import java.util.Set;
+
+import javassist.CtBehavior;
+import javassist.bytecode.BadBytecode;
+import javassist.bytecode.Bytecode;
+import javassist.bytecode.CodeAttribute;
+import javassist.bytecode.ConstPool;
+import javassist.bytecode.ExceptionTable;
+
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+
+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
+        {
+                ByteArrayOutputStream buf = new ByteArrayOutputStream();
+                DataOutputStream out = new DataOutputStream( buf );
+                try
+                {
+                        // write the constant pool
+                        new ConstPoolEditor( bytecode.getConstPool() ).writePool( out );
+                        
+                        // write metadata
+                        out.writeShort( bytecode.getMaxStack() );
+                        out.writeShort( bytecode.getMaxLocals() );
+                        out.writeShort( bytecode.getStackDepth() );
+                        
+                        // write the code
+                        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.close();
+                        return buf.toByteArray();
+                }
+                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
+                {
+                        // read the constant pool entries and update the class
+                        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 );
+                        
+                        // read the code
+                        int size = in.readShort();
+                        byte[] code = new byte[size];
+                        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() );
+                        }
+                        
+                        in.close();
+                        return bytecode;
+                }
+                catch( Exception ex )
+                {
+                        Util.closeQuietly( in );
+                        throw new Error( ex );
+                }
+        }
+        
+        public static Bytecode prepareMethodForBytecode( CtBehavior behavior, Bytecode bytecode )
+        throws BadBytecode
+        {
+                // update the destination class const pool
+                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.getMaxStack() > attribute.getMaxStack() )
+                {
+                        attribute.setMaxStack( bytecode.getMaxStack() );
+                }
+                
+                return bytecode;
+        }
+        
+        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() );
+                }
+                
+                Map<Integer,Integer> indexMap = Maps.newTreeMap();
+                
+                ConstPool src = bytecode.getConstPool();
+                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 );
+                                
+                                // skip entries that aren't this 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 ) );
+                                
+                                // 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 ) );
+                                
+                                // remap the indices
+                                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() );
+                                
+                                // make sure the source entry is unchanged
+                                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!" );
+                                }
+                                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() );
+                
+                // apply the mappings to the bytecode
+                BytecodeIndexIterator iter = new BytecodeIndexIterator( newBytecode );
+                for( Index index : iter.indices() )
+                {
+                        int oldIndex = index.getIndex();
+                        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 );
+                                
+                                // apply the mapping
+                                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 ) );
+                }
+                
+                return newBytecode;
+        }
+        
+        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] );
+                }
+        }
+        
+        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 );
+                }
+                
+                // 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 )
+                        );
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/ClassTranslator.java b/src/cuchaz/enigma/bytecode/ClassTranslator.java
new file mode 100644
index 0000000..3b5beeb
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/ClassTranslator.java
@@ -0,0 +1,171 @@
+/*******************************************************************************
+ * 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.bytecode;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import javassist.ClassMap;
+import javassist.CtBehavior;
+import javassist.CtClass;
+import javassist.CtField;
+import javassist.CtMethod;
+import javassist.bytecode.ConstPool;
+import javassist.bytecode.Descriptor;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.FieldEntry;
+import cuchaz.enigma.mapping.MethodEntry;
+import cuchaz.enigma.mapping.Translator;
+
+public class ClassTranslator
+{
+        private Translator m_translator;
+        
+        public ClassTranslator( Translator translator )
+        {
+                m_translator = translator;
+        }
+        
+        public void translate( CtClass c )
+        {
+                // NOTE: the order of these translations is very important
+                
+                // translate all the field and method references in the code by editing the constant pool
+                ConstPool constants = c.getClassFile().getConstPool();
+                ConstPoolEditor editor = new ConstPoolEditor( constants );
+                for( int i=1; i<constants.getSize(); i++ )
+                {
+                        switch( constants.getTag( i ) )
+                        {
+                                case ConstPool.CONST_Fieldref:
+                                {
+                                        // translate the name
+                                        FieldEntry entry = new FieldEntry(
+                                                new ClassEntry( Descriptor.toJvmName( constants.getFieldrefClassName( i ) ) ),
+                                                constants.getFieldrefName( i )
+                                        );
+                                        String translatedName = m_translator.translate( entry );
+                                        if( translatedName == null )
+                                        {
+                                                translatedName = entry.getName();
+                                        }
+                                        
+                                        // translate the type
+                                        String type = constants.getFieldrefType( i );
+                                        String translatedType = m_translator.translateSignature( type );
+                                        
+                                        if( !entry.getName().equals( translatedName ) || !type.equals( translatedType ) )
+                                        {
+                                                editor.changeMemberrefNameAndType( i, translatedName, translatedType );
+                                        }
+                                }
+                                break;
+                                
+                                case ConstPool.CONST_Methodref:
+                                case ConstPool.CONST_InterfaceMethodref:
+                                {
+                                        // translate the name and type
+                                        MethodEntry entry = new MethodEntry(
+                                                new ClassEntry( Descriptor.toJvmName( editor.getMemberrefClassname( i ) ) ),
+                                                editor.getMemberrefName( i ),
+                                                editor.getMemberrefType( i )
+                                        );
+                                        String translatedName = m_translator.translate( entry );
+                                        if( translatedName == null )
+                                        {
+                                                translatedName = entry.getName();
+                                        }
+                                        String translatedSignature = m_translator.translateSignature( entry.getSignature() );
+                                        
+                                        if( !entry.getName().equals( translatedName ) || !entry.getSignature().equals( translatedSignature ) )
+                                        {
+                                                editor.changeMemberrefNameAndType( i, translatedName, translatedSignature );
+                                        }
+                                }
+                                break;
+                        }
+                }
+                
+                ClassEntry classEntry = new ClassEntry( Descriptor.toJvmName( c.getName() ) );
+                
+                // translate all the fields
+                for( CtField field : c.getDeclaredFields() )
+                {
+                        // translate the name
+                        FieldEntry entry = new FieldEntry( classEntry, field.getName() );
+                        String translatedName = m_translator.translate( entry );
+                        if( translatedName != null )
+                        {
+                                field.setName( translatedName );
+                        }
+                        
+                        // translate the type
+                        String translatedType = m_translator.translateSignature( field.getFieldInfo().getDescriptor() );
+                        field.getFieldInfo().setDescriptor( translatedType );
+                }
+                
+                // translate all the methods and constructors
+                for( CtBehavior behavior : c.getDeclaredBehaviors() )
+                {
+                        // translate the name
+                        MethodEntry entry = new MethodEntry( classEntry, behavior.getName(), behavior.getSignature() );
+                        String translatedName = m_translator.translate( entry );
+                        if( translatedName != null )
+                        {
+                                if( behavior instanceof CtMethod )
+                                {
+                                        ((CtMethod)behavior).setName( translatedName );
+                                }
+                        }
+
+                        // translate the type
+                        String translatedSignature = m_translator.translateSignature( behavior.getMethodInfo().getDescriptor() );
+                        behavior.getMethodInfo().setDescriptor( translatedSignature );
+                }
+                
+                // translate all the class names referenced in the code
+                // the above code only changed method/field/reference names and types, but not the class names themselves
+                Set<String> classNames = getAllClassNames( c );
+                ClassMap map = new ClassMap();
+                for( String className : classNames )
+                {
+                        String translatedName = m_translator.translateClass( className );
+                        if( translatedName != null )
+                        {
+                                map.put( className, translatedName );
+                        }
+                }
+                if( !map.isEmpty() )
+                {
+                        c.replaceClassName( map );
+                }
+        }
+        
+        private Set<String> getAllClassNames( CtClass c )
+        {
+                final Set<String> names = new HashSet<String>();
+                ClassMap map = new ClassMap( )
+                {
+                        @Override
+                        public Object get( Object obj )
+                        {
+                                if( obj instanceof String )
+                                {
+                                        names.add( (String)obj );
+                                }
+                                return null;
+                        }
+                        private static final long serialVersionUID = -202160293602070641L;
+                };
+                c.replaceClassName( map );
+                return names;
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/ConstPoolEditor.java b/src/cuchaz/enigma/bytecode/ConstPoolEditor.java
new file mode 100644
index 0000000..aa6149c
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/ConstPoolEditor.java
@@ -0,0 +1,316 @@
+/*******************************************************************************
+ * 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.bytecode;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+
+import javassist.bytecode.ConstPool;
+import javassist.bytecode.Descriptor;
+import cuchaz.enigma.bytecode.accessors.ClassInfoAccessor;
+import cuchaz.enigma.bytecode.accessors.ConstInfoAccessor;
+import cuchaz.enigma.bytecode.accessors.MemberRefInfoAccessor;
+
+public class ConstPoolEditor
+{
+        private static Method m_getItem;
+        private static Method m_addItem;
+        private static Method m_addItem0;
+        private static Field m_items;
+        private static Field m_cache;
+        private static Field m_numItems;
+        private static Field m_objects;
+        private static Field m_elements;
+        private static Method m_methodWritePool;
+        private static Constructor<ConstPool> m_constructorPool;
+        
+        static
+        {
+                try
+                {
+                        m_getItem = ConstPool.class.getDeclaredMethod( "getItem", int.class );
+                        m_getItem.setAccessible( true );
+                        
+                        m_addItem = ConstPool.class.getDeclaredMethod( "addItem", Class.forName( "javassist.bytecode.ConstInfo" ) );
+                        m_addItem.setAccessible( true );
+                        
+                        m_addItem0 = ConstPool.class.getDeclaredMethod( "addItem0", Class.forName( "javassist.bytecode.ConstInfo" ) );
+                        m_addItem0.setAccessible( true );
+                        
+                        m_items = ConstPool.class.getDeclaredField( "items" );
+                        m_items.setAccessible( true );
+                        
+                        m_cache = ConstPool.class.getDeclaredField( "itemsCache" );
+                        m_cache.setAccessible( true );
+                        
+                        m_numItems = ConstPool.class.getDeclaredField( "numOfItems" );
+                        m_numItems.setAccessible( true );
+                        
+                        m_objects = Class.forName( "javassist.bytecode.LongVector" ).getDeclaredField( "objects" );
+                        m_objects.setAccessible( true );
+                        
+                        m_elements = Class.forName( "javassist.bytecode.LongVector" ).getDeclaredField( "elements" );
+                        m_elements.setAccessible( true );
+                        
+                        m_methodWritePool = ConstPool.class.getDeclaredMethod( "write", DataOutputStream.class );
+                        m_methodWritePool.setAccessible( true );
+                        
+                        m_constructorPool = ConstPool.class.getDeclaredConstructor( DataInputStream.class );
+                        m_constructorPool.setAccessible( true );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        private ConstPool m_pool;
+        
+        public ConstPoolEditor( ConstPool pool )
+        {
+                m_pool = pool;
+        }
+        
+        public void writePool( DataOutputStream out )
+        {
+                try
+                {
+                        m_methodWritePool.invoke( m_pool, out );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public static ConstPool readPool( DataInputStream in )
+        {
+                try
+                {
+                        return m_constructorPool.newInstance( in );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public String getMemberrefClassname( int memberrefIndex )
+        {
+                return Descriptor.toJvmName( m_pool.getClassInfo( m_pool.getMemberClass( memberrefIndex ) ) );
+        }
+        
+        public String getMemberrefName( int memberrefIndex )
+        {
+                return m_pool.getUtf8Info( m_pool.getNameAndTypeName( m_pool.getMemberNameAndType( memberrefIndex ) ) );
+        }
+        
+        public String getMemberrefType( int memberrefIndex )
+        {
+                return m_pool.getUtf8Info( m_pool.getNameAndTypeDescriptor( m_pool.getMemberNameAndType( memberrefIndex ) ) );
+        }
+        
+        public ConstInfoAccessor getItem( int index )
+        {
+                try
+                {
+                        Object entry = m_getItem.invoke( m_pool, index );
+                        if( entry == null )
+                        {
+                                return null;
+                        }
+                        return new ConstInfoAccessor( entry );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public int addItem( Object item )
+        {
+                try
+                {
+                        return (Integer)m_addItem.invoke( m_pool, item );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public int addItemForceNew( Object item )
+        {
+                try
+                {
+                        return (Integer)m_addItem0.invoke( m_pool, item );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        @SuppressWarnings( "rawtypes" )
+        public void removeLastItem( )
+        {
+                try
+                {
+                        // remove the item from the cache
+                        HashMap cache = getCache();
+                        if( cache != null )
+                        {
+                                Object item = getItem( m_pool.getSize() - 1 );
+                                cache.remove( item );
+                        }
+                        
+                        // remove the actual item
+                        // based off of LongVector.addElement()
+                        Object items = m_items.get( m_pool );
+                        Object[][] objects = (Object[][])m_objects.get( items );
+                        int numElements = (Integer)m_elements.get( items ) - 1;
+                        int nth = numElements >> 7;
+                int offset = numElements & (128 - 1);
+                objects[nth][offset] = null;
+                        
+                        // decrement the number of items
+                        m_elements.set( items, numElements );
+                        m_numItems.set( m_pool, (Integer)m_numItems.get( m_pool ) - 1 );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        @SuppressWarnings( "rawtypes" )
+        /* TEMP */public HashMap getCache( )
+        {
+                try
+                {
+                        return (HashMap)m_cache.get( m_pool );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        @SuppressWarnings( { "rawtypes", "unchecked" } )
+        public void changeMemberrefNameAndType( int memberrefIndex, String newName, String newType )
+        {
+                // NOTE: when changing values, we always need to copy-on-write
+                try
+                {
+                        // get the memberref item
+                        Object item = getItem( memberrefIndex ).getItem();
+                        
+                        // update the cache
+                        HashMap cache = getCache();
+                        if( cache != null )
+                        {
+                                cache.remove( item );
+                        }
+                        
+                        new MemberRefInfoAccessor( item ).setNameAndTypeIndex( m_pool.addNameAndTypeInfo( newName, newType ) );
+                        
+                        // update the cache
+                        if( cache != null )
+                        {
+                                cache.put( item, item );
+                        }
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+                
+                // make sure the change worked
+                assert( newName.equals( getMemberrefName( memberrefIndex ) ) );
+                assert( newType.equals( getMemberrefType( memberrefIndex ) ) );
+        }
+        
+        @SuppressWarnings( { "rawtypes", "unchecked" } )
+        public void changeClassName( int classNameIndex, String newName )
+        {
+                // NOTE: when changing values, we always need to copy-on-write
+                try
+                {
+                        // get the class item
+                        Object item = getItem( classNameIndex ).getItem();
+                        
+                        // update the cache
+                        HashMap cache = getCache();
+                        if( cache != null )
+                        {
+                                cache.remove( item );
+                        }
+                        
+                        // add the new name and repoint the name-and-type to it
+                        new ClassInfoAccessor( item ).setNameIndex( m_pool.addUtf8Info( newName ) );
+                        
+                        // update the cache
+                        if( cache != null )
+                        {
+                                cache.put( item, item );
+                        }
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public static ConstPool newConstPool( )
+        {
+                // const pool expects the name of a class to initialize itself
+                // but we want an empty pool
+                // so give it a bogus name, and then clear the entries afterwards
+                ConstPool pool = new ConstPool( "a" );
+                
+                ConstPoolEditor editor = new ConstPoolEditor( pool );
+                int size = pool.getSize();
+                for( int i=0; i<size-1; i++ )
+                {
+                        editor.removeLastItem();
+                }
+                
+                // make sure the pool is actually empty
+                // although, in this case "empty" means one thing in it
+                // the JVM spec says index 0 should be reserved
+                assert( pool.getSize() == 1 );
+                assert( editor.getItem( 0 ) == null );
+                assert( editor.getItem( 1 ) == null );
+                assert( editor.getItem( 2 ) == null );
+                assert( editor.getItem( 3 ) == null );
+                
+                // also, clear the cache
+                editor.getCache().clear();
+                
+                return pool;
+        }
+        
+        public String dump( )
+        {
+                StringBuilder buf = new StringBuilder();
+                for( int i=1; i<m_pool.getSize(); i++ )
+                {
+                        buf.append( String.format( "%4d", i ) );
+                        buf.append( "   " );
+                        buf.append( getItem( i ).toString() );
+                        buf.append( "\n" );
+                }
+                return buf.toString();
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/InfoType.java b/src/cuchaz/enigma/bytecode/InfoType.java
new file mode 100644
index 0000000..fe03006
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/InfoType.java
@@ -0,0 +1,364 @@
+/*******************************************************************************
+ * 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.bytecode;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+
+import cuchaz.enigma.bytecode.accessors.ClassInfoAccessor;
+import cuchaz.enigma.bytecode.accessors.ConstInfoAccessor;
+import cuchaz.enigma.bytecode.accessors.InvokeDynamicInfoAccessor;
+import cuchaz.enigma.bytecode.accessors.MemberRefInfoAccessor;
+import cuchaz.enigma.bytecode.accessors.MethodHandleInfoAccessor;
+import cuchaz.enigma.bytecode.accessors.MethodTypeInfoAccessor;
+import cuchaz.enigma.bytecode.accessors.NameAndTypeInfoAccessor;
+import cuchaz.enigma.bytecode.accessors.StringInfoAccessor;
+
+public enum InfoType
+{
+        Utf8Info( 1, 0 ),
+        IntegerInfo( 3, 0 ),
+        FloatInfo( 4, 0 ),
+        LongInfo( 5, 0 ),
+        DoubleInfo( 6, 0 ),
+        ClassInfo( 7, 1 )
+        {
+                @Override
+                public void gatherIndexTree( Collection<Integer> indices, ConstPoolEditor editor, ConstInfoAccessor entry )
+                {
+                        ClassInfoAccessor accessor = new ClassInfoAccessor( entry.getItem() );
+                        gatherIndexTree( indices, editor, accessor.getNameIndex() );
+                }
+                
+                @Override
+                public void remapIndices( Map<Integer,Integer> map, ConstInfoAccessor entry )
+                {
+                        ClassInfoAccessor accessor = new ClassInfoAccessor( entry.getItem() );
+                        accessor.setNameIndex( remapIndex( map, accessor.getNameIndex() ) );
+                }
+                
+                @Override
+                public boolean subIndicesAreValid( ConstInfoAccessor entry, ConstPoolEditor pool )
+                {
+                        ClassInfoAccessor accessor = new ClassInfoAccessor( entry.getItem() );
+                        ConstInfoAccessor nameEntry = pool.getItem( accessor.getNameIndex() );
+                        return nameEntry != null && nameEntry.getTag() == Utf8Info.getTag();
+                }
+        },
+        StringInfo( 8, 1 )
+        {
+                @Override
+                public void gatherIndexTree( Collection<Integer> indices, ConstPoolEditor editor, ConstInfoAccessor entry )
+                {
+                        StringInfoAccessor accessor = new StringInfoAccessor( entry.getItem() );
+                        gatherIndexTree( indices, editor, accessor.getStringIndex() );
+                }
+                
+                @Override
+                public void remapIndices( Map<Integer,Integer> map, ConstInfoAccessor entry )
+                {
+                        StringInfoAccessor accessor = new StringInfoAccessor( entry.getItem() );
+                        accessor.setStringIndex( remapIndex( map, accessor.getStringIndex() ) );
+                }
+                
+                @Override
+                public boolean subIndicesAreValid( ConstInfoAccessor entry, ConstPoolEditor pool )
+                {
+                        StringInfoAccessor accessor = new StringInfoAccessor( entry.getItem() );
+                        ConstInfoAccessor stringEntry = pool.getItem( accessor.getStringIndex() );
+                        return stringEntry != null && stringEntry.getTag() == Utf8Info.getTag();
+                }
+        },
+        FieldRefInfo( 9, 2 )
+        {
+                @Override
+                public void gatherIndexTree( Collection<Integer> indices, ConstPoolEditor editor, ConstInfoAccessor entry )
+                {
+                        MemberRefInfoAccessor accessor = new MemberRefInfoAccessor( entry.getItem() );
+                        gatherIndexTree( indices, editor, accessor.getClassIndex() );
+                        gatherIndexTree( indices, editor, accessor.getNameAndTypeIndex() );
+                }
+                
+                @Override
+                public void remapIndices( Map<Integer,Integer> map, ConstInfoAccessor entry )
+                {
+                        MemberRefInfoAccessor accessor = new MemberRefInfoAccessor( entry.getItem() );
+                        accessor.setClassIndex( remapIndex( map, accessor.getClassIndex() ) );
+                        accessor.setNameAndTypeIndex( remapIndex( map, accessor.getNameAndTypeIndex() ) );
+                }
+
+                @Override
+                public boolean subIndicesAreValid( ConstInfoAccessor entry, ConstPoolEditor pool )
+                {
+                        MemberRefInfoAccessor accessor = new MemberRefInfoAccessor( entry.getItem() );
+                        ConstInfoAccessor classEntry = pool.getItem( accessor.getClassIndex() );
+                        ConstInfoAccessor nameAndTypeEntry = pool.getItem( accessor.getNameAndTypeIndex() );
+                        return classEntry != null && classEntry.getTag() == ClassInfo.getTag()
+                                && nameAndTypeEntry != null && nameAndTypeEntry.getTag() == NameAndTypeInfo.getTag();
+                }
+        },
+        MethodRefInfo( 10, 2 ) // same as FieldRefInfo
+        {
+                @Override
+                public void gatherIndexTree( Collection<Integer> indices, ConstPoolEditor editor, ConstInfoAccessor entry )
+                {
+                        FieldRefInfo.gatherIndexTree( indices, editor, entry );
+                }
+                
+                @Override
+                public void remapIndices( Map<Integer,Integer> map, ConstInfoAccessor entry )
+                {
+                        FieldRefInfo.remapIndices( map, entry );
+                }
+
+                @Override
+                public boolean subIndicesAreValid( ConstInfoAccessor entry, ConstPoolEditor pool )
+                {
+                        return FieldRefInfo.subIndicesAreValid( entry, pool );
+                }
+        },
+        InterfaceMethodRefInfo( 11, 2 ) // same as FieldRefInfo
+        {
+                @Override
+                public void gatherIndexTree( Collection<Integer> indices, ConstPoolEditor editor, ConstInfoAccessor entry )
+                {
+                        FieldRefInfo.gatherIndexTree( indices, editor, entry );
+                }
+                
+                @Override
+                public void remapIndices( Map<Integer,Integer> map, ConstInfoAccessor entry )
+                {
+                        FieldRefInfo.remapIndices( map, entry );
+                }
+
+                @Override
+                public boolean subIndicesAreValid( ConstInfoAccessor entry, ConstPoolEditor pool )
+                {
+                        return FieldRefInfo.subIndicesAreValid( entry, pool );
+                }
+        },
+        NameAndTypeInfo( 12, 1 )
+        {
+                @Override
+                public void gatherIndexTree( Collection<Integer> indices, ConstPoolEditor editor, ConstInfoAccessor entry )
+                {
+                        NameAndTypeInfoAccessor accessor = new NameAndTypeInfoAccessor( entry.getItem() );
+                        gatherIndexTree( indices, editor, accessor.getNameIndex() );
+                        gatherIndexTree( indices, editor, accessor.getTypeIndex() );
+                }
+                
+                @Override
+                public void remapIndices( Map<Integer,Integer> map, ConstInfoAccessor entry )
+                {
+                        NameAndTypeInfoAccessor accessor = new NameAndTypeInfoAccessor( entry.getItem() );
+                        accessor.setNameIndex( remapIndex( map, accessor.getNameIndex() ) );
+                        accessor.setTypeIndex( remapIndex( map, accessor.getTypeIndex() ) );
+                }
+                
+                @Override
+                public boolean subIndicesAreValid( ConstInfoAccessor entry, ConstPoolEditor pool )
+                {
+                        NameAndTypeInfoAccessor accessor = new NameAndTypeInfoAccessor( entry.getItem() );
+                        ConstInfoAccessor nameEntry = pool.getItem( accessor.getNameIndex() );
+                        ConstInfoAccessor typeEntry = pool.getItem( accessor.getTypeIndex() );
+                        return nameEntry != null && nameEntry.getTag() == Utf8Info.getTag()
+                                && typeEntry != null && typeEntry.getTag() == Utf8Info.getTag();
+                }
+        },
+        MethodHandleInfo( 15, 3 )
+        {
+                @Override
+                public void gatherIndexTree( Collection<Integer> indices, ConstPoolEditor editor, ConstInfoAccessor entry )
+                {
+                        MethodHandleInfoAccessor accessor = new MethodHandleInfoAccessor( entry.getItem() );
+                        gatherIndexTree( indices, editor, accessor.getTypeIndex() );
+                        gatherIndexTree( indices, editor, accessor.getMethodRefIndex() );
+                }
+                
+                @Override
+                public void remapIndices( Map<Integer,Integer> map, ConstInfoAccessor entry )
+                {
+                        MethodHandleInfoAccessor accessor = new MethodHandleInfoAccessor( entry.getItem() );
+                        accessor.setTypeIndex( remapIndex( map, accessor.getTypeIndex() ) );
+                        accessor.setMethodRefIndex( remapIndex( map, accessor.getMethodRefIndex() ) );
+                }
+
+                @Override
+                public boolean subIndicesAreValid( ConstInfoAccessor entry, ConstPoolEditor pool )
+                {
+                        MethodHandleInfoAccessor accessor = new MethodHandleInfoAccessor( entry.getItem() );
+                        ConstInfoAccessor typeEntry = pool.getItem( accessor.getTypeIndex() );
+                        ConstInfoAccessor methodRefEntry = pool.getItem( accessor.getMethodRefIndex() );
+                        return typeEntry != null && typeEntry.getTag() == Utf8Info.getTag()
+                                && methodRefEntry != null && methodRefEntry.getTag() == MethodRefInfo.getTag();
+                }
+        },
+        MethodTypeInfo( 16, 1 )
+        {
+                @Override
+                public void gatherIndexTree( Collection<Integer> indices, ConstPoolEditor editor, ConstInfoAccessor entry )
+                {
+                        MethodTypeInfoAccessor accessor = new MethodTypeInfoAccessor( entry.getItem() );
+                        gatherIndexTree( indices, editor, accessor.getTypeIndex() );
+                }
+                
+                @Override
+                public void remapIndices( Map<Integer,Integer> map, ConstInfoAccessor entry )
+                {
+                        MethodTypeInfoAccessor accessor = new MethodTypeInfoAccessor( entry.getItem() );
+                        accessor.setTypeIndex( remapIndex( map, accessor.getTypeIndex() ) );
+                }
+
+                @Override
+                public boolean subIndicesAreValid( ConstInfoAccessor entry, ConstPoolEditor pool )
+                {
+                        MethodTypeInfoAccessor accessor = new MethodTypeInfoAccessor( entry.getItem() );
+                        ConstInfoAccessor typeEntry = pool.getItem( accessor.getTypeIndex() );
+                        return typeEntry != null && typeEntry.getTag() == Utf8Info.getTag();
+                }
+        },
+        InvokeDynamicInfo( 18, 2 )
+        {
+                @Override
+                public void gatherIndexTree( Collection<Integer> indices, ConstPoolEditor editor, ConstInfoAccessor entry )
+                {
+                        InvokeDynamicInfoAccessor accessor = new InvokeDynamicInfoAccessor( entry.getItem() );
+                        gatherIndexTree( indices, editor, accessor.getBootstrapIndex() );
+                        gatherIndexTree( indices, editor, accessor.getNameAndTypeIndex() );
+                }
+                
+                @Override
+                public void remapIndices( Map<Integer,Integer> map, ConstInfoAccessor entry )
+                {
+                        InvokeDynamicInfoAccessor accessor = new InvokeDynamicInfoAccessor( entry.getItem() );
+                        accessor.setBootstrapIndex( remapIndex( map, accessor.getBootstrapIndex() ) );
+                        accessor.setNameAndTypeIndex( remapIndex( map, accessor.getNameAndTypeIndex() ) );
+                }
+
+                @Override
+                public boolean subIndicesAreValid( ConstInfoAccessor entry, ConstPoolEditor pool )
+                {
+                        InvokeDynamicInfoAccessor accessor = new InvokeDynamicInfoAccessor( entry.getItem() );
+                        ConstInfoAccessor bootstrapEntry = pool.getItem( accessor.getBootstrapIndex() );
+                        ConstInfoAccessor nameAndTypeEntry = pool.getItem( accessor.getNameAndTypeIndex() );
+                        return bootstrapEntry != null && bootstrapEntry.getTag() == Utf8Info.getTag()
+                                && nameAndTypeEntry != null && nameAndTypeEntry.getTag() == NameAndTypeInfo.getTag();
+                }
+        };
+        
+        private static Map<Integer,InfoType> m_types;
+        
+        static
+        {
+                m_types = Maps.newTreeMap();
+                for( InfoType type : values() )
+                {
+                        m_types.put( type.getTag(), type );
+                }
+        }
+        
+        private int m_tag;
+        private int m_level;
+        
+        private InfoType( int tag, int level )
+        {
+                m_tag = tag;
+                m_level = level;
+        }
+        
+        public int getTag( )
+        {
+                return m_tag;
+        }
+        
+        public int getLevel( )
+        {
+                return m_level;
+        }
+        
+        public void gatherIndexTree( Collection<Integer> indices, ConstPoolEditor editor, ConstInfoAccessor entry )
+        {
+                // by default, do nothing
+        }
+        
+        public void remapIndices( Map<Integer,Integer> map, ConstInfoAccessor entry )
+        {
+                // by default, do nothing
+        }
+        
+        public boolean subIndicesAreValid( ConstInfoAccessor entry, ConstPoolEditor pool )
+        {
+                // by default, everything is good
+                return true;
+        }
+        
+        public boolean selfIndexIsValid( ConstInfoAccessor entry, ConstPoolEditor pool )
+        {
+                ConstInfoAccessor entryCheck = pool.getItem( entry.getIndex() );
+                if( entryCheck == null )
+                {
+                        return false;
+                }
+                return entryCheck.getItem().equals( entry.getItem() );
+        }
+        
+        public static InfoType getByTag( int tag )
+        {
+                return m_types.get( tag );
+        }
+        
+        public static List<InfoType> getByLevel( int level )
+        {
+                List<InfoType> types = Lists.newArrayList();
+                for( InfoType type : values() )
+                {
+                        if( type.getLevel() == level )
+                        {
+                                types.add( type );
+                        }
+                }
+                return types;
+        }
+        
+        public static List<InfoType> getSortedByLevel( )
+        {
+                List<InfoType> types = Lists.newArrayList();
+                types.addAll( getByLevel( 0 ) );
+                types.addAll( getByLevel( 1 ) );
+                types.addAll( getByLevel( 2 ) );
+                types.addAll( getByLevel( 3 ) );
+                return types;
+        }
+        
+        public static void gatherIndexTree( Collection<Integer> indices, ConstPoolEditor editor, int index )
+        {
+                // add own index
+                indices.add( index );
+                
+                // recurse
+                ConstInfoAccessor entry = editor.getItem( index );
+                entry.getType().gatherIndexTree( indices, editor, entry );
+        }
+        
+        private static int remapIndex( Map<Integer,Integer> map, int index )
+        {
+                Integer newIndex = map.get( index );
+                if( newIndex == null )
+                {
+                        newIndex = index;
+                }
+                return newIndex;
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/accessors/ClassInfoAccessor.java b/src/cuchaz/enigma/bytecode/accessors/ClassInfoAccessor.java
new file mode 100644
index 0000000..41e1d04
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/accessors/ClassInfoAccessor.java
@@ -0,0 +1,69 @@
+/*******************************************************************************
+ * 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.bytecode.accessors;
+
+import java.lang.reflect.Field;
+
+public class ClassInfoAccessor
+{
+        private static Class<?> m_class;
+        private static Field m_nameIndex;
+        
+        static
+        {
+                try
+                {
+                        m_class = Class.forName( "javassist.bytecode.ClassInfo" );
+                        m_nameIndex = m_class.getDeclaredField( "name" );
+                        m_nameIndex.setAccessible( true );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public static boolean isType( ConstInfoAccessor accessor )
+        {
+                return m_class.isAssignableFrom( accessor.getItem().getClass() );
+        }
+        
+        private Object m_item;
+        
+        public ClassInfoAccessor( Object item )
+        {
+                m_item = item;
+        }
+        
+        public int getNameIndex( )
+        {
+                try
+                {
+                        return (Integer)m_nameIndex.get( m_item );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public void setNameIndex( int val )
+        {
+                try
+                {
+                        m_nameIndex.set( m_item, val );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/accessors/ConstInfoAccessor.java b/src/cuchaz/enigma/bytecode/accessors/ConstInfoAccessor.java
new file mode 100644
index 0000000..3c3d3fa
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/accessors/ConstInfoAccessor.java
@@ -0,0 +1,199 @@
+/*******************************************************************************
+ * 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.bytecode.accessors;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+import cuchaz.enigma.bytecode.InfoType;
+
+public class ConstInfoAccessor
+{
+        private static Class<?> m_class;
+        private static Field m_index;
+        private static Method m_getTag;
+        
+        static
+        {
+                try
+                {
+                        m_class = Class.forName( "javassist.bytecode.ConstInfo" );
+                        m_index = m_class.getDeclaredField( "index" );
+                        m_index.setAccessible( true );
+                        m_getTag = m_class.getMethod( "getTag" );
+                        m_getTag.setAccessible( true );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        private Object m_item;
+        
+        public ConstInfoAccessor( Object item )
+        {
+                if( item == null )
+                {
+                        throw new IllegalArgumentException( "item cannot be null!" );
+                }
+                m_item = item;
+        }
+        
+        public ConstInfoAccessor( DataInputStream in )
+        throws IOException
+        {
+                try
+                {
+                        // read the entry
+                        String className = in.readUTF();
+                        int oldIndex = in.readInt();
+                        
+                        // NOTE: ConstInfo instances write a type id (a "tag"), but they don't read it back
+                        // so we have to read it here
+                        in.readByte();
+                        
+                        Constructor<?> constructor = Class.forName( className ).getConstructor( DataInputStream.class, int.class );
+                        constructor.setAccessible( true );
+                        m_item = constructor.newInstance( in, oldIndex );
+                }
+                catch( IOException ex )
+                {
+                        throw ex;
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public Object getItem( )
+        {
+                return m_item;
+        }
+        
+        public int getIndex( )
+        {
+                try
+                {
+                        return (Integer)m_index.get( m_item );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public void setIndex( int val )
+        {
+                try
+                {
+                        m_index.set( m_item, val );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public int getTag( )
+        {
+                try
+                {
+                        return (Integer)m_getTag.invoke( m_item );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public ConstInfoAccessor copy( )
+        {
+                return new ConstInfoAccessor( copyItem() );
+        }
+        
+        public Object copyItem( )
+        {
+                // I don't know of a simpler way to copy one of these silly things...
+                try
+                {
+                        // serialize the item
+                        ByteArrayOutputStream buf = new ByteArrayOutputStream();
+                        DataOutputStream out = new DataOutputStream( buf );
+                        write( out );
+                        
+                        // deserialize the item
+                        DataInputStream in = new DataInputStream( new ByteArrayInputStream( buf.toByteArray() ) );
+                        Object item = new ConstInfoAccessor( in ).getItem();
+                        in.close();
+                        
+                        return item;
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public void write( DataOutputStream out )
+        throws IOException
+        {
+                try
+                {
+                        out.writeUTF( m_item.getClass().getName() );
+                        out.writeInt( getIndex() );
+                        
+                        Method method = m_item.getClass().getMethod( "write", DataOutputStream.class );
+                        method.setAccessible( true );
+                        method.invoke( m_item, out );
+                }
+                catch( IOException ex )
+                {
+                        throw ex;
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        @Override
+        public String toString( )
+        {
+                try
+                {
+                        ByteArrayOutputStream buf = new ByteArrayOutputStream();
+                        PrintWriter out = new PrintWriter( buf );
+                        Method print = m_item.getClass().getMethod( "print", PrintWriter.class );
+                        print.setAccessible( true );
+                        print.invoke( m_item, out );
+                        out.close();
+                        return buf.toString().replace( "\n", "" );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public InfoType getType( )
+        {
+                return InfoType.getByTag( getTag() );
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/accessors/InvokeDynamicInfoAccessor.java b/src/cuchaz/enigma/bytecode/accessors/InvokeDynamicInfoAccessor.java
new file mode 100644
index 0000000..169306a
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/accessors/InvokeDynamicInfoAccessor.java
@@ -0,0 +1,96 @@
+/*******************************************************************************
+ * 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.bytecode.accessors;
+
+import java.lang.reflect.Field;
+
+public class InvokeDynamicInfoAccessor
+{
+        private static Class<?> m_class;
+        private static Field m_bootstrapIndex;
+        private static Field m_nameAndTypeIndex;
+        
+        static
+        {
+                try
+                {
+                        m_class = Class.forName( "javassist.bytecode.InvokeDynamicInfo" );
+                        m_bootstrapIndex = m_class.getDeclaredField( "bootstrap" );
+                        m_bootstrapIndex.setAccessible( true );
+                        m_nameAndTypeIndex = m_class.getDeclaredField( "nameAndType" );
+                        m_nameAndTypeIndex.setAccessible( true );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public static boolean isType( ConstInfoAccessor accessor )
+        {
+                return m_class.isAssignableFrom( accessor.getItem().getClass() );
+        }
+        
+        private Object m_item;
+        
+        public InvokeDynamicInfoAccessor( Object item )
+        {
+                m_item = item;
+        }
+        
+        public int getBootstrapIndex( )
+        {
+                try
+                {
+                        return (Integer)m_bootstrapIndex.get( m_item );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public void setBootstrapIndex( int val )
+        {
+                try
+                {
+                        m_bootstrapIndex.set( m_item, val );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public int getNameAndTypeIndex( )
+        {
+                try
+                {
+                        return (Integer)m_nameAndTypeIndex.get( m_item );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public void setNameAndTypeIndex( int val )
+        {
+                try
+                {
+                        m_nameAndTypeIndex.set( m_item, val );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/accessors/MemberRefInfoAccessor.java b/src/cuchaz/enigma/bytecode/accessors/MemberRefInfoAccessor.java
new file mode 100644
index 0000000..2ee3aff
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/accessors/MemberRefInfoAccessor.java
@@ -0,0 +1,96 @@
+/*******************************************************************************
+ * 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.bytecode.accessors;
+
+import java.lang.reflect.Field;
+
+public class MemberRefInfoAccessor
+{
+        private static Class<?> m_class;
+        private static Field m_classIndex;
+        private static Field m_nameAndTypeIndex;
+        
+        static
+        {
+                try
+                {
+                        m_class = Class.forName( "javassist.bytecode.MemberrefInfo" );
+                        m_classIndex = m_class.getDeclaredField( "classIndex" );
+                        m_classIndex.setAccessible( true );
+                        m_nameAndTypeIndex = m_class.getDeclaredField( "nameAndTypeIndex" );
+                        m_nameAndTypeIndex.setAccessible( true );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public static boolean isType( ConstInfoAccessor accessor )
+        {
+                return m_class.isAssignableFrom( accessor.getItem().getClass() );
+        }
+        
+        private Object m_item;
+        
+        public MemberRefInfoAccessor( Object item )
+        {
+                m_item = item;
+        }
+        
+        public int getClassIndex( )
+        {
+                try
+                {
+                        return (Integer)m_classIndex.get( m_item );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public void setClassIndex( int val )
+        {
+                try
+                {
+                        m_classIndex.set( m_item, val );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public int getNameAndTypeIndex( )
+        {
+                try
+                {
+                        return (Integer)m_nameAndTypeIndex.get( m_item );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public void setNameAndTypeIndex( int val )
+        {
+                try
+                {
+                        m_nameAndTypeIndex.set( m_item, val );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/accessors/MethodHandleInfoAccessor.java b/src/cuchaz/enigma/bytecode/accessors/MethodHandleInfoAccessor.java
new file mode 100644
index 0000000..27b7aee
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/accessors/MethodHandleInfoAccessor.java
@@ -0,0 +1,96 @@
+/*******************************************************************************
+ * 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.bytecode.accessors;
+
+import java.lang.reflect.Field;
+
+public class MethodHandleInfoAccessor
+{
+        private static Class<?> m_class;
+        private static Field m_kindIndex;
+        private static Field m_indexIndex;
+        
+        static
+        {
+                try
+                {
+                        m_class = Class.forName( "javassist.bytecode.MethodHandleInfo" );
+                        m_kindIndex = m_class.getDeclaredField( "refKind" );
+                        m_kindIndex.setAccessible( true );
+                        m_indexIndex = m_class.getDeclaredField( "refIndex" );
+                        m_indexIndex.setAccessible( true );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public static boolean isType( ConstInfoAccessor accessor )
+        {
+                return m_class.isAssignableFrom( accessor.getItem().getClass() );
+        }
+        
+        private Object m_item;
+        
+        public MethodHandleInfoAccessor( Object item )
+        {
+                m_item = item;
+        }
+        
+        public int getTypeIndex( )
+        {
+                try
+                {
+                        return (Integer)m_kindIndex.get( m_item );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public void setTypeIndex( int val )
+        {
+                try
+                {
+                        m_kindIndex.set( m_item, val );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public int getMethodRefIndex( )
+        {
+                try
+                {
+                        return (Integer)m_indexIndex.get( m_item );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public void setMethodRefIndex( int val )
+        {
+                try
+                {
+                        m_indexIndex.set( m_item, val );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/accessors/MethodTypeInfoAccessor.java b/src/cuchaz/enigma/bytecode/accessors/MethodTypeInfoAccessor.java
new file mode 100644
index 0000000..4cba6a2
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/accessors/MethodTypeInfoAccessor.java
@@ -0,0 +1,69 @@
+/*******************************************************************************
+ * 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.bytecode.accessors;
+
+import java.lang.reflect.Field;
+
+public class MethodTypeInfoAccessor
+{
+        private static Class<?> m_class;
+        private static Field m_descriptorIndex;
+        
+        static
+        {
+                try
+                {
+                        m_class = Class.forName( "javassist.bytecode.MethodTypeInfo" );
+                        m_descriptorIndex = m_class.getDeclaredField( "descriptor" );
+                        m_descriptorIndex.setAccessible( true );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public static boolean isType( ConstInfoAccessor accessor )
+        {
+                return m_class.isAssignableFrom( accessor.getItem().getClass() );
+        }
+        
+        private Object m_item;
+        
+        public MethodTypeInfoAccessor( Object item )
+        {
+                m_item = item;
+        }
+        
+        public int getTypeIndex( )
+        {
+                try
+                {
+                        return (Integer)m_descriptorIndex.get( m_item );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public void setTypeIndex( int val )
+        {
+                try
+                {
+                        m_descriptorIndex.set( m_item, val );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/accessors/NameAndTypeInfoAccessor.java b/src/cuchaz/enigma/bytecode/accessors/NameAndTypeInfoAccessor.java
new file mode 100644
index 0000000..03b4de3
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/accessors/NameAndTypeInfoAccessor.java
@@ -0,0 +1,96 @@
+/*******************************************************************************
+ * 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.bytecode.accessors;
+
+import java.lang.reflect.Field;
+
+public class NameAndTypeInfoAccessor
+{
+        private static Class<?> m_class;
+        private static Field m_nameIndex;
+        private static Field m_typeIndex;
+        
+        static
+        {
+                try
+                {
+                        m_class = Class.forName( "javassist.bytecode.NameAndTypeInfo" );
+                        m_nameIndex = m_class.getDeclaredField( "memberName" );
+                        m_nameIndex.setAccessible( true );
+                        m_typeIndex = m_class.getDeclaredField( "typeDescriptor" );
+                        m_typeIndex.setAccessible( true );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public static boolean isType( ConstInfoAccessor accessor )
+        {
+                return m_class.isAssignableFrom( accessor.getItem().getClass() );
+        }
+        
+        private Object m_item;
+        
+        public NameAndTypeInfoAccessor( Object item )
+        {
+                m_item = item;
+        }
+        
+        public int getNameIndex( )
+        {
+                try
+                {
+                        return (Integer)m_nameIndex.get( m_item );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public void setNameIndex( int val )
+        {
+                try
+                {
+                        m_nameIndex.set( m_item, val );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public int getTypeIndex( )
+        {
+                try
+                {
+                        return (Integer)m_typeIndex.get( m_item );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public void setTypeIndex( int val )
+        {
+                try
+                {
+                        m_typeIndex.set( m_item, val );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/accessors/StringInfoAccessor.java b/src/cuchaz/enigma/bytecode/accessors/StringInfoAccessor.java
new file mode 100644
index 0000000..5cdfce4
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/accessors/StringInfoAccessor.java
@@ -0,0 +1,69 @@
+/*******************************************************************************
+ * 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.bytecode.accessors;
+
+import java.lang.reflect.Field;
+
+public class StringInfoAccessor
+{
+        private static Class<?> m_class;
+        private static Field m_stringIndex;
+        
+        static
+        {
+                try
+                {
+                        m_class = Class.forName( "javassist.bytecode.StringInfo" );
+                        m_stringIndex = m_class.getDeclaredField( "string" );
+                        m_stringIndex.setAccessible( true );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public static boolean isType( ConstInfoAccessor accessor )
+        {
+                return m_class.isAssignableFrom( accessor.getItem().getClass() );
+        }
+        
+        private Object m_item;
+        
+        public StringInfoAccessor( Object item )
+        {
+                m_item = item;
+        }
+        
+        public int getStringIndex( )
+        {
+                try
+                {
+                        return (Integer)m_stringIndex.get( m_item );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public void setStringIndex( int val )
+        {
+                try
+                {
+                        m_stringIndex.set( m_item, val );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/accessors/Utf8InfoAccessor.java b/src/cuchaz/enigma/bytecode/accessors/Utf8InfoAccessor.java
new file mode 100644
index 0000000..1cadd83
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/accessors/Utf8InfoAccessor.java
@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * 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.bytecode.accessors;
+
+public class Utf8InfoAccessor
+{
+        private static Class<?> m_class;
+        
+        static
+        {
+                try
+                {
+                        m_class = Class.forName( "javassist.bytecode.Utf8Info" );
+                }
+                catch( Exception ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        public static boolean isType( ConstInfoAccessor accessor )
+        {
+                return m_class.isAssignableFrom( accessor.getItem().getClass() );
+        }
+}