1 files changed, 176 insertions, 0 deletions

diff --git a/src/cuchaz/enigma/mapping/MappingsReader.java b/src/cuchaz/enigma/mapping/MappingsReader.java
new file mode 100644
index 0000000..72e829d
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/MappingsReader.java
@@ -0,0 +1,176 @@
+/*******************************************************************************
+ * 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.Deque;
+
+import com.google.common.collect.Queues;
+
+import cuchaz.enigma.Constants;
+import cuchaz.enigma.mapping.SignatureUpdater.ClassNameUpdater;
+
+public class MappingsReader {
+        
+        public Mappings read(Reader in) throws IOException, MappingParseException {
+                return read(new BufferedReader(in));
+        }
+        
+        public Mappings read(BufferedReader in) throws IOException, MappingParseException {
+                Mappings mappings = new Mappings();
+                Deque<Object> mappingStack = Queues.newArrayDeque();
+                
+                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
+                        if (line.trim().length() <= 0) {
+                                continue;
+                        }
+                        
+                        // get the indent of this line
+                        int indent = 0;
+                        for (int i = 0; i < line.length(); i++) {
+                                if (line.charAt(i) != '\t') {
+                                        break;
+                                }
+                                indent++;
+                        }
+                        
+                        // handle stack pops
+                        while (indent < mappingStack.size()) {
+                                mappingStack.pop();
+                        }
+                        
+                        String[] parts = line.trim().split("\\s");
+                        try {
+                                // read the first token
+                                String token = parts[0];
+                                
+                                if (token.equalsIgnoreCase("CLASS")) {
+                                        ClassMapping classMapping;
+                                        if (indent == 0) {
+                                                // outer class
+                                                classMapping = readClass(parts, false);
+                                                mappings.addClassMapping(classMapping);
+                                        } else if (indent == 1) {
+                                                // inner class
+                                                if (! (mappingStack.getFirst() instanceof ClassMapping)) {
+                                                        throw new MappingParseException(lineNumber, "Unexpected CLASS entry here!");
+                                                }
+                                                
+                                                classMapping = readClass(parts, true);
+                                                ((ClassMapping)mappingStack.getFirst()).addInnerClassMapping(classMapping);
+                                        } else {
+                                                throw new MappingParseException(lineNumber, "Unexpected CLASS entry nesting!");
+                                        }
+                                        mappingStack.push(classMapping);
+                                } else if (token.equalsIgnoreCase("FIELD")) {
+                                        if (mappingStack.isEmpty() || ! (mappingStack.getFirst() instanceof ClassMapping)) {
+                                                throw new MappingParseException(lineNumber, "Unexpected FIELD entry here!");
+                                        }
+                                        ((ClassMapping)mappingStack.getFirst()).addFieldMapping(readField(parts));
+                                } else if (token.equalsIgnoreCase("METHOD")) {
+                                        if (mappingStack.isEmpty() || ! (mappingStack.getFirst() instanceof ClassMapping)) {
+                                                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 (ArrayIndexOutOfBoundsException | NumberFormatException ex) {
+                                throw new MappingParseException(lineNumber, "Malformed line!");
+                        }
+                }
+                
+                return mappings;
+        }
+        
+        private ArgumentMapping readArgument(String[] parts) {
+                return new ArgumentMapping(Integer.parseInt(parts[1]), parts[2]);
+        }
+        
+        private ClassMapping readClass(String[] parts, boolean makeSimple) {
+                if (parts.length == 2) {
+                        String obfName = processName(parts[1], makeSimple);
+                        return new ClassMapping(obfName);
+                } else {
+                        String obfName = processName(parts[1], makeSimple);
+                        String deobfName = processName(parts[2], makeSimple);
+                        return new ClassMapping(obfName, deobfName);
+                }
+        }
+        
+        private String processName(String name, boolean makeSimple) {
+                if (makeSimple) {
+                        return new ClassEntry(name).getSimpleName();
+                } else {
+                        return moveClassOutOfDefaultPackage(name, Constants.NonePackage);
+                }
+        }
+        
+        private String moveClassOutOfDefaultPackage(String className, String newPackageName) {
+                ClassEntry classEntry = new ClassEntry(className);
+                if (classEntry.isInDefaultPackage()) {
+                        return newPackageName + "/" + classEntry.getName();
+                }
+                return className;
+        }
+        
+        private FieldMapping readField(String[] parts) {
+                return new FieldMapping(parts[1], parts[2]);
+        }
+        
+        private MethodMapping readMethod(String[] parts) {
+                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);
+                        if (obfName.equals(deobfName)) {
+                                return new MethodMapping(obfName, obfSignature);
+                        } else {
+                                return new MethodMapping(obfName, obfSignature, deobfName);
+                        }
+                }
+        }
+        
+        private String moveSignatureOutOfDefaultPackage(String signature, final String newPackageName) {
+                return SignatureUpdater.update(signature, new ClassNameUpdater() {
+                        @Override
+                        public String update(String className) {
+                                ClassEntry classEntry = new ClassEntry(className);
+                                if (classEntry.isInDefaultPackage()) {
+                                        return newPackageName + "/" + className;
+                                }
+                                return className;
+                        }
+                });
+        }
+}