Merge pull request #62 from OpenModLoader/asm

ASM based class translator

1 files changed, 88 insertions, 79 deletions

diff --git a/src/main/java/cuchaz/enigma/mapping/MappingsEnigmaReader.java b/src/main/java/cuchaz/enigma/mapping/MappingsEnigmaReader.java
index a0d4313..ddbee76 100644
--- a/src/main/java/cuchaz/enigma/mapping/MappingsEnigmaReader.java
+++ b/src/main/java/cuchaz/enigma/mapping/MappingsEnigmaReader.java
@@ -5,8 +5,14 @@ import com.google.common.collect.Queues;
 import cuchaz.enigma.throwables.MappingConflict;
 import cuchaz.enigma.throwables.MappingParseException;
 
-import java.io.*;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
 import java.util.Deque;
+import java.util.function.Supplier;
 
 public class MappingsEnigmaReader {
 
@@ -39,92 +45,95 @@ public class MappingsEnigmaReader {
         }
 
         public Mappings readFile(Mappings mappings, File file) throws IOException, MappingParseException {
+                return readFileStream(mappings, new FileInputStream(file), file::getAbsolutePath);
+        }
 
-                BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(file), Charsets.UTF_8));
-                Deque<Object> mappingStack = Queues.newArrayDeque();
+        public Mappings readFileStream(Mappings mappings, InputStream stream, Supplier<String> filenameSupplier) throws IOException, MappingParseException {
+                try (BufferedReader in = new BufferedReader(new InputStreamReader(stream, Charsets.UTF_8))) {
+                        Deque<Object> mappingStack = Queues.newArrayDeque();
 
-                int lineNumber = 0;
-                String line;
-                while ((line = in.readLine()) != null) {
-                        lineNumber++;
+                        int lineNumber = 0;
+                        String line;
+                        while ((line = in.readLine()) != null) {
+                                lineNumber++;
 
-                        // strip comments
-                        int commentPos = line.indexOf('#');
-                        if (commentPos >= 0) {
-                                line = line.substring(0, commentPos);
-                        }
+                                // strip comments
+                                int commentPos = line.indexOf('#');
+                                if (commentPos >= 0) {
+                                        line = line.substring(0, commentPos);
+                                }
 
-                        // skip blank lines
-                        if (line.trim().length() <= 0) {
-                                continue;
-                        }
+                                // 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;
+                                // get the indent of this line
+                                int indent = 0;
+                                for (int i = 0; i < line.length(); i++) {
+                                        if (line.charAt(i) != '\t') {
+                                                break;
+                                        }
+                                        indent++;
                                 }
-                                indent++;
-                        }
 
-                        // handle stack pops
-                        while (indent < mappingStack.size()) {
-                                mappingStack.pop();
-                        }
+                                // 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 {
-
-                                                // inner class
-                                                if (!(mappingStack.peek() instanceof ClassMapping)) {
-                                                        throw new MappingParseException(file, lineNumber, "Unexpected CLASS entry here!");
+                                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 {
+
+                                                        // inner class
+                                                        if (!(mappingStack.peek() instanceof ClassMapping)) {
+                                                                throw new MappingParseException(filenameSupplier, lineNumber, "Unexpected CLASS entry here!");
+                                                        }
+
+                                                        classMapping = readClass(parts, true);
+                                                        ((ClassMapping) mappingStack.peek()).addInnerClassMapping(classMapping);
                                                 }
-
-                                                classMapping = readClass(parts, true);
-                                                ((ClassMapping) mappingStack.peek()).addInnerClassMapping(classMapping);
-                                        }
-                                        mappingStack.push(classMapping);
-                                } else if (token.equalsIgnoreCase("FIELD")) {
-                                        if (mappingStack.isEmpty() || !(mappingStack.peek() instanceof ClassMapping)) {
-                                                throw new MappingParseException(file, lineNumber, "Unexpected FIELD entry here!");
-                                        }
-                                        ((ClassMapping) mappingStack.peek()).addFieldMapping(readField(parts));
-                                } else if (token.equalsIgnoreCase("METHOD")) {
-                                        if (mappingStack.isEmpty() || !(mappingStack.peek() instanceof ClassMapping)) {
-                                                throw new MappingParseException(file, lineNumber, "Unexpected METHOD entry here!");
-                                        }
-                                        MethodMapping methodMapping = readMethod(parts);
-                                        ((ClassMapping) mappingStack.peek()).addMethodMapping(methodMapping);
-                                        mappingStack.push(methodMapping);
-                                } else if (token.equalsIgnoreCase("ARG")) {
-                                        if (mappingStack.isEmpty() || !(mappingStack.peek() instanceof MethodMapping)) {
-                                                throw new MappingParseException(file, lineNumber, "Unexpected ARG entry here!");
+                                                mappingStack.push(classMapping);
+                                        } else if (token.equalsIgnoreCase("FIELD")) {
+                                                if (mappingStack.isEmpty() || !(mappingStack.peek() instanceof ClassMapping)) {
+                                                        throw new MappingParseException(filenameSupplier, lineNumber, "Unexpected FIELD entry here!");
+                                                }
+                                                ((ClassMapping) mappingStack.peek()).addFieldMapping(readField(parts));
+                                        } else if (token.equalsIgnoreCase("METHOD")) {
+                                                if (mappingStack.isEmpty() || !(mappingStack.peek() instanceof ClassMapping)) {
+                                                        throw new MappingParseException(filenameSupplier, lineNumber, "Unexpected METHOD entry here!");
+                                                }
+                                                MethodMapping methodMapping = readMethod(parts);
+                                                ((ClassMapping) mappingStack.peek()).addMethodMapping(methodMapping);
+                                                mappingStack.push(methodMapping);
+                                        } else if (token.equalsIgnoreCase("ARG")) {
+                                                if (mappingStack.isEmpty() || !(mappingStack.peek() instanceof MethodMapping)) {
+                                                        throw new MappingParseException(filenameSupplier, lineNumber, "Unexpected ARG entry here!");
+                                                }
+                                                ((MethodMapping) mappingStack.peek()).addArgumentMapping(readArgument(parts));
                                         }
-                                        ((MethodMapping) mappingStack.peek()).addArgumentMapping(readArgument(parts));
+                                } catch (ArrayIndexOutOfBoundsException | IllegalArgumentException ex) {
+                                        throw new MappingParseException(filenameSupplier, lineNumber, "Malformed line:\n" + line);
+                                } catch (MappingConflict e) {
+                                        throw new MappingParseException(filenameSupplier, lineNumber, e.getMessage());
                                 }
-                        } catch (ArrayIndexOutOfBoundsException | IllegalArgumentException ex) {
-                                throw new MappingParseException(file, lineNumber, "Malformed line:\n" + line);
-                        } catch (MappingConflict e) {
-                                throw new MappingParseException(file, lineNumber, e.getMessage());
                         }
+                        return mappings;
                 }
