Document a "little bit" the Tiny Reader

1 files changed, 33 insertions, 8 deletions

diff --git a/src/main/java/cuchaz/enigma/mapping/MappingsTinyReader.java b/src/main/java/cuchaz/enigma/mapping/MappingsTinyReader.java
index b2ba1917..5e597b0c 100644
--- a/src/main/java/cuchaz/enigma/mapping/MappingsTinyReader.java
+++ b/src/main/java/cuchaz/enigma/mapping/MappingsTinyReader.java
@@ -29,10 +29,9 @@ public class MappingsTinyReader {
 
         public Mappings read(File file) throws IOException, MappingParseException {
                 Mappings mappings = new Mappings(Mappings.FormatType.TINY_FILE);
-                System.out.println(file);
                 List<String> lines = Files.readAllLines(file.toPath(), Charsets.UTF_8);
                 Map<String, ClassMapping> classMappingMap = Maps.newHashMap();
-                String header = lines.remove(0);
+                lines.remove(0); // TODO: use the header
                 for (int lineNumber = 0; lineNumber < lines.size(); lineNumber++) {
                         String line = lines.get(lineNumber);
                         String[] parts = line.split("\\s");
@@ -41,26 +40,34 @@ public class MappingsTinyReader {
                                 ClassMapping classMapping;
                                 switch (token) {
                                         case "CLASS":
+
+                                                // Check for orphan created by field or method entries. It shouldn't be possible but I prefer to handle this case
                                                 if (classMappingMap.containsKey(parts[1])) {
                                                         classMapping = classMappingMap.get(parts[1]);
+
+                                                        // We have the full deob name, Enigma only support simple class name so we extract it.
                                                         String deobName = parts[2].contains("$") ?
                                                                           parts[2].substring(parts[2].lastIndexOf('$') + 1) :
                                                                           parts[2];
+
+                                                        // Add full deob name to the class mapping to handle inner class after this loop
                                                         classMappingMap.put(parts[2], classMapping.setDeobInner(parts[2]));
                                                         classMapping.setDeobfName(deobName);
+
+                                                        // Avoid to make the mapping dirty directly at the startup
                                                         classMapping.resetDirty();
                                                 } else
                                                         classMapping = readClass(parts);
                                                 classMappingMap.put(parts[1], classMapping);
                                                 break;
                                         case "FIELD":
+                                                // We can have missing classes mappings because they don't have a ob name, so we create it and use it
                                                 classMapping = classMappingMap.computeIfAbsent(parts[1], k -> new ClassMapping(parts[1]));
-                                                //throw new MappingParseException(file, lineNumber, "Cannot find class '" + parts[1] + "' declaration!");
                                                 classMapping.addFieldMapping(readField(parts));
                                                 break;
                                         case "METHOD":
+                                                // We can have missing classes mappings because they don't have a ob name, so we create it and use it
                                                 classMapping = classMappingMap.computeIfAbsent(parts[1], k -> new ClassMapping(parts[1]));
-                                                //throw new MappingParseException(file, lineNumber, "Cannot find class '" + parts[1] + "' declaration!");
                                                 classMapping.addMethodMapping(readMethod(parts));
                                                 break;
                                         default:
@@ -72,21 +79,39 @@ public class MappingsTinyReader {
                 }
 
                 List<ClassMapping> toRegister = new ArrayList<>(classMappingMap.values());
+
+                // After having completely parsed the file, we need to register it to the real mapping
                 for (ClassMapping classMapping : toRegister) {
                         ClassEntry obEntry = classMapping.getObfEntry();
                         ClassEntry deobEntry = classMapping.getDeObfEntry();
                         try {
                                 if (obEntry.isInnerClass()) {
                                         ClassMapping parent = classMappingMap.get(obEntry.getOuterClassName());
+                                        // Inner class can miss their parent... So we create it and add it to the mappings
                                         if (parent == null) {
-                                                parent = new ClassMapping(obEntry.getOuterClassName());
+                                                parent = new ClassMapping(obEntry.getOuterClassName()); // FIXME: WE ACTUALLY DON'T MANAGE INNER CLASS OF INNER CLASS
                                                 classMappingMap.put(obEntry.getOuterClassName(), parent);
                                                 mappings.addClassMapping(parent);
                                         }
+                                        // Add the inner class to the parent
+                                        parent.addInnerClassMapping(classMapping);
+                                }
+                                // obf class can become deobf inner classs, manage this case.
+                                else if (deobEntry != null && deobEntry.isInnerClass()) {
+                                        String outerClassName = deobEntry.getOuterClassName();
+                                        ClassMapping parent = classMappingMap.get(outerClassName);
+
+                                        // Only the inner is deob??? Okay
+                                        if (parent == null) {
+                                                parent = classMappingMap.get(outerClassName);
+                                                if (parent == null) {
+                                                        parent = new ClassMapping(outerClassName); // FIXME: WE ACTUALLY DON'T MANAGE INNER CLASS OF INNER CLASS
+                                                        classMappingMap.put(outerClassName, parent);
+                                                        mappings.addClassMapping(parent);
+                                                }
+                                        }
                                         parent.addInnerClassMapping(classMapping);
-                                } else if (deobEntry != null && deobEntry.isInnerClass())
-                                        classMappingMap.get(deobEntry.getOuterClassName()).addInnerClassMapping(classMapping);
-                                else
+                                } else
                                         mappings.addClassMapping(classMapping);
                         } catch (MappingConflict e) {
                                 throw new MappingParseException(file, -1, e.getMessage());