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/Deobfuscator.java | 31 +-- src/cuchaz/enigma/gui/GuiController.java | 17 +- src/cuchaz/enigma/mapping/ArgumentIndex.java | 41 ---- src/cuchaz/enigma/mapping/ArgumentMapping.java | 42 ++++ src/cuchaz/enigma/mapping/ClassIndex.java | 159 --------------- src/cuchaz/enigma/mapping/ClassMapping.java | 217 +++++++++++++++++++++ .../enigma/mapping/DeobfuscatedAncestries.java | 8 +- src/cuchaz/enigma/mapping/FieldEntry.java | 1 + src/cuchaz/enigma/mapping/FieldMapping.java | 41 ++++ src/cuchaz/enigma/mapping/Mappings.java | 128 ++++++++++++ src/cuchaz/enigma/mapping/MappingsReader.java | 129 ++++++++++++ src/cuchaz/enigma/mapping/MappingsWriter.java | 75 +++++++ src/cuchaz/enigma/mapping/MethodIndex.java | 125 ------------ src/cuchaz/enigma/mapping/MethodMapping.java | 136 +++++++++++++ src/cuchaz/enigma/mapping/Renamer.java | 125 ++++++++++++ src/cuchaz/enigma/mapping/TranslationMappings.java | 187 ------------------ src/cuchaz/enigma/mapping/Translator.java | 16 +- 17 files changed, 933 insertions(+), 545 deletions(-) delete mode 100644 src/cuchaz/enigma/mapping/ArgumentIndex.java create mode 100644 src/cuchaz/enigma/mapping/ArgumentMapping.java delete mode 100644 src/cuchaz/enigma/mapping/ClassIndex.java create mode 100644 src/cuchaz/enigma/mapping/ClassMapping.java create mode 100644 src/cuchaz/enigma/mapping/FieldMapping.java create mode 100644 src/cuchaz/enigma/mapping/Mappings.java create mode 100644 src/cuchaz/enigma/mapping/MappingsReader.java create mode 100644 src/cuchaz/enigma/mapping/MappingsWriter.java delete mode 100644 src/cuchaz/enigma/mapping/MethodIndex.java create mode 100644 src/cuchaz/enigma/mapping/MethodMapping.java create mode 100644 src/cuchaz/enigma/mapping/Renamer.java delete mode 100644 src/cuchaz/enigma/mapping/TranslationMappings.java (limited to 'src/cuchaz') diff --git a/src/cuchaz/enigma/Deobfuscator.java b/src/cuchaz/enigma/Deobfuscator.java index bc7065fd..7be57062 100644 --- a/src/cuchaz/enigma/Deobfuscator.java +++ b/src/cuchaz/enigma/Deobfuscator.java @@ -32,9 +32,10 @@ import cuchaz.enigma.mapping.ArgumentEntry; import cuchaz.enigma.mapping.ClassEntry; import cuchaz.enigma.mapping.Entry; import cuchaz.enigma.mapping.FieldEntry; +import cuchaz.enigma.mapping.Mappings; import cuchaz.enigma.mapping.MethodEntry; +import cuchaz.enigma.mapping.Renamer; import cuchaz.enigma.mapping.TranslationDirection; -import cuchaz.enigma.mapping.TranslationMappings; import cuchaz.enigma.mapping.Translator; public class Deobfuscator @@ -43,7 +44,8 @@ public class Deobfuscator private JarFile m_jar; private DecompilerSettings m_settings; private Ancestries m_ancestries; - private TranslationMappings m_mappings; + private Mappings m_mappings; + private Renamer m_renamer; private static Comparator m_obfuscatedClassSorter; @@ -89,7 +91,7 @@ public class Deobfuscator m_settings.setShowSyntheticMembers( true ); // init mappings - setMappings( new TranslationMappings( m_ancestries ) ); + setMappings( new Mappings() ); } public String getJarName( ) @@ -97,23 +99,24 @@ public class Deobfuscator return m_file.getName(); } - public TranslationMappings getMappings( ) + public Mappings getMappings( ) { return m_mappings; } - public void setMappings( TranslationMappings val ) + public void setMappings( Mappings val ) { if( val == null ) { - val = new TranslationMappings( m_ancestries ); + val = new Mappings(); } m_mappings = val; + m_renamer = new Renamer( m_ancestries, m_mappings ); // update decompiler options m_settings.setTypeLoader( new TranslatingTypeLoader( m_jar, - m_mappings.getTranslator( TranslationDirection.Deobfuscating ), - m_mappings.getTranslator( TranslationDirection.Obfuscating ) + m_mappings.getTranslator( m_ancestries, TranslationDirection.Deobfuscating ), + m_mappings.getTranslator( m_ancestries, TranslationDirection.Obfuscating ) ) ); } @@ -168,19 +171,19 @@ public class Deobfuscator { if( entry instanceof ClassEntry ) { - m_mappings.setClassName( (ClassEntry)entry, newName ); + m_renamer.setClassName( (ClassEntry)entry, newName ); } else if( entry instanceof FieldEntry ) { - m_mappings.setFieldName( (FieldEntry)entry, newName ); + m_renamer.setFieldName( (FieldEntry)entry, newName ); } else if( entry instanceof MethodEntry ) { - m_mappings.setMethodName( (MethodEntry)entry, newName ); + m_renamer.setMethodName( (MethodEntry)entry, newName ); } else if( entry instanceof ArgumentEntry ) { - m_mappings.setArgumentName( (ArgumentEntry)entry, newName ); + m_renamer.setArgumentName( (ArgumentEntry)entry, newName ); } else { @@ -190,7 +193,7 @@ public class Deobfuscator public Entry obfuscate( Entry in ) { - Translator translator = m_mappings.getTranslator( TranslationDirection.Obfuscating ); + Translator translator = m_mappings.getTranslator( m_ancestries, TranslationDirection.Obfuscating ); if( in instanceof ClassEntry ) { return translator.translateEntry( (ClassEntry)in ); @@ -215,7 +218,7 @@ public class Deobfuscator public Entry deobfuscate( Entry in ) { - Translator translator = m_mappings.getTranslator( TranslationDirection.Deobfuscating ); + Translator translator = m_mappings.getTranslator( m_ancestries, TranslationDirection.Deobfuscating ); if( in instanceof ClassEntry ) { return translator.translateEntry( (ClassEntry)in ); diff --git a/src/cuchaz/enigma/gui/GuiController.java b/src/cuchaz/enigma/gui/GuiController.java index 5df2d434..fb22b961 100644 --- a/src/cuchaz/enigma/gui/GuiController.java +++ b/src/cuchaz/enigma/gui/GuiController.java @@ -11,8 +11,8 @@ package cuchaz.enigma.gui; import java.io.File; -import java.io.FileInputStream; -import java.io.FileOutputStream; +import java.io.FileReader; +import java.io.FileWriter; import java.io.IOException; import cuchaz.enigma.ClassFile; @@ -22,7 +22,8 @@ import cuchaz.enigma.analysis.SourceIndex; import cuchaz.enigma.mapping.ClassEntry; import cuchaz.enigma.mapping.Entry; import cuchaz.enigma.mapping.EntryPair; -import cuchaz.enigma.mapping.TranslationMappings; +import cuchaz.enigma.mapping.MappingsReader; +import cuchaz.enigma.mapping.MappingsWriter; public class GuiController { @@ -56,17 +57,19 @@ public class GuiController public void openMappings( File file ) throws IOException { - FileInputStream in = new FileInputStream( file ); - m_deobfuscator.setMappings( TranslationMappings.newFromStream( in ) ); + FileReader in = new FileReader( file ); + m_deobfuscator.setMappings( new MappingsReader().read( in ) ); in.close(); + // TEMP + System.out.println( m_deobfuscator.getMappings() ); refreshOpenFiles(); } public void saveMappings( File file ) throws IOException { - FileOutputStream out = new FileOutputStream( file ); - m_deobfuscator.getMappings().write( out ); + FileWriter out = new FileWriter( file ); + new MappingsWriter().write( out, m_deobfuscator.getMappings() ); out.close(); } diff --git a/src/cuchaz/enigma/mapping/ArgumentIndex.java b/src/cuchaz/enigma/mapping/ArgumentIndex.java deleted file mode 100644 index 57488d14..00000000 --- a/src/cuchaz/enigma/mapping/ArgumentIndex.java +++ /dev/null @@ -1,41 +0,0 @@ -/******************************************************************************* - * 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; - -public class ArgumentIndex implements Serializable -{ - private static final long serialVersionUID = 8610742471440861315L; - - private String m_obfName; - private String m_deobfName; - - public ArgumentIndex( String obfName, String deobfName ) - { - m_obfName = obfName; - m_deobfName = deobfName; - } - - public String getObfName( ) - { - return m_obfName; - } - - public String getDeobfName( ) - { - return m_deobfName; - } - public void setDeobfName( String val ) - { - m_deobfName = val; - } -} diff --git a/src/cuchaz/enigma/mapping/ArgumentMapping.java b/src/cuchaz/enigma/mapping/ArgumentMapping.java new file mode 100644 index 00000000..d5e020a6 --- /dev/null +++ b/src/cuchaz/enigma/mapping/ArgumentMapping.java @@ -0,0 +1,42 @@ +/******************************************************************************* + * 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; + +public class ArgumentMapping implements Serializable +{ + private static final long serialVersionUID = 8610742471440861315L; + + private int m_index; + private String m_name; + + // NOTE: this argument order is important for the MethodReader/MethodWriter + public ArgumentMapping( int index, String name ) + { + m_index = index; + m_name = name; + } + + public int getIndex( ) + { + return m_index; + } + + public String getName( ) + { + return m_name; + } + public void setName( String val ) + { + m_name = val; + } +} diff --git a/src/cuchaz/enigma/mapping/ClassIndex.java b/src/cuchaz/enigma/mapping/ClassIndex.java deleted file mode 100644 index 699807b8..00000000 --- a/src/cuchaz/enigma/mapping/ClassIndex.java +++ /dev/null @@ -1,159 +0,0 @@ -/******************************************************************************* - * 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; -import com.google.common.collect.BiMap; -import com.google.common.collect.HashBiMap; - -public class ClassIndex implements Serializable -{ - private static final long serialVersionUID = -5148491146902340107L; - - private String m_obfName; - private String m_deobfName; - private BiMap m_fieldsObfToDeobf; - private Map m_methodsByObf; - private Map m_methodsByDeobf; - - public ClassIndex( String obfName, String deobfName ) - { - m_obfName = obfName; - m_deobfName = deobfName; - m_fieldsObfToDeobf = HashBiMap.create(); - 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 String getObfFieldName( String deobfName ) - { - return m_fieldsObfToDeobf.inverse().get( deobfName ); - } - - public String getDeobfFieldName( String obfName ) - { - return m_fieldsObfToDeobf.get( obfName ); - } - - public void setFieldName( String obfName, String deobfName ) - { - m_fieldsObfToDeobf.put( obfName, deobfName ); - } - - public MethodIndex getMethodByObf( String obfName, String signature ) - { - return m_methodsByObf.get( getMethodKey( obfName, signature ) ); - } - - public MethodIndex getMethodByDeobf( String deobfName, String signature ) - { - return m_methodsByDeobf.get( getMethodKey( deobfName, signature ) ); - } - - private String getMethodKey( String name, String signature ) - { - 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!" ); - } - - MethodIndex 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( MethodIndex methodIndex : m_methodsByObf.values() ) - { - methodIndex.setDeobfSignature( translator.translateSignature( methodIndex.getObfSignature() ) ); - } - } - - public void setArgumentName( String obfMethodName, String obfMethodSignature, int index, String obfName, String deobfName ) - { - if( deobfName == null ) - { - throw new IllegalArgumentException( "deobf name cannot be null!" ); - } - - MethodIndex methodIndex = m_methodsByObf.get( getMethodKey( obfMethodName, obfMethodSignature ) ); - if( methodIndex == null ) - { - methodIndex = createMethodIndex( obfMethodName, obfMethodSignature ); - } - methodIndex.setArgumentName( index, obfName, deobfName ); - } - - private MethodIndex createMethodIndex( String obfName, String obfSignature ) - { - MethodIndex methodIndex = new MethodIndex( obfName, obfSignature, obfName, 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( Map.Entry entry : m_fieldsObfToDeobf.entrySet() ) - { - buf.append( "\t" ); - buf.append( entry.getKey() ); - buf.append( " <-> " ); - buf.append( entry.getValue() ); - buf.append( "\n" ); - } - buf.append( "Methods:\n" ); - for( MethodIndex methodIndex : m_methodsByObf.values() ) - { - buf.append( methodIndex.toString() ); - buf.append( "\n" ); - } - return buf.toString(); - } -} diff --git a/src/cuchaz/enigma/mapping/ClassMapping.java b/src/cuchaz/enigma/mapping/ClassMapping.java new file mode 100644 index 00000000..3ba3569f --- /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(); + } +} diff --git a/src/cuchaz/enigma/mapping/DeobfuscatedAncestries.java b/src/cuchaz/enigma/mapping/DeobfuscatedAncestries.java index 5320f110..dcb0741a 100644 --- a/src/cuchaz/enigma/mapping/DeobfuscatedAncestries.java +++ b/src/cuchaz/enigma/mapping/DeobfuscatedAncestries.java @@ -17,10 +17,10 @@ public class DeobfuscatedAncestries extends Ancestries private static final long serialVersionUID = 8316248774892618324L; private Ancestries m_ancestries; - private Map m_classesByObf; - private Map m_classesByDeobf; + private Map m_classesByObf; + private Map m_classesByDeobf; - protected DeobfuscatedAncestries( Ancestries ancestries, Map classesByObf, Map classesByDeobf ) + protected DeobfuscatedAncestries( Ancestries ancestries, Map classesByObf, Map classesByDeobf ) { m_ancestries = ancestries; m_classesByObf = classesByObf; @@ -31,7 +31,7 @@ public class DeobfuscatedAncestries extends Ancestries public String getSuperclassName( String deobfClassName ) { // obfuscate the class name - ClassIndex classIndex = m_classesByDeobf.get( deobfClassName ); + ClassMapping classIndex = m_classesByDeobf.get( deobfClassName ); if( classIndex == null ) { return null; diff --git a/src/cuchaz/enigma/mapping/FieldEntry.java b/src/cuchaz/enigma/mapping/FieldEntry.java index b9f42394..eefc4c4c 100644 --- a/src/cuchaz/enigma/mapping/FieldEntry.java +++ b/src/cuchaz/enigma/mapping/FieldEntry.java @@ -21,6 +21,7 @@ public class FieldEntry implements Entry, Serializable private ClassEntry m_classEntry; private String m_name; + // NOTE: this argument order is important for the MethodReader/MethodWriter public FieldEntry( ClassEntry classEntry, String name ) { if( classEntry == null ) diff --git a/src/cuchaz/enigma/mapping/FieldMapping.java b/src/cuchaz/enigma/mapping/FieldMapping.java new file mode 100644 index 00000000..618f45c6 --- /dev/null +++ b/src/cuchaz/enigma/mapping/FieldMapping.java @@ -0,0 +1,41 @@ +/******************************************************************************* + * 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; + +public class FieldMapping implements Serializable +{ + private static final long serialVersionUID = 8610742471440861315L; + + private String m_obfName; + private String m_deobfName; + + public FieldMapping( String obfName, String deobfName ) + { + m_obfName = obfName; + m_deobfName = deobfName; + } + + public String getObfName( ) + { + return m_obfName; + } + + public String getDeobfName( ) + { + return m_deobfName; + } + public void setDeobfName( String val ) + { + m_deobfName = val; + } +} diff --git a/src/cuchaz/enigma/mapping/Mappings.java b/src/cuchaz/enigma/mapping/Mappings.java new file mode 100644 index 00000000..2a39057a --- /dev/null +++ b/src/cuchaz/enigma/mapping/Mappings.java @@ -0,0 +1,128 @@ +/******************************************************************************* + * 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.IOException; +import java.io.InputStream; +import java.io.ObjectInputStream; +import java.io.Serializable; +import java.util.Map; +import java.util.zip.GZIPInputStream; + +import com.beust.jcommander.internal.Maps; + +import cuchaz.enigma.Util; + +public class Mappings implements Serializable +{ + private static final long serialVersionUID = 4649790259460259026L; + + protected Map m_classesByObf; + protected Map m_classesByDeobf; + + public Mappings( ) + { + m_classesByObf = Maps.newHashMap(); + m_classesByDeobf = Maps.newHashMap(); + } + + public Mappings( Iterable classes ) + { + this(); + + for( ClassMapping classMapping : classes ) + { + m_classesByObf.put( classMapping.getObfName(), classMapping ); + m_classesByDeobf.put( classMapping.getDeobfName(), classMapping ); + } + } + + public static Mappings newFromResource( String resource ) + throws IOException + { + InputStream in = null; + try + { + in = Mappings.class.getResourceAsStream( resource ); + return newFromStream( in ); + } + finally + { + Util.closeQuietly( in ); + } + } + + public Iterable classes( ) + { + assert( m_classesByObf.size() == m_classesByDeobf.size() ); + return m_classesByObf.values(); + } + + protected void addClassMapping( ClassMapping classMapping ) + { + m_classesByObf.put( classMapping.getObfName(), classMapping ); + m_classesByDeobf.put( classMapping.getDeobfName(), classMapping ); + } + + public ClassMapping getClassByObf( ClassEntry entry ) + { + return getClassByObf( entry.getName() ); + } + + public ClassMapping getClassByObf( String obfName ) + { + return m_classesByObf.get( obfName ); + } + + public ClassMapping getClassByDeobf( ClassEntry entry ) + { + return getClassByObf( entry.getName() ); + } + + public ClassMapping getClassByDeobf( String deobfName ) + { + return m_classesByDeobf.get( deobfName ); + } + + public Translator getTranslator( Ancestries ancestries, TranslationDirection direction ) + { + return new Translator( + direction, + direction.choose( m_classesByObf, m_classesByDeobf ), + direction.choose( ancestries, new DeobfuscatedAncestries( ancestries, m_classesByObf, m_classesByDeobf ) ) + ); + } + + public static Mappings newFromStream( InputStream in ) + throws IOException + { + try + { + return (Mappings)new ObjectInputStream( new GZIPInputStream( in ) ).readObject(); + } + catch( ClassNotFoundException ex ) + { + throw new Error( ex ); + } + } + + @Override + public String toString( ) + { + StringBuilder buf = new StringBuilder(); + for( ClassMapping classMapping : m_classesByObf.values() ) + { + buf.append( classMapping.toString() ); + buf.append( "\n" ); + } + return buf.toString(); + } +} diff --git a/src/cuchaz/enigma/mapping/MappingsReader.java b/src/cuchaz/enigma/mapping/MappingsReader.java new file mode 100644 index 00000000..b0394090 --- /dev/null +++ b/src/cuchaz/enigma/mapping/MappingsReader.java @@ -0,0 +1,129 @@ +/******************************************************************************* + * 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.BufferedReader; +import java.io.IOException; +import java.io.Reader; +import java.util.NoSuchElementException; +import java.util.Scanner; + +import cuchaz.enigma.Util; + +public class MappingsReader +{ + public Mappings read( Reader in ) + throws IOException + { + return read( new BufferedReader( in ) ); + } + + public Mappings read( BufferedReader in ) + throws IOException + { + Mappings mappings = new Mappings(); + ClassMapping classMapping = null; + MethodMapping methodMapping = null; + + int lineNumber = 0; + String line = null; + while( ( line = in.readLine() ) != null ) + { + lineNumber++; + + // strip comments + int commentPos = line.indexOf( '#' ); + if( commentPos >= 0 ) + { + line = line.substring( 0, commentPos ); + } + + // skip blank lines + line = line.trim(); + if( line.length() <= 0 ) + { + continue; + } + + Scanner scanner = new Scanner( line ); + try + { + while( scanner.hasNext() ) + { + // read the first token + String token = scanner.next(); + + if( token.equalsIgnoreCase( "CLASS" ) ) + { + classMapping = readClass( scanner ); + mappings.addClassMapping( classMapping ); + methodMapping = null; + } + else if( token.equalsIgnoreCase( "FIELD" ) ) + { + if( classMapping == null ) + { + throw new IllegalArgumentException( "Line " + lineNumber + ": Unexpected FIELD entry here!" ); + } + classMapping.addFieldMapping( readField( scanner ) ); + } + else if( token.equalsIgnoreCase( "METHOD" ) ) + { + if( classMapping == null ) + { + throw new IllegalArgumentException( "Line " + lineNumber + ": Unexpected METHOD entry here!" ); + } + methodMapping = readMethod( scanner ); + classMapping.addMethodMapping( methodMapping ); + } + else if( token.equalsIgnoreCase( "ARG" ) ) + { + if( classMapping == null || methodMapping == null ) + { + throw new IllegalArgumentException( "Line " + lineNumber + ": Unexpected ARG entry here!" ); + } + methodMapping.addArgumentMapping( readArgument( scanner ) ); + } + } + } + catch( NoSuchElementException ex ) + { + throw new IllegalArgumentException( "Line " + lineNumber + ": malformed line!" ); + } + finally + { + Util.closeQuietly( scanner ); + } + } + + return mappings; + } + + private ArgumentMapping readArgument( Scanner scanner ) + { + return new ArgumentMapping( scanner.nextInt(), scanner.next() ); + } + + private ClassMapping readClass( Scanner scanner ) + { + return new ClassMapping( scanner.next(), scanner.next() ); + } + + private FieldMapping readField( Scanner scanner ) + { + return new FieldMapping( scanner.next(), scanner.next() ); + } + + private MethodMapping readMethod( Scanner scanner ) + { + return new MethodMapping( scanner.next(), scanner.next(), scanner.next(), scanner.next() ); + } +} diff --git a/src/cuchaz/enigma/mapping/MappingsWriter.java b/src/cuchaz/enigma/mapping/MappingsWriter.java new file mode 100644 index 00000000..20863687 --- /dev/null +++ b/src/cuchaz/enigma/mapping/MappingsWriter.java @@ -0,0 +1,75 @@ +/******************************************************************************* + * 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.IOException; +import java.io.PrintWriter; +import java.io.Writer; + +public class MappingsWriter +{ + public void write( Writer out, Mappings mappings ) + throws IOException + { + write( new PrintWriter( out ), mappings ); + } + + public void write( PrintWriter out, Mappings mappings ) + throws IOException + { + for( ClassMapping classMapping : mappings.classes() ) + { + write( out, classMapping ); + } + } + + public void write( PrintWriter out, ClassMapping classMapping ) + throws IOException + { + out.format( "CLASS %s %s\n", classMapping.getObfName(), classMapping.getDeobfName() ); + + for( FieldMapping fieldMapping : classMapping.fields() ) + { + write( out, fieldMapping ); + } + + for( MethodMapping methodMapping : classMapping.methods() ) + { + write( out, methodMapping ); + } + } + + public void write( PrintWriter out, FieldMapping fieldMapping ) + throws IOException + { + out.format( "\tFIELD %s %s\n", fieldMapping.getObfName(), fieldMapping.getDeobfName() ); + } + + public void write( PrintWriter out, MethodMapping methodMapping ) + throws IOException + { + out.format( "\tMETHOD %s %s %s %s\n", + methodMapping.getObfName(), methodMapping.getDeobfName(), + methodMapping.getObfSignature(), methodMapping.getDeobfSignature() + ); + + for( ArgumentMapping argumentMapping : methodMapping.arguments() ) + { + write( out, argumentMapping ); + } + } + + public void write( PrintWriter out, ArgumentMapping argumentMapping ) + throws IOException + { + out.format( "\t\tARG %d %s\n", argumentMapping.getIndex(), argumentMapping.getName() ); + } +} diff --git a/src/cuchaz/enigma/mapping/MethodIndex.java b/src/cuchaz/enigma/mapping/MethodIndex.java deleted file mode 100644 index f965355d..00000000 --- a/src/cuchaz/enigma/mapping/MethodIndex.java +++ /dev/null @@ -1,125 +0,0 @@ -/******************************************************************************* - * 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 java.util.TreeMap; - -public class MethodIndex implements Serializable -{ - private static final long serialVersionUID = -4409570216084263978L; - - private String m_obfName; - private String m_deobfName; - private String m_obfSignature; - private String m_deobfSignature; - private Map m_arguments; - - public MethodIndex( String obfName, String obfSignature, String deobfName, String deobfSignature ) - { - m_obfName = obfName; - m_deobfName = deobfName; - m_obfSignature = obfSignature; - m_deobfSignature = deobfSignature; - m_arguments = new TreeMap(); - } - - public String getObfName( ) - { - return m_obfName; - } - - public String getDeobfName( ) - { - return m_deobfName; - } - public void setDeobfName( String val ) - { - m_deobfName = val; - } - - public String getObfSignature( ) - { - return m_obfSignature; - } - - public String getDeobfSignature( ) - { - return m_deobfSignature; - } - public void setDeobfSignature( String val ) - { - m_deobfSignature = val; - } - - public String getObfArgumentName( int index ) - { - ArgumentIndex argumentIndex = m_arguments.get( index ); - if( argumentIndex != null ) - { - return argumentIndex.getObfName(); - } - - return null; - } - - public String getDeobfArgumentName( int index ) - { - ArgumentIndex argumentIndex = m_arguments.get( index ); - if( argumentIndex != null ) - { - return argumentIndex.getDeobfName(); - } - - return null; - } - - public void setArgumentName( int index, String obfName, String deobfName ) - { - ArgumentIndex argumentIndex = m_arguments.get( index ); - if( argumentIndex == null ) - { - argumentIndex = new ArgumentIndex( obfName, deobfName ); - m_arguments.put( index, argumentIndex ); - } - else - { - argumentIndex.setDeobfName( deobfName ); - } - } - - @Override - public String toString( ) - { - StringBuilder buf = new StringBuilder(); - buf.append( "\t" ); - buf.append( m_obfName ); - buf.append( " <-> " ); - buf.append( m_deobfName ); - buf.append( "\n" ); - buf.append( "\t" ); - buf.append( m_obfSignature ); - buf.append( " <-> " ); - buf.append( m_deobfSignature ); - buf.append( "\n" ); - buf.append( "\tArguments:\n" ); - for( ArgumentIndex argumentIndex : m_arguments.values() ) - { - buf.append( "\t\t" ); - buf.append( argumentIndex.getObfName() ); - buf.append( " <-> " ); - buf.append( argumentIndex.getDeobfName() ); - buf.append( "\n" ); - } - return buf.toString(); - } -} diff --git a/src/cuchaz/enigma/mapping/MethodMapping.java b/src/cuchaz/enigma/mapping/MethodMapping.java new file mode 100644 index 00000000..f2bc54d1 --- /dev/null +++ b/src/cuchaz/enigma/mapping/MethodMapping.java @@ -0,0 +1,136 @@ +/******************************************************************************* + * 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 java.util.TreeMap; + +public class MethodMapping implements Serializable +{ + private static final long serialVersionUID = -4409570216084263978L; + + private String m_obfName; + private String m_deobfName; + private String m_obfSignature; + 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 ) + { + m_obfName = obfName; + m_deobfName = deobfName; + m_obfSignature = obfSignature; + m_deobfSignature = deobfSignature; + m_arguments = new TreeMap(); + } + + public String getObfName( ) + { + return m_obfName; + } + + public String getDeobfName( ) + { + return m_deobfName; + } + public void setDeobfName( String val ) + { + m_deobfName = val; + } + + public String getObfSignature( ) + { + return m_obfSignature; + } + + public String getDeobfSignature( ) + { + return m_deobfSignature; + } + public void setDeobfSignature( String val ) + { + m_deobfSignature = val; + } + + public Iterable arguments( ) + { + return m_arguments.values(); + } + + protected void addArgumentMapping( ArgumentMapping argumentMapping ) + { + m_arguments.put( argumentMapping.getIndex(), argumentMapping ); + } + + public String getObfArgumentName( int index ) + { + ArgumentMapping argumentMapping = m_arguments.get( index ); + if( argumentMapping != null ) + { + return argumentMapping.getName(); + } + + return null; + } + + public String getDeobfArgumentName( int index ) + { + ArgumentMapping argumentMapping = m_arguments.get( index ); + if( argumentMapping != null ) + { + return argumentMapping.getName(); + } + + return null; + } + + public void setArgumentName( int index, String name ) + { + ArgumentMapping argumentMapping = m_arguments.get( index ); + if( argumentMapping == null ) + { + argumentMapping = new ArgumentMapping( index, name ); + m_arguments.put( index, argumentMapping ); + } + else + { + argumentMapping.setName( name ); + } + } + + @Override + public String toString( ) + { + StringBuilder buf = new StringBuilder(); + buf.append( "\t" ); + buf.append( m_obfName ); + buf.append( " <-> " ); + buf.append( m_deobfName ); + buf.append( "\n" ); + buf.append( "\t" ); + buf.append( m_obfSignature ); + buf.append( " <-> " ); + buf.append( m_deobfSignature ); + buf.append( "\n" ); + buf.append( "\tArguments:\n" ); + for( ArgumentMapping argumentMapping : m_arguments.values() ) + { + buf.append( "\t\t" ); + buf.append( argumentMapping.getIndex() ); + buf.append( " <-> " ); + buf.append( argumentMapping.getName() ); + buf.append( "\n" ); + } + return buf.toString(); + } +} diff --git a/src/cuchaz/enigma/mapping/Renamer.java b/src/cuchaz/enigma/mapping/Renamer.java new file mode 100644 index 00000000..4a648ad3 --- /dev/null +++ b/src/cuchaz/enigma/mapping/Renamer.java @@ -0,0 +1,125 @@ +/******************************************************************************* + * 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.IOException; +import java.io.ObjectOutputStream; +import java.io.OutputStream; +import java.util.zip.GZIPOutputStream; + +public class Renamer +{ + private Ancestries m_ancestries; + private Mappings m_mappings; + + public Renamer( Ancestries ancestries, Mappings mappings ) + { + m_ancestries = ancestries; + m_mappings = mappings; + } + + public void setClassName( ClassEntry obf, String deobfName ) + { + ClassMapping classMapping = m_mappings.m_classesByObf.get( obf.getName() ); + if( classMapping == null ) + { + classMapping = createClassMapping( obf ); + } + + m_mappings.m_classesByDeobf.remove( classMapping.getDeobfName() ); + classMapping.setDeobfName( deobfName ); + m_mappings.m_classesByDeobf.put( deobfName, classMapping ); + + updateDeobfMethodSignatures(); + + // TEMP + String translatedName = m_mappings.getTranslator( m_ancestries, TranslationDirection.Deobfuscating ).translate( obf ); + assert( translatedName != null && translatedName.equals( deobfName ) ); + } + + public void setFieldName( FieldEntry obf, String deobfName ) + { + ClassMapping classMapping = m_mappings.m_classesByObf.get( obf.getClassName() ); + if( classMapping == null ) + { + classMapping = createClassMapping( obf.getClassEntry() ); + } + + classMapping.setFieldName( obf.getName(), deobfName ); + + // TEMP + System.out.println( classMapping ); + String translatedName = m_mappings.getTranslator( m_ancestries, TranslationDirection.Deobfuscating ).translate( obf ); + assert( translatedName != null && translatedName.equals( deobfName ) ); + } + + public void setMethodName( MethodEntry obf, String deobfName ) + { + ClassMapping classMapping = m_mappings.m_classesByObf.get( obf.getClassName() ); + if( classMapping == null ) + { + classMapping = createClassMapping( obf.getClassEntry() ); + } + + String deobfSignature = m_mappings.getTranslator( m_ancestries, TranslationDirection.Deobfuscating ).translateSignature( obf.getSignature() ); + classMapping.setMethodNameAndSignature( obf.getName(), obf.getSignature(), deobfName, deobfSignature ); + + // TODO: update ancestor/descendant methods in other classes in the inheritance hierarchy too + + // TEMP + System.out.println( classMapping ); + String translatedName = m_mappings.getTranslator( m_ancestries, TranslationDirection.Deobfuscating ).translate( obf ); + assert( translatedName != null && translatedName.equals( deobfName ) ); + } + + public void setArgumentName( ArgumentEntry obf, String deobfName ) + { + ClassMapping classMapping = m_mappings.m_classesByObf.get( obf.getClassName() ); + if( classMapping == null ) + { + classMapping = createClassMapping( obf.getClassEntry() ); + } + + classMapping.setArgumentName( obf.getMethodName(), obf.getMethodSignature(), obf.getIndex(), deobfName ); + + // TEMP + System.out.println( classMapping ); + String translatedName = m_mappings.getTranslator( m_ancestries, TranslationDirection.Deobfuscating ).translate( obf ); + assert( translatedName != null && translatedName.equals( deobfName ) ); + } + + public void write( OutputStream out ) + throws IOException + { + // TEMP: just use the object output for now. We can find a more efficient storage format later + GZIPOutputStream gzipout = new GZIPOutputStream( out ); + ObjectOutputStream oout = new ObjectOutputStream( gzipout ); + oout.writeObject( this ); + gzipout.finish(); + } + + private ClassMapping createClassMapping( ClassEntry obf ) + { + ClassMapping classMapping = new ClassMapping( obf.getName(), obf.getName() ); + m_mappings.m_classesByObf.put( classMapping.getObfName(), classMapping ); + m_mappings.m_classesByDeobf.put( classMapping.getDeobfName(), classMapping ); + return classMapping; + } + + private void updateDeobfMethodSignatures( ) + { + Translator translator = m_mappings.getTranslator( m_ancestries, TranslationDirection.Deobfuscating ); + for( ClassMapping classMapping : m_mappings.m_classesByObf.values() ) + { + classMapping.updateDeobfMethodSignatures( translator ); + } + } +} diff --git a/src/cuchaz/enigma/mapping/TranslationMappings.java b/src/cuchaz/enigma/mapping/TranslationMappings.java deleted file mode 100644 index d6cd4491..00000000 --- a/src/cuchaz/enigma/mapping/TranslationMappings.java +++ /dev/null @@ -1,187 +0,0 @@ -/******************************************************************************* - * 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.IOException; -import java.io.InputStream; -import java.io.ObjectInputStream; -import java.io.ObjectOutputStream; -import java.io.OutputStream; -import java.io.Serializable; -import java.util.Map; -import java.util.zip.GZIPInputStream; -import java.util.zip.GZIPOutputStream; - -import com.beust.jcommander.internal.Maps; - -import cuchaz.enigma.Util; - -public class TranslationMappings implements Serializable -{ - private static final long serialVersionUID = 4649790259460259026L; - - private Map m_classesByObf; - private Map m_classesByDeobf; - private Ancestries m_ancestries; - - public TranslationMappings( Ancestries ancestries ) - { - m_classesByObf = Maps.newHashMap(); - m_classesByDeobf = Maps.newHashMap(); - m_ancestries = ancestries; - } - - public static TranslationMappings newFromResource( String resource ) - throws IOException - { - InputStream in = null; - try - { - in = TranslationMappings.class.getResourceAsStream( resource ); - return newFromStream( in ); - } - finally - { - Util.closeQuietly( in ); - } - } - - public Translator getTranslator( TranslationDirection direction ) - { - return new Translator( - direction, - direction.choose( m_classesByObf, m_classesByDeobf ), - direction.choose( m_ancestries, new DeobfuscatedAncestries( m_ancestries, m_classesByObf, m_classesByDeobf ) ) - ); - } - - public void setClassName( ClassEntry obf, String deobfName ) - { - ClassIndex classIndex = m_classesByObf.get( obf.getName() ); - if( classIndex == null ) - { - classIndex = createClassIndex( obf ); - } - - m_classesByDeobf.remove( classIndex.getDeobfName() ); - classIndex.setDeobfName( deobfName ); - m_classesByDeobf.put( deobfName, classIndex ); - - updateDeobfMethodSignatures(); - - // TEMP - String translatedName = getTranslator( TranslationDirection.Deobfuscating ).translate( obf ); - assert( translatedName != null && translatedName.equals( deobfName ) ); - } - - public void setFieldName( FieldEntry obf, String deobfName ) - { - ClassIndex classIndex = m_classesByObf.get( obf.getClassName() ); - if( classIndex == null ) - { - classIndex = createClassIndex( obf.getClassEntry() ); - } - - classIndex.setFieldName( obf.getName(), deobfName ); - - // TEMP - System.out.println( classIndex ); - String translatedName = getTranslator( TranslationDirection.Deobfuscating ).translate( obf ); - assert( translatedName != null && translatedName.equals( deobfName ) ); - } - - public void setMethodName( MethodEntry obf, String deobfName ) - { - ClassIndex classIndex = m_classesByObf.get( obf.getClassName() ); - if( classIndex == null ) - { - classIndex = createClassIndex( obf.getClassEntry() ); - } - - String deobfSignature = getTranslator( TranslationDirection.Deobfuscating ).translateSignature( obf.getSignature() ); - classIndex.setMethodNameAndSignature( obf.getName(), obf.getSignature(), deobfName, deobfSignature ); - - // TODO: update ancestor/descendant methods in other classes in the inheritance hierarchy too - - // TEMP - System.out.println( classIndex ); - String translatedName = getTranslator( TranslationDirection.Deobfuscating ).translate( obf ); - assert( translatedName != null && translatedName.equals( deobfName ) ); - } - - public void setArgumentName( ArgumentEntry obf, String deobfName ) - { - ClassIndex classIndex = m_classesByObf.get( obf.getClassName() ); - if( classIndex == null ) - { - classIndex = createClassIndex( obf.getClassEntry() ); - } - - classIndex.setArgumentName( obf.getMethodName(), obf.getMethodSignature(), obf.getIndex(), obf.getName(), deobfName ); - - // TEMP - System.out.println( classIndex ); - String translatedName = getTranslator( TranslationDirection.Deobfuscating ).translate( obf ); - assert( translatedName != null && translatedName.equals( deobfName ) ); - } - - public void write( OutputStream out ) - throws IOException - { - // TEMP: just use the object output for now. We can find a more efficient storage format later - GZIPOutputStream gzipout = new GZIPOutputStream( out ); - ObjectOutputStream oout = new ObjectOutputStream( gzipout ); - oout.writeObject( this ); - gzipout.finish(); - } - - public static TranslationMappings newFromStream( InputStream in ) - throws IOException - { - try - { - return (TranslationMappings)new ObjectInputStream( new GZIPInputStream( in ) ).readObject(); - } - catch( ClassNotFoundException ex ) - { - throw new Error( ex ); - } - } - - private ClassIndex createClassIndex( ClassEntry obf ) - { - ClassIndex classIndex = new ClassIndex( obf.getName(), obf.getName() ); - m_classesByObf.put( classIndex.getObfName(), classIndex ); - m_classesByDeobf.put( classIndex.getDeobfName(), classIndex ); - return classIndex; - } - - private void updateDeobfMethodSignatures( ) - { - Translator translator = getTranslator( TranslationDirection.Deobfuscating ); - for( ClassIndex classIndex : m_classesByObf.values() ) - { - classIndex.updateDeobfMethodSignatures( translator ); - } - } - - @Override - public String toString( ) - { - StringBuilder buf = new StringBuilder(); - for( ClassIndex classIndex : m_classesByObf.values() ) - { - buf.append( classIndex.toString() ); - buf.append( "\n" ); - } - return buf.toString(); - } -} diff --git a/src/cuchaz/enigma/mapping/Translator.java b/src/cuchaz/enigma/mapping/Translator.java index bae0dce7..3dbc103b 100644 --- a/src/cuchaz/enigma/mapping/Translator.java +++ b/src/cuchaz/enigma/mapping/Translator.java @@ -19,10 +19,10 @@ import cuchaz.enigma.mapping.SignatureUpdater.ClassNameUpdater; public class Translator { private TranslationDirection m_direction; - private Map m_classes; + private Map m_classes; private Ancestries m_ancestries; - protected Translator( TranslationDirection direction, Map classes, Ancestries ancestries ) + protected Translator( TranslationDirection direction, Map classes, Ancestries ancestries ) { m_direction = direction; m_classes = classes; @@ -36,7 +36,7 @@ public class Translator public String translateClass( String in ) { - ClassIndex classIndex = m_classes.get( in ); + ClassMapping classIndex = m_classes.get( in ); if( classIndex != null ) { return m_direction.choose( @@ -63,7 +63,7 @@ public class Translator for( String className : getSelfAndAncestors( in.getClassName() ) ) { // look for the class - ClassIndex classIndex = m_classes.get( className ); + ClassMapping classIndex = m_classes.get( className ); if( classIndex != null ) { // look for the field @@ -99,11 +99,11 @@ public class Translator for( String className : getSelfAndAncestors( in.getClassName() ) ) { // look for the class - ClassIndex classIndex = m_classes.get( className ); + ClassMapping classIndex = m_classes.get( className ); if( classIndex != null ) { // look for the method - MethodIndex methodIndex = m_direction.choose( + MethodMapping methodIndex = m_direction.choose( classIndex.getMethodByObf( in.getName(), in.getSignature() ), classIndex.getMethodByDeobf( in.getName(), in.getSignature() ) ); @@ -139,11 +139,11 @@ public class Translator for( String className : getSelfAndAncestors( in.getClassName() ) ) { // look for the class - ClassIndex classIndex = m_classes.get( className ); + ClassMapping classIndex = m_classes.get( className ); if( classIndex != null ) { // look for the method - MethodIndex methodIndex = m_direction.choose( + MethodMapping methodIndex = m_direction.choose( classIndex.getMethodByObf( in.getMethodName(), in.getMethodSignature() ), classIndex.getMethodByDeobf( in.getMethodName(), in.getMethodSignature() ) ); -- cgit v1.2.3