From 4349d22cc8abf5ec74075dde1b45c5f2f8679bbf Mon Sep 17 00:00:00 2001 From: jeff Date: Wed, 30 Jul 2014 23:43:09 -0400 Subject: switched to line-by-line mergable, human-readable file format for mappings --- src/cuchaz/enigma/mapping/ClassMapping.java | 217 ++++++++++++++++++++++++++++ 1 file changed, 217 insertions(+) create mode 100644 src/cuchaz/enigma/mapping/ClassMapping.java (limited to 'src/cuchaz/enigma/mapping/ClassMapping.java') diff --git a/src/cuchaz/enigma/mapping/ClassMapping.java b/src/cuchaz/enigma/mapping/ClassMapping.java new file mode 100644 index 0000000..3ba3569 --- /dev/null +++ b/src/cuchaz/enigma/mapping/ClassMapping.java @@ -0,0 +1,217 @@ +/******************************************************************************* + * 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.mapping; + +import java.io.Serializable; +import java.util.Map; + +import com.beust.jcommander.internal.Maps; + +public class ClassMapping implements Serializable +{ + private static final long serialVersionUID = -5148491146902340107L; + + private String m_obfName; + private String m_deobfName; + private Map m_fieldsByObf; + private Map m_fieldsByDeobf; + private Map m_methodsByObf; + private Map m_methodsByDeobf; + + // NOTE: this argument order is important for the MethodReader/MethodWriter + public ClassMapping( String obfName, String deobfName ) + { + m_obfName = obfName; + m_deobfName = deobfName; + m_fieldsByObf = Maps.newHashMap(); + m_fieldsByDeobf = Maps.newHashMap(); + m_methodsByObf = Maps.newHashMap(); + m_methodsByDeobf = Maps.newHashMap(); + } + + public String getObfName( ) + { + return m_obfName; + } + + public String getDeobfName( ) + { + return m_deobfName; + } + public void setDeobfName( String val ) + { + m_deobfName = val; + } + + public Iterable fields( ) + { + assert( m_fieldsByObf.size() == m_fieldsByDeobf.size() ); + return m_fieldsByObf.values(); + } + + protected void addFieldMapping( FieldMapping fieldMapping ) + { + m_fieldsByObf.put( fieldMapping.getObfName(), fieldMapping ); + m_fieldsByDeobf.put( fieldMapping.getDeobfName(), fieldMapping ); + } + + public Iterable methods( ) + { + assert( m_methodsByObf.size() == m_methodsByDeobf.size() ); + return m_methodsByObf.values(); + } + + protected void addMethodMapping( MethodMapping methodMapping ) + { + m_methodsByObf.put( getMethodKey( methodMapping.getObfName(), methodMapping.getObfSignature() ), methodMapping ); + m_methodsByDeobf.put( getMethodKey( methodMapping.getDeobfName(), methodMapping.getDeobfSignature() ), methodMapping ); + } + + public String getObfFieldName( String deobfName ) + { + FieldMapping fieldMapping = m_fieldsByDeobf.get( deobfName ); + if( fieldMapping != null ) + { + return fieldMapping.getObfName(); + } + return null; + } + + public String getDeobfFieldName( String obfName ) + { + FieldMapping fieldMapping = m_fieldsByObf.get( obfName ); + if( fieldMapping != null ) + { + return fieldMapping.getDeobfName(); + } + return null; + } + + public void setFieldName( String obfName, String deobfName ) + { + if( deobfName == null ) + { + throw new IllegalArgumentException( "deobf name cannot be null!" ); + } + + FieldMapping fieldMapping = m_fieldsByObf.get( obfName ); + if( fieldMapping == null ) + { + fieldMapping = new FieldMapping( obfName, deobfName ); + m_fieldsByObf.put( obfName, fieldMapping ); + m_fieldsByDeobf.put( deobfName, fieldMapping ); + } + + m_fieldsByDeobf.remove( fieldMapping.getDeobfName() ); + fieldMapping.setDeobfName( deobfName ); + m_fieldsByDeobf.put( deobfName, fieldMapping ); + } + + public MethodMapping getMethodByObf( String obfName, String signature ) + { + return m_methodsByObf.get( getMethodKey( obfName, signature ) ); + } + + public MethodMapping getMethodByDeobf( String deobfName, String signature ) + { + return m_methodsByDeobf.get( getMethodKey( deobfName, signature ) ); + } + + private String getMethodKey( String name, String signature ) + { + if( name == null ) + { + throw new IllegalArgumentException( "name cannot be null!" ); + } + if( signature == null ) + { + throw new IllegalArgumentException( "signature cannot be null!" ); + } + return name + signature; + } + + public void setMethodNameAndSignature( String obfName, String obfSignature, String deobfName, String deobfSignature ) + { + if( deobfName == null ) + { + throw new IllegalArgumentException( "deobf name cannot be null!" ); + } + + MethodMapping methodIndex = m_methodsByObf.get( getMethodKey( obfName, obfSignature ) ); + if( methodIndex == null ) + { + methodIndex = createMethodIndex( obfName, obfSignature ); + } + + m_methodsByDeobf.remove( getMethodKey( methodIndex.getDeobfName(), methodIndex.getDeobfSignature() ) ); + methodIndex.setDeobfName( deobfName ); + methodIndex.setDeobfSignature( deobfSignature ); + m_methodsByDeobf.put( getMethodKey( deobfName, deobfSignature ), methodIndex ); + } + + public void updateDeobfMethodSignatures( Translator translator ) + { + for( MethodMapping methodIndex : m_methodsByObf.values() ) + { + methodIndex.setDeobfSignature( translator.translateSignature( methodIndex.getObfSignature() ) ); + } + } + + public void setArgumentName( String obfMethodName, String obfMethodSignature, int argumentIndex, String argumentName ) + { + if( argumentName == null ) + { + throw new IllegalArgumentException( "argument name cannot be null!" ); + } + + MethodMapping methodIndex = m_methodsByObf.get( getMethodKey( obfMethodName, obfMethodSignature ) ); + if( methodIndex == null ) + { + methodIndex = createMethodIndex( obfMethodName, obfMethodSignature ); + } + methodIndex.setArgumentName( argumentIndex, argumentName ); + } + + private MethodMapping createMethodIndex( String obfName, String obfSignature ) + { + MethodMapping methodIndex = new MethodMapping( obfName, obfName, obfSignature, obfSignature ); + String key = getMethodKey( obfName, obfSignature ); + m_methodsByObf.put( key, methodIndex ); + m_methodsByDeobf.put( key, methodIndex ); + return methodIndex; + } + + @Override + public String toString( ) + { + StringBuilder buf = new StringBuilder(); + buf.append( m_obfName ); + buf.append( " <-> " ); + buf.append( m_deobfName ); + buf.append( "\n" ); + buf.append( "Fields:\n" ); + for( FieldMapping fieldMapping : fields() ) + { + buf.append( "\t" ); + buf.append( fieldMapping.getObfName() ); + buf.append( " <-> " ); + buf.append( fieldMapping.getDeobfName() ); + buf.append( "\n" ); + } + buf.append( "Methods:\n" ); + for( MethodMapping methodIndex : m_methodsByObf.values() ) + { + buf.append( methodIndex.toString() ); + buf.append( "\n" ); + } + return buf.toString(); + } +} -- cgit v1.2.3