feat: implemented multimapper

3 files changed, 141 insertions, 15 deletions

diff --git a/src/main/java/ftbsc/lll/mapper/impl/MultiMapper.java b/src/main/java/ftbsc/lll/mapper/impl/MultiMapper.java
new file mode 100644
index 0000000..20cb2a5
--- /dev/null
+++ b/src/main/java/ftbsc/lll/mapper/impl/MultiMapper.java
@@ -0,0 +1,123 @@
+package ftbsc.lll.mapper.impl;
+
+import com.google.auto.service.AutoService;
+import ftbsc.lll.exceptions.MalformedMappingsException;
+import ftbsc.lll.exceptions.MappingNotFoundException;
+import ftbsc.lll.mapper.IMapper;
+import ftbsc.lll.mapper.MapperProvider;
+import ftbsc.lll.mapper.tools.MappingUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Special mapper type that actually resolves to an ordered
+ * sequence of mappers applied one after the other.
+ */
+@AutoService(IMapper.class)
+public class MultiMapper implements IMapper {
+
+	/**
+	 * The list of mappers.
+	 */
+	private final List<IMapper> mapperList = new ArrayList<>();
+
+	/**
+	 * Checks whether this mapper can process the given lines.
+	 * @param lines the lines to read
+	 * @return whether this type of mapper can process these lines
+	 */
+	@Override
+	public boolean claim(List<String> lines) {
+		return lines.get(0).equals("lll multimapper");
+	}
+
+	/**
+	 * Populates the {@link IMapper} given the lines, ignoring errors depending on the
+	 * given ignoreErrors flag.
+	 * @param lines the lines to read
+	 * @param ignoreErrors try to ignore errors and keep going
+	 * @throws MalformedMappingsException if an error is encountered and ignoreErrors is false
+	 */
+	@Override
+	public void populate(List<String> lines, boolean ignoreErrors) throws MalformedMappingsException {
+		for(int i = 1; i < lines.size(); i++) {
+			List<String> data = MapperProvider.fetchFromLocalOrRemote(lines.get(i));
+			IMapper mapper = MapperProvider.getMapper(data);
+			mapper.populate(data, ignoreErrors);
+			this.mapperList.add(mapper);
+		}
+	}
+
+	/**
+	 * Completely resets the mapper, clearing it of all existing mappings.
+	 */
+	@Override
+	public void reset() {
+		this.mapperList.forEach(IMapper::reset);
+		this.mapperList.clear();
+	}
+
+	/**
+	 * Gets the obfuscated name of the class.
+	 * @param name the plain internal name of the desired class
+	 * @return the obfuscated name of the class
+	 * @throws MappingNotFoundException if no mapping is found
+	 */
+	@Override
+	public String obfuscateClass(String name) throws MappingNotFoundException {
+		for(IMapper mapper : this.mapperList)
+			name = mapper.obfuscateClass(name);
+		return name;
+	}
+
+	/**
+	 * Gets the plain name of the class.
+	 * @param nameObf the obfuscated internal name of the desired class
+	 * @return the plain name of the class
+	 * @throws MappingNotFoundException if no mapping is found
+	 */
+	@Override
+	public String deobfuscateClass(String nameObf) throws MappingNotFoundException {
+		for(int i = this.mapperList.size() - 1; i >= 0; i--)
+			nameObf = this.mapperList.get(i).deobfuscateClass(nameObf);
+		return nameObf;
+	}
+
+	/**
+	 * Gets the obfuscated name of a class member (field or method).
+	 * @param parentName the plain internal name of the parent class
+	 * @param memberName the field name or method signature
+	 * @param methodDescriptor the descriptor of the member (only for methods)
+	 * @return the obfuscated name of the given member
+	 * @throws MappingNotFoundException if no mapping is found
+	 */
+	@Override
+	public String obfuscateMember(String parentName, String memberName, String methodDescriptor) throws MappingNotFoundException {
+		for(IMapper mapper : this.mapperList) {
+			memberName = mapper.obfuscateMember(parentName, memberName, methodDescriptor);
+			methodDescriptor = MappingUtils.mapMethodDescriptor(methodDescriptor, mapper, false);
+			parentName = mapper.obfuscateClass(parentName);
+		}
+		return memberName;
+	}
+
+	/**
+	 * Gets the plain name of a class member (field or method).
+	 * @param parentName the obfuscated internal name of the parent class
+	 * @param memberName the obfuscated field name or method signature
+	 * @param methodDescriptor the obfuscated descriptor of the member (only for methods)
+	 * @return the plain name of the given member
+	 * @throws MappingNotFoundException if no mapping is found
+	 */
+	@Override
+	public String deobfuscateMember(String parentName, String memberName, String methodDescriptor) throws MappingNotFoundException {
+		for(int i = this.mapperList.size() - 1; i >= 0; i--) {
+			IMapper mapper = this.mapperList.get(i);
+			memberName = mapper.deobfuscateMember(parentName, memberName, methodDescriptor);
+			methodDescriptor = MappingUtils.mapMethodDescriptor(methodDescriptor, mapper, true);
+			parentName = mapper.deobfuscateClass(parentName);
+		}
+		return memberName;
+	}
+}
diff --git a/src/main/java/ftbsc/lll/mapper/tools/MappingUtils.java b/src/main/java/ftbsc/lll/mapper/tools/MappingUtils.java
index df0b79d..c8d76af 100644
--- a/src/main/java/ftbsc/lll/mapper/tools/MappingUtils.java
+++ b/src/main/java/ftbsc/lll/mapper/tools/MappingUtils.java
@@ -10,33 +10,34 @@ import org.objectweb.asm.Type;
  * mappers.
  */
 public class MappingUtils {
+
 	/**
-	 * Obfuscates a method descriptor, replacing its class references
-	 * with their obfuscated counterparts.
+	 * Maps a method descriptor, replacing its class references with their mapped counterparts.
 	 * @param descriptor a {@link String} containing the descriptor
 	 * @param mapper the {@link IMapper} to use for the process
-	 * @return the obfuscated descriptor
+	 * @param reverse whether it should deobfuscate rather than obfuscate
+	 * @return the mapped descriptor
 	 */
-	public static String obfuscateMethodDescriptor(String descriptor, IMapper mapper) {
+	public static String mapMethodDescriptor(String descriptor, IMapper mapper, boolean reverse) {
 		Type method = Type.getMethodType(descriptor);
 		Type[] arguments = method.getArgumentTypes();
 		Type returnType = method.getReturnType();
 
-		Type[] obfArguments = new Type[arguments.length];
-		for(int i = 0; i < obfArguments.length; i++)
-			obfArguments[i] = obfuscateType(arguments[i], mapper);
+		Type[] mappedArguents = new Type[arguments.length];
+		for(int i = 0; i < mappedArguents.length; i++)
+			mappedArguents[i] = mapType(arguments[i], mapper, reverse);
 
-		return Type.getMethodDescriptor(obfuscateType(returnType, mapper), obfArguments);
+		return Type.getMethodDescriptor(mapType(returnType, mapper, reverse), mappedArguents);
 	}
 
 	/**
-	 * Given a {@link Type} and a valid {@link IMapper} it returns its obfuscated
-	 * counterpart.
+	 * Given a {@link Type} and a valid {@link IMapper} it returns its mapped counterpart.
 	 * @param type the type in question
 	 * @param mapper the {@link IMapper} to use for the process
+	 * @param reverse whether it should deobfuscate rather than obfuscate
 	 * @return the obfuscated type
 	 */
-	public static Type obfuscateType(Type type, IMapper mapper) {
+	public static Type mapType(Type type, IMapper mapper, boolean reverse) {
 		//unwrap arrays
 		Type unwrapped = type;
 		int arrayLevel = 0;
@@ -51,10 +52,12 @@ public class MappingUtils {
 
 		String internalName = type.getInternalName();
 
-		String internalNameObf;
+		String internalNameMapped;
 		try {
-			internalNameObf = mapper.obfuscateClass(internalName);
-			return Type.getType(DescriptorBuilder.nameToDescriptor(internalNameObf, arrayLevel));
+			internalNameMapped = reverse
+				? mapper.deobfuscateClass(internalName)
+				: mapper.obfuscateClass(internalName);
+			return Type.getType(DescriptorBuilder.nameToDescriptor(internalNameMapped, arrayLevel));
 		} catch(MappingNotFoundException e) {
 			return type;
 		}
diff --git a/src/main/java/ftbsc/lll/mapper/tools/data/ClassData.java b/src/main/java/ftbsc/lll/mapper/tools/data/ClassData.java
index 5ae4124..3b53055 100644
--- a/src/main/java/ftbsc/lll/mapper/tools/data/ClassData.java
+++ b/src/main/java/ftbsc/lll/mapper/tools/data/ClassData.java
@@ -77,7 +77,7 @@ public class ClassData {
 	public ClassData generateReverseMappings(IMapper mapper) {
 		ClassData reverse = new ClassData(this.nameMapped, this.name);
 		this.methods.forEach((signature, data) -> reverse.addMethod(nameMapped, signature.name,
-			MappingUtils.obfuscateMethodDescriptor(signature.descriptor, mapper)));
+			MappingUtils.mapMethodDescriptor(signature.descriptor, mapper, false)));
 		this.fields.forEach((name, data) -> reverse.addField(data.nameMapped, name));
 		return reverse;
 	}