-                in.close();
-                return mappings;
         }
 
-        private ArgumentMapping readArgument(String[] parts) {
-                return new ArgumentMapping(Integer.parseInt(parts[1]), parts[2]);
+        private LocalVariableMapping readArgument(String[] parts) {
+                return new LocalVariableMapping(Integer.parseInt(parts[1]), parts[2]);
         }
 
         private ClassMapping readClass(String[] parts, boolean makeSimple) {
@@ -150,27 +159,27 @@ public class MappingsEnigmaReader {
                 if (parts.length == 4) {
                         boolean access = parts[3].startsWith("ACC:");
                         if (access)
-                                mapping = new FieldMapping(parts[1], new Type(parts[2]), null,
+                                mapping = new FieldMapping(parts[1], new TypeDescriptor(parts[2]), null,
                                         Mappings.EntryModifier.valueOf(parts[3].substring(4)));
                         else
-                                mapping = new FieldMapping(parts[1], new Type(parts[3]), parts[2], Mappings.EntryModifier.UNCHANGED);
+                                mapping = new FieldMapping(parts[1], new TypeDescriptor(parts[3]), parts[2], Mappings.EntryModifier.UNCHANGED);
                 } else if (parts.length == 5)
-                        mapping = new FieldMapping(parts[1], new Type(parts[3]), parts[2], Mappings.EntryModifier.valueOf(parts[4].substring(4)));
+                        mapping = new FieldMapping(parts[1], new TypeDescriptor(parts[3]), parts[2], Mappings.EntryModifier.valueOf(parts[4].substring(4)));
                 return mapping;
         }
 
         private MethodMapping readMethod(String[] parts) {
                 MethodMapping mapping = null;
                 if (parts.length == 3)
-                        mapping = new MethodMapping(parts[1], new Signature(parts[2]));
+                        mapping = new MethodMapping(parts[1], new MethodDescriptor(parts[2]));
                 else if (parts.length == 4) {
                         boolean access = parts[3].startsWith("ACC:");
                         if (access)
-                                mapping = new MethodMapping(parts[1], new Signature(parts[2]), null, Mappings.EntryModifier.valueOf(parts[3].substring(4)));
+                                mapping = new MethodMapping(parts[1], new MethodDescriptor(parts[2]), null, Mappings.EntryModifier.valueOf(parts[3].substring(4)));
                         else
-                                mapping = new MethodMapping(parts[1], new Signature(parts[3]), parts[2]);
+                                mapping = new MethodMapping(parts[1], new MethodDescriptor(parts[3]), parts[2]);
                 } else if (parts.length == 5)
-                        mapping = new MethodMapping(parts[1], new Signature(parts[3]), parts[2],
+                        mapping = new MethodMapping(parts[1], new MethodDescriptor(parts[3]), parts[2],
                                 Mappings.EntryModifier.valueOf(parts[4].substring(4)));
                 return mapping;
         }