Init

me/Unmapper/MappingReader.java

@@ -0,0 +1,135 @@
+package me.Unmapper;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.HashMap;
+
+public class MappingReader {
+
+	private final File mappingFile;
+
+	private final HashMap<String, String> internalReversedClassMappings = new HashMap<>();
+	private final HashMap<String, String> classMappings = new HashMap<>();
+	private final HashMap<MemberData, String> memberMappings = new HashMap<>();
+
+	public MappingReader(File mappingFile) {
+		this.mappingFile = mappingFile;
+	}
+
+	public void load() throws IOException {
+		try (BufferedReader read = new BufferedReader(new FileReader(mappingFile))) {
+			String className = null;
+			String s;
+
+			while ((s = read.readLine()) != null) {
+				s = s.trim();
+
+				if (s.startsWith("#"))
+					continue;
+
+				if (s.endsWith(":")) {
+					className = parseClassMapping(s);
+				} else if (className != null) {
+					parseClassMemberMapping(className, s);
+				}
+			}
+		}
+	}
+
+	private String parseClassMapping(String s) {
+		int splitIdx = s.indexOf("->");
+		if (splitIdx < 0) {
+			return null;
+		}
+
+		int colonIndex = s.indexOf(':', splitIdx + 2);
+		if (colonIndex < 0) {
+			return null;
+		}
+
+		String originalName = s.substring(0, splitIdx).trim().replace('.', '/');
+		String obfuscatedName = s.substring(splitIdx + 2, colonIndex).trim().replace('.', '/');
+
+		classMappings.put(obfuscatedName, originalName);
+		internalReversedClassMappings.put(originalName, obfuscatedName);
+
+		return originalName;
+	}
+
+	private void parseClassMemberMapping(String className, String s) {
+		int colonIdx1 = s.indexOf(':');
+		int colonIdx2 = colonIdx1 < 0 ? -1 : s.indexOf(':', colonIdx1 + 1);
+		int spaceIdx = s.indexOf(' ', colonIdx2 + 2);
+		int argIdx1 = s.indexOf('(', spaceIdx + 1);
+		int argIdx2 = argIdx1 < 0 ? -1 : s.indexOf(')', argIdx1 + 1);
+		int colonIdx3 = argIdx2 < 0 ? -1 : s.indexOf(':', argIdx2 + 1);
+		int colonIdx4 = colonIdx3 < 0 ? -1 : s.indexOf(':', colonIdx3 + 1);
+		int arrowIdx = s.indexOf("->",
+				(colonIdx4 >= 0 ? colonIdx4 : colonIdx3 >= 0 ? colonIdx3 : argIdx2 >= 0 ? argIdx2 : spaceIdx) + 1);
+
+		if (spaceIdx < 0 || arrowIdx < 0) {
+			return;
+		}
+
+		String type = s.substring(colonIdx2 + 1, spaceIdx).trim();
+		String originalName = s.substring(spaceIdx + 1, argIdx1 >= 0 ? argIdx1 : arrowIdx).trim();
+		String obfuscatedName = s.substring(arrowIdx + 2).trim();
+
+		String newClassName = className;
+		int dotIndex = originalName.lastIndexOf('.');
+		if (dotIndex >= 0) {
+			className = originalName.substring(0, dotIndex);
+			originalName = originalName.substring(dotIndex + 1);
+			// How does this work?
+			System.out.println("Don't know how to handle mapping " + className + " to " + newClassName);
+		}
+
+		if (type.length() > 0 && originalName.length() > 0 && obfuscatedName.length() > 0) {
+			if (argIdx2 < 0) {
+				memberMappings.put(
+						new MemberData(getOldClassName(className), convertTypeToByteCode(type), obfuscatedName),
+						originalName);
+			} else {
+				String args = s.substring(argIdx1 + 1, argIdx2).trim();
+
+				memberMappings.put(new MemberData(getOldClassName(className),
+						"(" + convertMultipleTypesToByteCode(args) + ")" + convertTypeToByteCode(type), obfuscatedName),
+						originalName);
+			}
+		}
+	}
+
+	public HashMap<String, String> getClassMappings() {
+		return classMappings;
+	}
+
+	public HashMap<MemberData, String> getMemberMappings() {
+		return memberMappings;
+	}
+
+	private String getOldClassName(String name) {
+		name = name.replace('.', '/');
+		String old = internalReversedClassMappings.get(name);
+		if (old != null)
+			return old;
+		return name;
+	}
+
+	private String convertTypeToByteCode(String type) {
+		if (type.isEmpty())
+			return "";
+		return ClassUtil.getSimpleDesc(getOldClassName(type));
+	}
+
+	private String convertMultipleTypesToByteCode(String types) {
+		if (types.isEmpty())
+			return "";
+		String ret = "";
+		for (String s : types.split(",")) {
+			ret += convertTypeToByteCode(s);
+		}
+		return ret;
+	}
+}