From b5338883d271779c335842c07047d60136316167 Mon Sep 17 00:00:00 2001 From: jeff Date: Wed, 3 Sep 2014 00:20:36 -0400 Subject: big refactor to better model class/method mappings with no deobf name --- src/cuchaz/enigma/Deobfuscator.java | 2 +- src/cuchaz/enigma/gui/GuiController.java | 2 + src/cuchaz/enigma/mapping/ClassMapping.java | 111 +++++++++++------- src/cuchaz/enigma/mapping/Mappings.java | 90 +++++++++----- src/cuchaz/enigma/mapping/MappingsReader.java | 155 ++++++++++++++----------- src/cuchaz/enigma/mapping/MappingsRenamer.java | 14 ++- src/cuchaz/enigma/mapping/MappingsWriter.java | 29 ++++- src/cuchaz/enigma/mapping/MethodMapping.java | 16 ++- src/cuchaz/enigma/mapping/NameValidator.java | 12 +- 9 files changed, 276 insertions(+), 155 deletions(-) (limited to 'src') diff --git a/src/cuchaz/enigma/Deobfuscator.java b/src/cuchaz/enigma/Deobfuscator.java index d15c25f9..526534da 100644 --- a/src/cuchaz/enigma/Deobfuscator.java +++ b/src/cuchaz/enigma/Deobfuscator.java @@ -192,7 +192,7 @@ public class Deobfuscator // we need to tell the decompiler the deobfuscated name so it doesn't get freaked out // the decompiler only sees the deobfuscated class, so we need to load it by the deobfuscated name ClassMapping classMapping = m_mappings.getClassByObf( className ); - if( classMapping != null ) + if( classMapping != null && classMapping.getDeobfName() != null ) { className = classMapping.getDeobfName(); } diff --git a/src/cuchaz/enigma/gui/GuiController.java b/src/cuchaz/enigma/gui/GuiController.java index c0fb2e40..5057db2d 100644 --- a/src/cuchaz/enigma/gui/GuiController.java +++ b/src/cuchaz/enigma/gui/GuiController.java @@ -167,6 +167,8 @@ public class GuiController public boolean entryHasMapping( Entry deobfEntry ) { + // TEMP + System.out.println( deobfEntry + " -> " + m_deobfuscator.obfuscateEntry( deobfEntry ) ); return m_deobfuscator.hasMapping( m_deobfuscator.obfuscateEntry( deobfEntry ) ); } diff --git a/src/cuchaz/enigma/mapping/ClassMapping.java b/src/cuchaz/enigma/mapping/ClassMapping.java index 5faaf2a1..bce16cc5 100644 --- a/src/cuchaz/enigma/mapping/ClassMapping.java +++ b/src/cuchaz/enigma/mapping/ClassMapping.java @@ -29,7 +29,11 @@ public class ClassMapping implements Serializable, Comparable private Map m_methodsByObf; private Map m_methodsByDeobf; - // NOTE: this argument order is important for the MethodReader/MethodWriter + public ClassMapping( String obfName ) + { + this( obfName, null ); + } + public ClassMapping( String obfName, String deobfName ) { m_obfName = obfName; @@ -60,14 +64,19 @@ public class ClassMapping implements Serializable, Comparable public Iterable innerClasses( ) { - assert( m_innerClassesByObf.size() == m_innerClassesByDeobf.size() ); + assert( m_innerClassesByObf.size() >= m_innerClassesByDeobf.size() ); return m_innerClassesByObf.values(); } - protected void addInnerClassMapping( ClassMapping classMapping ) + public void addInnerClassMapping( ClassMapping classMapping ) { - m_innerClassesByObf.put( classMapping.getObfName(), classMapping ); - m_innerClassesByDeobf.put( classMapping.getDeobfName(), classMapping ); + boolean obfWasAdded = m_innerClassesByObf.put( classMapping.getObfName(), classMapping ) == null; + assert( obfWasAdded ); + if( classMapping.getDeobfName() != null ) + { + boolean deobfWasAdded = m_innerClassesByDeobf.put( classMapping.getDeobfName(), classMapping ) == null; + assert( deobfWasAdded ); + } } public ClassMapping getOrCreateInnerClass( String obfName ) @@ -75,9 +84,9 @@ public class ClassMapping implements Serializable, Comparable ClassMapping classMapping = m_innerClassesByObf.get( obfName ); if( classMapping == null ) { - classMapping = new ClassMapping( obfName, obfName ); - m_innerClassesByObf.put( obfName, classMapping ); - m_innerClassesByDeobf.put( obfName, classMapping ); + classMapping = new ClassMapping( obfName ); + boolean wasAdded = m_innerClassesByObf.put( obfName, classMapping ) == null; + assert( wasAdded ); } return classMapping; } @@ -115,9 +124,11 @@ public class ClassMapping implements Serializable, Comparable public void setInnerClassName( String obfName, String deobfName ) { ClassMapping classMapping = getOrCreateInnerClass( obfName ); - m_innerClassesByDeobf.remove( classMapping.getDeobfName() ); + boolean wasRemoved = m_innerClassesByDeobf.remove( classMapping.getDeobfName() ) != null; + assert( wasRemoved ); classMapping.setDeobfName( deobfName ); - m_innerClassesByDeobf.put( deobfName, classMapping ); + boolean wasAdded = m_innerClassesByDeobf.put( deobfName, classMapping ) == null; + assert( wasAdded ); } //// FIELDS //////// @@ -128,7 +139,7 @@ public class ClassMapping implements Serializable, Comparable return m_fieldsByObf.values(); } - protected void addFieldMapping( FieldMapping fieldMapping ) + public void addFieldMapping( FieldMapping fieldMapping ) { if( m_fieldsByObf.containsKey( fieldMapping.getObfName() ) ) { @@ -138,8 +149,10 @@ public class ClassMapping implements Serializable, Comparable { throw new Error( "Already have mapping for " + m_deobfName + "." + fieldMapping.getDeobfName() ); } - m_fieldsByObf.put( fieldMapping.getObfName(), fieldMapping ); - m_fieldsByDeobf.put( fieldMapping.getDeobfName(), fieldMapping ); + boolean obfWasAdded = m_fieldsByObf.put( fieldMapping.getObfName(), fieldMapping ) == null; + assert( obfWasAdded ); + boolean deobfWasAdded = m_fieldsByDeobf.put( fieldMapping.getDeobfName(), fieldMapping ) == null; + assert( deobfWasAdded ); assert( m_fieldsByObf.size() == m_fieldsByDeobf.size() ); } @@ -169,38 +182,47 @@ public class ClassMapping implements Serializable, Comparable if( fieldMapping == null ) { fieldMapping = new FieldMapping( obfName, deobfName ); - m_fieldsByObf.put( obfName, fieldMapping ); - m_fieldsByDeobf.put( deobfName, fieldMapping ); + boolean obfWasAdded = m_fieldsByObf.put( obfName, fieldMapping ) == null; + assert( obfWasAdded ); + } + else + { + boolean wasRemoved = m_fieldsByDeobf.remove( fieldMapping.getDeobfName() ) != null; + assert( wasRemoved ); } - - m_fieldsByDeobf.remove( fieldMapping.getDeobfName() ); fieldMapping.setDeobfName( deobfName ); - m_fieldsByDeobf.put( deobfName, fieldMapping ); + boolean wasAdded = m_fieldsByDeobf.put( deobfName, fieldMapping ) == null; + assert( wasAdded ); } //// METHODS //////// public Iterable methods( ) { - assert( m_methodsByObf.size() == m_methodsByDeobf.size() ); + assert( m_methodsByObf.size() >= m_methodsByDeobf.size() ); return m_methodsByObf.values(); } - protected void addMethodMapping( MethodMapping methodMapping ) + public void addMethodMapping( MethodMapping methodMapping ) { String obfKey = getMethodKey( methodMapping.getObfName(), methodMapping.getObfSignature() ); - String deobfKey = getMethodKey( methodMapping.getDeobfName(), methodMapping.getDeobfSignature() ); if( m_methodsByObf.containsKey( obfKey ) ) { throw new Error( "Already have mapping for " + m_obfName + "." + obfKey ); } - if( m_methodsByDeobf.containsKey( deobfKey ) ) + boolean wasAdded = m_methodsByObf.put( obfKey, methodMapping ) == null; + assert( wasAdded ); + if( methodMapping.getDeobfName() != null ) { - throw new Error( "Already have mapping for " + m_deobfName + "." + deobfKey ); + String deobfKey = getMethodKey( methodMapping.getDeobfName(), methodMapping.getDeobfSignature() ); + if( m_methodsByDeobf.containsKey( deobfKey ) ) + { + throw new Error( "Already have mapping for " + m_deobfName + "." + deobfKey ); + } + boolean deobfWasAdded = m_methodsByDeobf.put( deobfKey, methodMapping ) == null; + assert( deobfWasAdded ); } - m_methodsByObf.put( obfKey, methodMapping ); - m_methodsByDeobf.put( deobfKey, methodMapping ); - assert( m_methodsByObf.size() == m_methodsByDeobf.size() ); + assert( m_methodsByObf.size() >= m_methodsByDeobf.size() ); } public MethodMapping getMethodByObf( String obfName, String signature ) @@ -231,13 +253,17 @@ public class ClassMapping implements Serializable, Comparable MethodMapping methodMapping = m_methodsByObf.get( getMethodKey( obfName, obfSignature ) ); if( methodMapping == null ) { - methodMapping = createMethodIndex( obfName, obfSignature ); + methodMapping = createMethodMapping( obfName, obfSignature ); + } + else + { + boolean wasRemoved = m_methodsByDeobf.remove( getMethodKey( methodMapping.getDeobfName(), methodMapping.getDeobfSignature() ) ) != null; + assert( wasRemoved ); } - - m_methodsByDeobf.remove( getMethodKey( methodMapping.getDeobfName(), methodMapping.getDeobfSignature() ) ); methodMapping.setDeobfName( deobfName ); methodMapping.setDeobfSignature( deobfSignature ); - m_methodsByDeobf.put( getMethodKey( deobfName, deobfSignature ), methodMapping ); + boolean wasAdded = m_methodsByDeobf.put( getMethodKey( deobfName, deobfSignature ), methodMapping ) == null; + assert( wasAdded ); } public void updateDeobfMethodSignatures( Translator translator ) @@ -255,17 +281,16 @@ public class ClassMapping implements Serializable, Comparable MethodMapping methodIndex = m_methodsByObf.get( getMethodKey( obfMethodName, obfMethodSignature ) ); if( methodIndex == null ) { - methodIndex = createMethodIndex( obfMethodName, obfMethodSignature ); + methodIndex = createMethodMapping( obfMethodName, obfMethodSignature ); } methodIndex.setArgumentName( argumentIndex, argumentName ); } - private MethodMapping createMethodIndex( String obfName, String obfSignature ) + private MethodMapping createMethodMapping( String obfName, String obfSignature ) { - MethodMapping methodMapping = new MethodMapping( obfName, obfName, obfSignature, obfSignature ); - String key = getMethodKey( obfName, obfSignature ); - m_methodsByObf.put( key, methodMapping ); - m_methodsByDeobf.put( key, methodMapping ); + MethodMapping methodMapping = new MethodMapping( obfName, obfSignature ); + boolean wasAdded = m_methodsByObf.put( getMethodKey( obfName, obfSignature ), methodMapping ) == null; + assert( wasAdded ); return methodMapping; } @@ -308,9 +333,10 @@ public class ClassMapping implements Serializable, Comparable { if( innerClassMapping.renameObfClass( oldObfClassName, newObfClassName ) ) { - m_innerClassesByObf.remove( oldObfClassName ); - m_innerClassesByObf.put( newObfClassName, innerClassMapping ); - assert( m_innerClassesByObf.size() == m_innerClassesByDeobf.size() ); + boolean wasRemoved = m_innerClassesByObf.remove( oldObfClassName ) != null; + assert( wasRemoved ); + boolean wasAdded = m_innerClassesByObf.put( newObfClassName, innerClassMapping ) == null; + assert( wasAdded ); } } @@ -320,9 +346,10 @@ public class ClassMapping implements Serializable, Comparable String oldMethodKey = getMethodKey( methodMapping.getObfName(), methodMapping.getObfSignature() ); if( methodMapping.renameObfClass( oldObfClassName, newObfClassName ) ) { - m_methodsByObf.remove( oldMethodKey ); - m_methodsByObf.put( getMethodKey( methodMapping.getObfName(), methodMapping.getObfSignature() ), methodMapping ); - assert( m_methodsByObf.size() == m_methodsByDeobf.size() ); + boolean wasRemoved = m_methodsByObf.remove( oldMethodKey ) != null; + assert( wasRemoved ); + boolean wasAdded = m_methodsByObf.put( getMethodKey( methodMapping.getObfName(), methodMapping.getObfSignature() ), methodMapping ) == null; + assert( wasAdded ); } } diff --git a/src/cuchaz/enigma/mapping/Mappings.java b/src/cuchaz/enigma/mapping/Mappings.java index f52094fd..99cb85f0 100644 --- a/src/cuchaz/enigma/mapping/Mappings.java +++ b/src/cuchaz/enigma/mapping/Mappings.java @@ -47,7 +47,10 @@ public class Mappings implements Serializable for( ClassMapping classMapping : classes ) { m_classesByObf.put( classMapping.getObfName(), classMapping ); - m_classesByDeobf.put( classMapping.getDeobfName(), classMapping ); + if( classMapping.getDeobfName() != null ) + { + m_classesByDeobf.put( classMapping.getDeobfName(), classMapping ); + } } } @@ -68,23 +71,27 @@ public class Mappings implements Serializable public Collection classes( ) { - assert( m_classesByObf.size() == m_classesByDeobf.size() ); + assert( m_classesByObf.size() >= m_classesByDeobf.size() ); return m_classesByObf.values(); } - protected void addClassMapping( ClassMapping classMapping ) + public void addClassMapping( ClassMapping classMapping ) { if( m_classesByObf.containsKey( classMapping.getObfName() ) ) { throw new Error( "Already have mapping for " + classMapping.getObfName() ); } - if( m_classesByDeobf.containsKey( classMapping.getDeobfName() ) ) + boolean obfWasAdded = m_classesByObf.put( classMapping.getObfName(), classMapping ) == null; + assert( obfWasAdded ); + if( classMapping.getDeobfName() != null ) { - throw new Error( "Already have mapping for " + classMapping.getDeobfName() ); + if( m_classesByDeobf.containsKey( classMapping.getDeobfName() ) ) + { + throw new Error( "Already have mapping for " + classMapping.getDeobfName() ); + } + boolean deobfWasAdded = m_classesByDeobf.put( classMapping.getDeobfName(), classMapping ) == null; + assert( deobfWasAdded ); } - m_classesByObf.put( classMapping.getObfName(), classMapping ); - m_classesByDeobf.put( classMapping.getDeobfName(), classMapping ); - assert( m_classesByObf.size() == m_classesByDeobf.size() ); } public ClassMapping getClassByObf( ClassEntry entry ) @@ -99,7 +106,7 @@ public class Mappings implements Serializable public ClassMapping getClassByDeobf( ClassEntry entry ) { - return getClassByObf( entry.getName() ); + return getClassByDeobf( entry.getName() ); } public ClassMapping getClassByDeobf( String deobfName ) @@ -109,26 +116,52 @@ public class Mappings implements Serializable public Translator getTranslator( TranslationIndex index, TranslationDirection direction ) { - if( direction == TranslationDirection.Obfuscating ) + switch( direction ) { - // deobfuscate the index - index = new TranslationIndex( index ); - Map renames = Maps.newHashMap(); - for( ClassMapping classMapping : classes() ) - { - renames.put( classMapping.getObfName(), classMapping.getDeobfName() ); - for( ClassMapping innerClassMapping : classMapping.innerClasses() ) + case Deobfuscating: + + return new Translator( direction, m_classesByObf, index ); + + case Obfuscating: + + // deobfuscate the index + index = new TranslationIndex( index ); + Map renames = Maps.newHashMap(); + for( ClassMapping classMapping : classes() ) { - renames.put( innerClassMapping.getObfName(), innerClassMapping.getDeobfName() ); + if( classMapping.getDeobfName() != null ) + { + renames.put( classMapping.getObfName(), classMapping.getDeobfName() ); + } + for( ClassMapping innerClassMapping : classMapping.innerClasses() ) + { + if( innerClassMapping.getDeobfName() != null ) + { + renames.put( innerClassMapping.getObfName(), innerClassMapping.getDeobfName() ); + } + } } - } - index.renameClasses( renames ); + index.renameClasses( renames ); + + // fill in the missing deobf class entries with obf entries + Map classes = Maps.newHashMap(); + for( ClassMapping classMapping : classes() ) + { + if( classMapping.getDeobfName() != null ) + { + classes.put( classMapping.getDeobfName(), classMapping ); + } + else + { + classes.put( classMapping.getObfName(), classMapping ); + } + } + + return new Translator( direction, classes, index ); + + default: + throw new Error( "Invalid translation direction!" ); } - return new Translator( - direction, - direction.choose( m_classesByObf, m_classesByDeobf ), - index - ); } public static Mappings newFromStream( InputStream in ) @@ -162,9 +195,10 @@ public class Mappings implements Serializable { if( classMapping.renameObfClass( oldObfName, newObfName ) ) { - m_classesByObf.remove( oldObfName ); - m_classesByObf.put( newObfName, classMapping ); - assert( m_classesByObf.size() == m_classesByDeobf.size() ); + boolean wasRemoved = m_classesByObf.remove( oldObfName ) != null; + assert( wasRemoved ); + boolean wasAdded = m_classesByObf.put( newObfName, classMapping ) == null; + assert( wasAdded ); } } } diff --git a/src/cuchaz/enigma/mapping/MappingsReader.java b/src/cuchaz/enigma/mapping/MappingsReader.java index 9f42b42c..7888836e 100644 --- a/src/cuchaz/enigma/mapping/MappingsReader.java +++ b/src/cuchaz/enigma/mapping/MappingsReader.java @@ -14,13 +14,10 @@ import java.io.BufferedReader; import java.io.IOException; import java.io.Reader; import java.util.Deque; -import java.util.NoSuchElementException; -import java.util.Scanner; import com.google.common.collect.Queues; import cuchaz.enigma.Constants; -import cuchaz.enigma.Util; import cuchaz.enigma.mapping.SignatureUpdater.ClassNameUpdater; public class MappingsReader @@ -73,89 +70,99 @@ public class MappingsReader mappingStack.pop(); } - Scanner scanner = new Scanner( line ); + String[] parts = line.trim().split( "\\s" ); try { - while( scanner.hasNext() ) + // read the first token + String token = parts[0]; + + if( token.equalsIgnoreCase( "CLASS" ) ) { - // read the first token - String token = scanner.next(); - - if( token.equalsIgnoreCase( "CLASS" ) ) + ClassMapping classMapping = readClass( parts ); + if( indent == 0 ) { - ClassMapping classMapping = readClass( scanner ); - if( indent == 0 ) - { - // outer class - mappings.addClassMapping( classMapping ); - } - else if( indent == 1 ) - { - // inner class - if( !( mappingStack.getFirst() instanceof ClassMapping ) ) - { - throw new MappingParseException( lineNumber, "Unexpected CLASS entry here!" ); - } - ((ClassMapping)mappingStack.getFirst()).addInnerClassMapping( classMapping ); - } - else + // outer class + mappings.addClassMapping( classMapping ); + } + else if( indent == 1 ) + { + // inner class + if( !( mappingStack.getFirst() instanceof ClassMapping ) ) { throw new MappingParseException( lineNumber, "Unexpected CLASS entry here!" ); } - mappingStack.push( classMapping ); + ((ClassMapping)mappingStack.getFirst()).addInnerClassMapping( classMapping ); } - else if( token.equalsIgnoreCase( "FIELD" ) ) + else { - if( mappingStack.isEmpty() || !(mappingStack.getFirst() instanceof ClassMapping) ) - { - throw new MappingParseException( lineNumber, "Unexpected FIELD entry here!" ); - } - ((ClassMapping)mappingStack.getFirst()).addFieldMapping( readField( scanner ) ); + throw new MappingParseException( lineNumber, "Unexpected CLASS entry here!" ); } - else if( token.equalsIgnoreCase( "METHOD" ) ) + mappingStack.push( classMapping ); + } + else if( token.equalsIgnoreCase( "FIELD" ) ) + { + if( mappingStack.isEmpty() || !(mappingStack.getFirst() instanceof ClassMapping) ) { - if( mappingStack.isEmpty() || !(mappingStack.getFirst() instanceof ClassMapping) ) - { - throw new MappingParseException( lineNumber, "Unexpected METHOD entry here!" ); - } - MethodMapping methodMapping = readMethod( scanner ); - ((ClassMapping)mappingStack.getFirst()).addMethodMapping( methodMapping ); - mappingStack.push( methodMapping ); + throw new MappingParseException( lineNumber, "Unexpected FIELD entry here!" ); } - else if( token.equalsIgnoreCase( "ARG" ) ) + ((ClassMapping)mappingStack.getFirst()).addFieldMapping( readField( parts ) ); + } + else if( token.equalsIgnoreCase( "METHOD" ) ) + { + if( mappingStack.isEmpty() || !(mappingStack.getFirst() instanceof ClassMapping) ) { - if( mappingStack.isEmpty() || !(mappingStack.getFirst() instanceof MethodMapping) ) - { - throw new MappingParseException( lineNumber, "Unexpected ARG entry here!" ); - } - ((MethodMapping)mappingStack.getFirst()).addArgumentMapping( readArgument( scanner ) ); + throw new MappingParseException( lineNumber, "Unexpected METHOD entry here!" ); + } + MethodMapping methodMapping = readMethod( parts ); + ((ClassMapping)mappingStack.getFirst()).addMethodMapping( methodMapping ); + mappingStack.push( methodMapping ); + } + else if( token.equalsIgnoreCase( "ARG" ) ) + { + if( mappingStack.isEmpty() || !(mappingStack.getFirst() instanceof MethodMapping) ) + { + throw new MappingParseException( lineNumber, "Unexpected ARG entry here!" ); } + ((MethodMapping)mappingStack.getFirst()).addArgumentMapping( readArgument( parts ) ); } } - catch( NoSuchElementException ex ) + catch( ArrayIndexOutOfBoundsException | NumberFormatException ex ) { throw new MappingParseException( lineNumber, "Malformed line!" ); } - finally - { - Util.closeQuietly( scanner ); - } } return mappings; } - private ArgumentMapping readArgument( Scanner scanner ) + private ArgumentMapping readArgument( String[] parts ) { - return new ArgumentMapping( scanner.nextInt(), scanner.next() ); + return new ArgumentMapping( Integer.parseInt( parts[1] ), parts[2] ); } - private ClassMapping readClass( Scanner scanner ) + private ClassMapping readClass( String[] parts ) { - return new ClassMapping( - moveClassOutOfDefaultPackage( scanner.next(), Constants.NonePackage ), - moveClassOutOfDefaultPackage( scanner.next(), Constants.NonePackage ) - ); + if( parts.length == 2 ) + { + String obfName = parts[1]; + return new ClassMapping( moveClassOutOfDefaultPackage( obfName, Constants.NonePackage ) ); + } + else + { + String obfName = parts[1]; + String deobfName = parts[2]; + if( obfName.equals( deobfName ) ) + { + return new ClassMapping( moveClassOutOfDefaultPackage( obfName, Constants.NonePackage ) ); + } + else + { + return new ClassMapping( + moveClassOutOfDefaultPackage( parts[1], Constants.NonePackage ), + moveClassOutOfDefaultPackage( parts[2], Constants.NonePackage ) + ); + } + } } private String moveClassOutOfDefaultPackage( String className, String newPackageName ) @@ -168,18 +175,34 @@ public class MappingsReader return className; } - private FieldMapping readField( Scanner scanner ) + private FieldMapping readField( String[] parts ) { - return new FieldMapping( scanner.next(), scanner.next() ); + return new FieldMapping( parts[1], parts[2] ); } - private MethodMapping readMethod( Scanner scanner ) + private MethodMapping readMethod( String[] parts ) { - return new MethodMapping( - scanner.next(), scanner.next(), - moveSignatureOutOfDefaultPackage( scanner.next(), Constants.NonePackage ), - moveSignatureOutOfDefaultPackage( scanner.next(), Constants.NonePackage ) - ); + if( parts.length == 3 ) + { + String obfName = parts[1]; + String obfSignature = moveSignatureOutOfDefaultPackage( parts[2], Constants.NonePackage ); + return new MethodMapping( obfName, obfSignature ); + } + else + { + String obfName = parts[1]; + String deobfName = parts[2]; + String obfSignature = moveSignatureOutOfDefaultPackage( parts[3], Constants.NonePackage ); + String deobfSignature = moveSignatureOutOfDefaultPackage( parts[4], Constants.NonePackage ); + if( obfName.equals( deobfName ) ) + { + return new MethodMapping( obfName, obfSignature ); + } + else + { + return new MethodMapping( obfName, obfSignature, deobfName, deobfSignature ); + } + } } private String moveSignatureOutOfDefaultPackage( String signature, final String newPackageName ) diff --git a/src/cuchaz/enigma/mapping/MappingsRenamer.java b/src/cuchaz/enigma/mapping/MappingsRenamer.java index 9d036d8f..f84b2489 100644 --- a/src/cuchaz/enigma/mapping/MappingsRenamer.java +++ b/src/cuchaz/enigma/mapping/MappingsRenamer.java @@ -46,9 +46,11 @@ public class MappingsRenamer } else { - m_mappings.m_classesByDeobf.remove( classMapping.getDeobfName() ); + boolean wasRemoved = m_mappings.m_classesByDeobf.remove( classMapping.getDeobfName() ) != null; + assert( wasRemoved ); classMapping.setDeobfName( deobfName ); - m_mappings.m_classesByDeobf.put( deobfName, classMapping ); + boolean wasAdded = m_mappings.m_classesByDeobf.put( deobfName, classMapping ) == null; + assert( wasAdded ); } updateDeobfMethodSignatures(); @@ -132,9 +134,11 @@ public class MappingsRenamer ClassMapping classMapping = m_mappings.m_classesByObf.get( obfClassName ); if( classMapping == null ) { - classMapping = new ClassMapping( obfClassName, obfClassName ); - m_mappings.m_classesByObf.put( classMapping.getObfName(), classMapping ); - m_mappings.m_classesByDeobf.put( classMapping.getDeobfName(), classMapping ); + classMapping = new ClassMapping( obfClassName ); + boolean obfWasAdded = m_mappings.m_classesByObf.put( classMapping.getObfName(), classMapping ) == null; + assert( obfWasAdded ); + boolean deobfWasAdded = m_mappings.m_classesByDeobf.put( classMapping.getDeobfName(), classMapping ) == null; + assert( deobfWasAdded ); } return classMapping; } diff --git a/src/cuchaz/enigma/mapping/MappingsWriter.java b/src/cuchaz/enigma/mapping/MappingsWriter.java index 62035713..ea6e6558 100644 --- a/src/cuchaz/enigma/mapping/MappingsWriter.java +++ b/src/cuchaz/enigma/mapping/MappingsWriter.java @@ -37,7 +37,14 @@ public class MappingsWriter private void write( PrintWriter out, ClassMapping classMapping, int depth ) throws IOException { - out.format( "%sCLASS %s %s\n", getIndent( depth ), classMapping.getObfName(), classMapping.getDeobfName() ); + if( classMapping.getDeobfName() == null ) + { + out.format( "%sCLASS %s\n", getIndent( depth ), classMapping.getObfName() ); + } + else + { + out.format( "%sCLASS %s %s\n", getIndent( depth ), classMapping.getObfName(), classMapping.getDeobfName() ); + } for( ClassMapping innerClassMapping : sorted( classMapping.innerClasses() ) ) { @@ -64,11 +71,21 @@ public class MappingsWriter private void write( PrintWriter out, MethodMapping methodMapping, int depth ) throws IOException { - out.format( "%sMETHOD %s %s %s %s\n", - getIndent( depth ), - methodMapping.getObfName(), methodMapping.getDeobfName(), - methodMapping.getObfSignature(), methodMapping.getDeobfSignature() - ); + if( methodMapping.getDeobfName() == null ) + { + out.format( "%sMETHOD %s %s\n", + getIndent( depth ), + methodMapping.getObfName(), methodMapping.getObfSignature() + ); + } + else + { + out.format( "%sMETHOD %s %s %s %s\n", + getIndent( depth ), + methodMapping.getObfName(), methodMapping.getDeobfName(), + methodMapping.getObfSignature(), methodMapping.getDeobfSignature() + ); + } for( ArgumentMapping argumentMapping : sorted( methodMapping.arguments() ) ) { diff --git a/src/cuchaz/enigma/mapping/MethodMapping.java b/src/cuchaz/enigma/mapping/MethodMapping.java index bf83bd21..e59cb2eb 100644 --- a/src/cuchaz/enigma/mapping/MethodMapping.java +++ b/src/cuchaz/enigma/mapping/MethodMapping.java @@ -26,8 +26,12 @@ public class MethodMapping implements Serializable, Comparable private String m_deobfSignature; private Map m_arguments; - // NOTE: this argument order is important for the MethodReader/MethodWriter - public MethodMapping( String obfName, String deobfName, String obfSignature, String deobfSignature ) + public MethodMapping( String obfName, String obfSignature ) + { + this( obfName, obfSignature, null, null ); + } + + public MethodMapping( String obfName, String obfSignature, String deobfName, String deobfSignature ) { m_obfName = obfName; m_deobfName = NameValidator.validateMethodName( deobfName ); @@ -69,9 +73,10 @@ public class MethodMapping implements Serializable, Comparable return m_arguments.values(); } - protected void addArgumentMapping( ArgumentMapping argumentMapping ) + public void addArgumentMapping( ArgumentMapping argumentMapping ) { - m_arguments.put( argumentMapping.getIndex(), argumentMapping ); + boolean wasAdded = m_arguments.put( argumentMapping.getIndex(), argumentMapping ) == null; + assert( wasAdded ); } public String getObfArgumentName( int index ) @@ -102,7 +107,8 @@ public class MethodMapping implements Serializable, Comparable if( argumentMapping == null ) { argumentMapping = new ArgumentMapping( index, name ); - m_arguments.put( index, argumentMapping ); + boolean wasAdded = m_arguments.put( index, argumentMapping ) == null; + assert( wasAdded ); } else { diff --git a/src/cuchaz/enigma/mapping/NameValidator.java b/src/cuchaz/enigma/mapping/NameValidator.java index 6df893fb..9adf1ac1 100644 --- a/src/cuchaz/enigma/mapping/NameValidator.java +++ b/src/cuchaz/enigma/mapping/NameValidator.java @@ -57,7 +57,11 @@ public class NameValidator public static String validateClassName( String name ) { - if( name == null || !ClassPattern.matcher( name ).matches() || ReservedWords.contains( name ) ) + if( name == null ) + { + return null; + } + if( !ClassPattern.matcher( name ).matches() || ReservedWords.contains( name ) ) { throw new IllegalNameException( name, "This doesn't look like a legal class name" ); } @@ -70,7 +74,11 @@ public class NameValidator public static String validateFieldName( String name ) { - if( name == null || !IdentifierPattern.matcher( name ).matches() || ReservedWords.contains( name ) ) + if( name == null ) + { + return null; + } + if( !IdentifierPattern.matcher( name ).matches() || ReservedWords.contains( name ) ) { throw new IllegalNameException( name, "This doesn't look like a legal identifier" ); } -- cgit v1.2.3