started on mapping converter tool so we can update to newer Minecraft jars

1 files changed, 255 insertions, 0 deletions

diff --git a/src/cuchaz/enigma/convert/ClassIdentity.java b/src/cuchaz/enigma/convert/ClassIdentity.java
new file mode 100644
index 0000000..aecf7fc
--- /dev/null
+++ b/src/cuchaz/enigma/convert/ClassIdentity.java
@@ -0,0 +1,255 @@
+/*******************************************************************************
+ * 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.convert;
+
+import java.io.UnsupportedEncodingException;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import javassist.CtBehavior;
+import javassist.CtClass;
+import javassist.CtConstructor;
+import javassist.CtField;
+import javassist.CtMethod;
+import javassist.bytecode.BadBytecode;
+import javassist.bytecode.CodeIterator;
+import javassist.bytecode.ConstPool;
+import javassist.bytecode.Descriptor;
+import javassist.bytecode.Opcode;
+
+import com.beust.jcommander.internal.Maps;
+import com.beust.jcommander.internal.Sets;
+import com.google.common.collect.Lists;
+
+import cuchaz.enigma.Util;
+import cuchaz.enigma.bytecode.ConstPoolEditor;
+import cuchaz.enigma.bytecode.InfoType;
+import cuchaz.enigma.bytecode.accessors.ConstInfoAccessor;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.SignatureUpdater;
+import cuchaz.enigma.mapping.SignatureUpdater.ClassNameUpdater;
+
+public class ClassIdentity
+{
+        private ClassEntry m_classEntry;
+        private Set<String> m_fields;
+        private Set<String> m_methods;
+        private Set<String> m_constructors;
+        private String m_staticInitializer;
+        
+        public ClassIdentity( CtClass c )
+        {
+                m_classEntry = new ClassEntry( Descriptor.toJvmName( c.getName() ) );
+                m_fields = Sets.newHashSet();
+                for( CtField field : c.getDeclaredFields() )
+                {
+                        m_fields.add( scrubSignature( scrubSignature( field.getSignature() ) ) );
+                }
+                m_methods = Sets.newHashSet();
+                for( CtMethod method : c.getDeclaredMethods() )
+                {
+                        m_methods.add( scrubSignature( method.getSignature() ) + "0x" + getBehaviorSignature( method ) );
+                }
+                m_constructors = Sets.newHashSet();
+                for( CtConstructor constructor : c.getDeclaredConstructors() )
+                {
+                        m_constructors.add( scrubSignature( constructor.getSignature() ) + "0x" + getBehaviorSignature( constructor ) );
+                }
+                m_staticInitializer = "";
+                if( c.getClassInitializer() != null )
+                {
+                        m_staticInitializer = getBehaviorSignature( c.getClassInitializer() );
+                }
+        }
+
+        public ClassEntry getClassEntry( )
+        {
+                return m_classEntry;
+        }
+        
+        @Override
+        public String toString( )
+        {
+                StringBuilder buf = new StringBuilder();
+                buf.append( "class: " );
+                buf.append( hashCode() );
+                buf.append( "\n" );
+                for( String field : m_fields )
+                {
+                        buf.append( "\tfield " );
+                        buf.append( field );
+                        buf.append( "\n" );
+                }
+                for( String method : m_methods )
+                {
+                        buf.append( "\tmethod " );
+                        buf.append( method );
+                        buf.append( "\n" );
+                }
+                for( String constructor : m_constructors )
+                {
+                        buf.append( "\tconstructor " );
+                        buf.append( constructor );
+                        buf.append( "\n" );
+                }
+                if( m_staticInitializer.length() > 0 )
+                {
+                        buf.append( "\tinitializer " );
+                        buf.append( m_staticInitializer );
+                        buf.append( "\n" );
+                }
+                return buf.toString();
+        }
+        
+        private String scrubSignature( String signature )
+        {
+                return SignatureUpdater.update( signature, new ClassNameUpdater( )
+                {
+                        private Map<String,String> m_classNames = Maps.newHashMap();
+                        
+                        @Override
+                        public String update( String className )
+                        {
+                                // does the class have a package?
+                                if( className.indexOf( '/' ) >= 0 )
+                                {
+                                        return className;
+                                }
+                                
+                                if( !m_classNames.containsKey( className ) )
+                                {
+                                        m_classNames.put( className, getNewClassName() );
+                                }
+                                return m_classNames.get( className );
+                        }
+
+                        private String getNewClassName( )
+                        {
+                                return String.format( "C%03d", m_classNames.size() );
+                        }
+                } );
+        }
+        
+        private String getBehaviorSignature( CtBehavior behavior )
+        {
+                try
+                {
+                        // does this method have an implementation?
+                        if( behavior.getMethodInfo().getCodeAttribute() == null )
+                        {
+                                return "(none)";
+                        }
+                        
+                        // compute the hash from the opcodes
+                        ConstPool constants = behavior.getMethodInfo().getConstPool();
+                        ConstPoolEditor editor = new ConstPoolEditor( constants );
+                        MessageDigest digest = MessageDigest.getInstance( "MD5" );
+                        CodeIterator iter = behavior.getMethodInfo().getCodeAttribute().iterator();
+                        while( iter.hasNext() )
+                        {
+                                int pos = iter.next();
+                                
+                                // update the hash with the opcode
+                                int opcode = iter.byteAt( pos );
+                                digest.update( (byte)opcode );
+                                
+                                // is there a constant value here?
+                                int constIndex = -1;
+                                switch( opcode )
+                                {
+                                        case Opcode.LDC:
+                                                constIndex = iter.byteAt( pos + 1 );
+                                        break;
+                                        
+                                        case Opcode.LDC_W:
+                                                constIndex = ( iter.byteAt( pos + 1 ) << 8 ) | iter.byteAt( pos + 2 );
+                                        break;
+                                        
+                                        case Opcode.LDC2_W:
+                                                constIndex = ( iter.byteAt( pos + 1 ) << 8 ) | iter.byteAt( pos + 2 );
+                                        break;
+                                }
+                                
+                                if( constIndex >= 0 )
+                                {
+                                        // update the hash with the constant value
+                                        ConstInfoAccessor item = editor.getItem( constIndex );
+                                        if( item.getType() == InfoType.StringInfo )
+                                        {
+                                                String val = constants.getStringInfo( constIndex );
+                                                try
+                                                {
+                                                        digest.update( val.getBytes( "UTF8" ) );
+                                                }
+                                                catch( UnsupportedEncodingException ex )
+                                                {
+                                                        throw new Error( ex );
+                                                }
+                                        }
+                                }
+                        }
+                        
+                        // convert the hash to a hex string
+                        return toHex( digest.digest() );
+                }
+                catch( BadBytecode | NoSuchAlgorithmException ex )
+                {
+                        throw new Error( ex );
+                }
+        }
+        
+        private String toHex( byte[] bytes )
+        {
+                // function taken from:
+                // http://stackoverflow.com/questions/9655181/convert-from-byte-array-to-hex-string-in-java
+                final char[] hexArray = "0123456789ABCDEF".toCharArray();
+                char[] hexChars = new char[bytes.length * 2];
+                for( int j = 0; j < bytes.length; j++ )
+                {
+                        int v = bytes[j] & 0xFF;
+                        hexChars[j * 2] = hexArray[v >>> 4];
+                        hexChars[j * 2 + 1] = hexArray[v & 0x0F];
+                }
+                return new String( hexChars );
+        }
+
+        @Override
+        public boolean equals( Object other )
+        {
+                if( other instanceof ClassIdentity )
+                {
+                        return equals( (ClassIdentity)other );
+                }
+                return false;
+        }
+        
+        public boolean equals( ClassIdentity other )
+        {
+                return m_fields.equals( other.m_fields )
+                        && m_methods.equals( other.m_methods )
+                        && m_constructors.equals( other.m_constructors )
+                        && m_staticInitializer.equals( other.m_staticInitializer );
+        }
+        
+        @Override
+        public int hashCode( )
+        {
+                List<Object> objs = Lists.newArrayList();
+                objs.addAll( m_fields );
+                objs.addAll( m_methods );
+                objs.addAll( m_constructors );
+                objs.add( m_staticInitializer );
+                return Util.combineHashesOrdered( objs );
+        }
+}