From 47de69a821c6e089b01187e93f4f916aceeeea85 Mon Sep 17 00:00:00 2001 From: NebelNidas Date: Thu, 22 Sep 2022 11:59:53 +0200 Subject: Add initial Mapping-IO export support --- .../translation/mapping/serde/MappingFormat.java | 25 ++-- .../mapping/serde/MappingIoConverter.java | 126 +++++++++++++++++++++ 2 files changed, 142 insertions(+), 9 deletions(-) create mode 100644 enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java (limited to 'enigma/src/main/java') diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java index 367af3b..4790fee 100644 --- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java +++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java @@ -21,21 +21,23 @@ import cuchaz.enigma.translation.mapping.serde.tinyv2.TinyV2Writer; import cuchaz.enigma.translation.mapping.tree.EntryTree; public enum MappingFormat { - ENIGMA_FILE(EnigmaMappingsWriter.FILE, EnigmaMappingsReader.FILE), - ENIGMA_DIRECTORY(EnigmaMappingsWriter.DIRECTORY, EnigmaMappingsReader.DIRECTORY), - ENIGMA_ZIP(EnigmaMappingsWriter.ZIP, EnigmaMappingsReader.ZIP), - TINY_V2(new TinyV2Writer("intermediary", "named"), new TinyV2Reader()), - TINY_FILE(TinyMappingsWriter.INSTANCE, TinyMappingsReader.INSTANCE), - SRG_FILE(SrgMappingsWriter.INSTANCE, null), - PROGUARD(null, ProguardMappingsReader.INSTANCE), - RECAF(RecafMappingsWriter.INSTANCE, RecafMappingsReader.INSTANCE); + ENIGMA_FILE(EnigmaMappingsWriter.FILE, EnigmaMappingsReader.FILE, null), + ENIGMA_DIRECTORY(EnigmaMappingsWriter.DIRECTORY, EnigmaMappingsReader.DIRECTORY, net.fabricmc.mappingio.format.MappingFormat.ENIGMA), + ENIGMA_ZIP(EnigmaMappingsWriter.ZIP, EnigmaMappingsReader.ZIP, null), + TINY_V2(new TinyV2Writer("intermediary", "named"), new TinyV2Reader(), net.fabricmc.mappingio.format.MappingFormat.TINY_2), + TINY_FILE(TinyMappingsWriter.INSTANCE, TinyMappingsReader.INSTANCE, net.fabricmc.mappingio.format.MappingFormat.TINY), + SRG_FILE(SrgMappingsWriter.INSTANCE, null, net.fabricmc.mappingio.format.MappingFormat.SRG), + PROGUARD(null, ProguardMappingsReader.INSTANCE, net.fabricmc.mappingio.format.MappingFormat.PROGUARD), + RECAF(RecafMappingsWriter.INSTANCE, RecafMappingsReader.INSTANCE, null); private final MappingsWriter writer; private final MappingsReader reader; + private final net.fabricmc.mappingio.format.MappingFormat mappingIoCounterpart; - MappingFormat(MappingsWriter writer, MappingsReader reader) { + MappingFormat(MappingsWriter writer, MappingsReader reader, net.fabricmc.mappingio.format.MappingFormat mappingIoCounterpart) { this.writer = writer; this.reader = reader; + this.mappingIoCounterpart = mappingIoCounterpart; } public void write(EntryTree mappings, Path path, ProgressListener progressListener, MappingSaveParameters saveParameters) { @@ -67,4 +69,9 @@ public enum MappingFormat { public MappingsReader getReader() { return reader; } + + @Nullable + public net.fabricmc.mappingio.format.MappingFormat getMappingIoCounterpart() { + return mappingIoCounterpart; + } } diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java new file mode 100644 index 0000000..3a86476 --- /dev/null +++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java @@ -0,0 +1,126 @@ +package cuchaz.enigma.translation.mapping.serde; + +import java.util.Deque; +import java.util.LinkedList; +import java.util.List; + +import net.fabricmc.mappingio.MappedElementKind; +import net.fabricmc.mappingio.tree.MemoryMappingTree; + +import cuchaz.enigma.translation.mapping.EntryMap; +import cuchaz.enigma.translation.mapping.EntryMapping; +import cuchaz.enigma.translation.mapping.tree.EntryTree; +import cuchaz.enigma.translation.mapping.tree.EntryTreeNode; +import cuchaz.enigma.translation.representation.entry.ClassEntry; +import cuchaz.enigma.translation.representation.entry.Entry; +import cuchaz.enigma.translation.representation.entry.FieldEntry; +import cuchaz.enigma.translation.representation.entry.LocalVariableEntry; +import cuchaz.enigma.translation.representation.entry.MethodEntry; + +public class MappingIoConverter { + public static MemoryMappingTree toMappingIo(EntryTree mappings) { + MemoryMappingTree mappingTree = new MemoryMappingTree(); + mappingTree.visitNamespaces("intermediary", List.of("named")); + + for (EntryTreeNode node : mappings) { + if (node.getEntry() instanceof ClassEntry) { + writeClass(node, mappings, mappingTree); + } + } + + mappingTree.visitEnd(); + return mappingTree; + } + + private static void writeClass(EntryTreeNode classNode, EntryMap oldMappingTree, MemoryMappingTree newMappingTree) { + ClassEntry classEntry = (ClassEntry) classNode.getEntry(); + EntryMapping mapping = oldMappingTree.get(classEntry); + Deque parts = new LinkedList<>(); + + newMappingTree.visitClass(classEntry.getFullName()); + newMappingTree.visitComment(MappedElementKind.CLASS, mapping.javadoc()); + + do { + mapping = oldMappingTree.get(classEntry); + + if (mapping != null && mapping.targetName() != null) { + parts.addFirst(mapping.targetName()); + } else { + parts.addFirst(classEntry.getName()); + } + + classEntry = classEntry.getOuterClass(); + } while (classEntry != null); + + String mappedName = String.join("$", parts); + newMappingTree.visitDstName(MappedElementKind.CLASS, 0, mappedName); + + for (EntryTreeNode child : classNode.getChildNodes()) { + Entry entry = child.getEntry(); + + if (entry instanceof FieldEntry) { + writeField(child, newMappingTree); + } else if (entry instanceof MethodEntry) { + writeMethod(child, newMappingTree); + } + } + } + + private static void writeField(EntryTreeNode fieldNode, MemoryMappingTree mappingTree) { + if (fieldNode.getValue() == null || fieldNode.getValue().equals(EntryMapping.DEFAULT)) { + return; // Shortcut + } + + FieldEntry fieldEntry = ((FieldEntry) fieldNode.getEntry()); + mappingTree.visitField(fieldEntry.getName(), fieldEntry.getDesc().toString()); + + EntryMapping fieldMapping = fieldNode.getValue(); + + if (fieldMapping == null) { + fieldMapping = EntryMapping.DEFAULT; + } + + mappingTree.visitDstName(MappedElementKind.FIELD, 0, fieldMapping.targetName()); + mappingTree.visitComment(MappedElementKind.FIELD, fieldMapping.javadoc()); + } + + private static void writeMethod(EntryTreeNode methodNode, MemoryMappingTree mappingTree) { + MethodEntry methodEntry = ((MethodEntry) methodNode.getEntry()); + mappingTree.visitMethod(methodEntry.getName(), methodEntry.getDesc().toString()); + + EntryMapping methodMapping = methodNode.getValue(); + + if (methodMapping == null) { + methodMapping = EntryMapping.DEFAULT; + } + + mappingTree.visitDstName(MappedElementKind.METHOD, 0, methodMapping.targetName()); + mappingTree.visitComment(MappedElementKind.METHOD, methodMapping.javadoc()); + + for (EntryTreeNode child : methodNode.getChildNodes()) { + Entry entry = child.getEntry(); + + if (entry instanceof LocalVariableEntry) { + writeMethodArg(child, mappingTree); + } + } + } + + private static void writeMethodArg(EntryTreeNode methodArgNode, MemoryMappingTree mappingTree) { + if (methodArgNode.getValue() == null || methodArgNode.getValue().equals(EntryMapping.DEFAULT)) { + return; // Shortcut + } + + LocalVariableEntry methodArgEntry = ((LocalVariableEntry) methodArgNode.getEntry()); + mappingTree.visitMethodArg(-1, methodArgEntry.getIndex(), methodArgEntry.getName()); + + EntryMapping methodArgMapping = methodArgNode.getValue(); + + if (methodArgMapping == null) { + methodArgMapping = EntryMapping.DEFAULT; + } + + mappingTree.visitDstName(MappedElementKind.METHOD_ARG, 0, methodArgMapping.targetName()); + mappingTree.visitComment(MappedElementKind.METHOD_ARG, methodArgMapping.javadoc()); + } +} -- cgit v1.2.3 From 6c7738ca744e55e8e2ea03518a5b93000fe9a864 Mon Sep 17 00:00:00 2001 From: NebelNidas Date: Thu, 6 Oct 2022 20:03:14 +0200 Subject: Add Mapping-IO import support; small cleanup --- .../translation/mapping/serde/MappingFormat.java | 2 + .../mapping/serde/MappingIoConverter.java | 58 ++++++++++++++++++++++ 2 files changed, 60 insertions(+) (limited to 'enigma/src/main/java') diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java index 4790fee..5bad929 100644 --- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java +++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java @@ -27,6 +27,8 @@ public enum MappingFormat { TINY_V2(new TinyV2Writer("intermediary", "named"), new TinyV2Reader(), net.fabricmc.mappingio.format.MappingFormat.TINY_2), TINY_FILE(TinyMappingsWriter.INSTANCE, TinyMappingsReader.INSTANCE, net.fabricmc.mappingio.format.MappingFormat.TINY), SRG_FILE(SrgMappingsWriter.INSTANCE, null, net.fabricmc.mappingio.format.MappingFormat.SRG), + TSRG_FILE(null, null, net.fabricmc.mappingio.format.MappingFormat.TSRG), + TSRG_2_FILE(null, null, net.fabricmc.mappingio.format.MappingFormat.TSRG2), PROGUARD(null, ProguardMappingsReader.INSTANCE, net.fabricmc.mappingio.format.MappingFormat.PROGUARD), RECAF(RecafMappingsWriter.INSTANCE, RecafMappingsReader.INSTANCE, null); diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java index 3a86476..d3fd341 100644 --- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java +++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java @@ -6,11 +6,18 @@ import java.util.List; import net.fabricmc.mappingio.MappedElementKind; import net.fabricmc.mappingio.tree.MemoryMappingTree; +import net.fabricmc.mappingio.tree.MappingTree.ClassMapping; +import net.fabricmc.mappingio.tree.MappingTree.FieldMapping; +import net.fabricmc.mappingio.tree.MappingTree.MethodArgMapping; +import net.fabricmc.mappingio.tree.MappingTree.MethodMapping; import cuchaz.enigma.translation.mapping.EntryMap; import cuchaz.enigma.translation.mapping.EntryMapping; import cuchaz.enigma.translation.mapping.tree.EntryTree; import cuchaz.enigma.translation.mapping.tree.EntryTreeNode; +import cuchaz.enigma.translation.mapping.tree.HashEntryTree; +import cuchaz.enigma.translation.representation.MethodDescriptor; +import cuchaz.enigma.translation.representation.TypeDescriptor; import cuchaz.enigma.translation.representation.entry.ClassEntry; import cuchaz.enigma.translation.representation.entry.Entry; import cuchaz.enigma.translation.representation.entry.FieldEntry; @@ -123,4 +130,55 @@ public class MappingIoConverter { mappingTree.visitDstName(MappedElementKind.METHOD_ARG, 0, methodArgMapping.targetName()); mappingTree.visitComment(MappedElementKind.METHOD_ARG, methodArgMapping.javadoc()); } + + public static EntryTree fromMappingIo(MemoryMappingTree mappingTree) { + EntryTree dstMappingTree = new HashEntryTree<>(); + + for (ClassMapping classMapping : mappingTree.getClasses()) { + readClass(classMapping, dstMappingTree); + } + + return dstMappingTree; + } + + private static void readClass(ClassMapping classMapping, EntryTree mappingTree) { + ClassEntry currentClass = new ClassEntry(classMapping.getSrcName()); + String dstName = classMapping.getDstName(0); + + if (dstName != null) { + dstName = dstName.substring(dstName.lastIndexOf('$') + 1); + } + + mappingTree.insert(currentClass, new EntryMapping(dstName)); + + for (FieldMapping fieldMapping : classMapping.getFields()) { + readField(fieldMapping, currentClass, mappingTree); + } + + for (MethodMapping methodMapping : classMapping.getMethods()) { + readMethod(methodMapping, currentClass, mappingTree); + } + } + + private static void readField(FieldMapping fieldMapping, ClassEntry parent, EntryTree mappingTree) { + mappingTree.insert(new FieldEntry(parent, fieldMapping.getSrcName(), new TypeDescriptor(fieldMapping.getSrcDesc())), + new EntryMapping(fieldMapping.getDstName(0))); + } + + private static void readMethod(MethodMapping methodMapping, ClassEntry parent, EntryTree mappingTree) { + MethodEntry currentMethod; + mappingTree.insert(currentMethod = new MethodEntry(parent, methodMapping.getSrcName(), new MethodDescriptor(methodMapping.getSrcDesc())), + new EntryMapping(methodMapping.getDstName(0))); + + for (MethodArgMapping methodArgMapping : methodMapping.getArgs()) { + readMethodArg(methodArgMapping, currentMethod, mappingTree); + } + } + + private static void readMethodArg(MethodArgMapping methodArgMapping, MethodEntry parent, EntryTree mappingTree) { + String methodArgSrcName = methodArgMapping.getSrcName() != null ? methodArgMapping.getSrcName() : ""; + + mappingTree.insert(new LocalVariableEntry(parent, methodArgMapping.getLvIndex(), methodArgSrcName, true, null), + new EntryMapping(methodArgMapping.getDstName(0))); + } } -- cgit v1.2.3 From cc4154d610adf7aee7816279171a50fe074aa675 Mon Sep 17 00:00:00 2001 From: NebelNidas Date: Mon, 10 Oct 2022 13:25:02 +0200 Subject: Add progress listener to Mapping-IO conversion; deduplicate lang files --- .../mapping/serde/MappingIoConverter.java | 24 ++++++++++++++++------ .../mapping/serde/enigma/EnigmaMappingsReader.java | 8 ++++---- .../mapping/serde/enigma/EnigmaMappingsWriter.java | 6 ++---- .../mapping/serde/srg/SrgMappingsWriter.java | 4 ++-- .../mapping/serde/tiny/TinyMappingsReader.java | 2 +- .../mapping/serde/tinyv2/TinyV2Reader.java | 2 +- 6 files changed, 28 insertions(+), 18 deletions(-) (limited to 'enigma/src/main/java') diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java index d3fd341..171f252 100644 --- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java +++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java @@ -3,6 +3,7 @@ package cuchaz.enigma.translation.mapping.serde; import java.util.Deque; import java.util.LinkedList; import java.util.List; +import java.util.stream.StreamSupport; import net.fabricmc.mappingio.MappedElementKind; import net.fabricmc.mappingio.tree.MemoryMappingTree; @@ -11,6 +12,7 @@ import net.fabricmc.mappingio.tree.MappingTree.FieldMapping; import net.fabricmc.mappingio.tree.MappingTree.MethodArgMapping; import net.fabricmc.mappingio.tree.MappingTree.MethodMapping; +import cuchaz.enigma.ProgressListener; import cuchaz.enigma.translation.mapping.EntryMap; import cuchaz.enigma.translation.mapping.EntryMapping; import cuchaz.enigma.translation.mapping.tree.EntryTree; @@ -23,16 +25,23 @@ import cuchaz.enigma.translation.representation.entry.Entry; import cuchaz.enigma.translation.representation.entry.FieldEntry; import cuchaz.enigma.translation.representation.entry.LocalVariableEntry; import cuchaz.enigma.translation.representation.entry.MethodEntry; +import cuchaz.enigma.utils.I18n; public class MappingIoConverter { - public static MemoryMappingTree toMappingIo(EntryTree mappings) { + public static MemoryMappingTree toMappingIo(EntryTree mappings, ProgressListener progress) { + List> classes = StreamSupport.stream(mappings.spliterator(), false) + .filter(node -> node.getEntry() instanceof ClassEntry) + .toList(); + + progress.init(classes.size(), I18n.translate("progress.mappings.converting.to_mappingio")); + int steps = 0; + MemoryMappingTree mappingTree = new MemoryMappingTree(); mappingTree.visitNamespaces("intermediary", List.of("named")); - for (EntryTreeNode node : mappings) { - if (node.getEntry() instanceof ClassEntry) { - writeClass(node, mappings, mappingTree); - } + for (EntryTreeNode classNode : classes) { + progress.step(steps++, classNode.getEntry().getFullName()); + writeClass(classNode, mappings, mappingTree); } mappingTree.visitEnd(); @@ -131,10 +140,13 @@ public class MappingIoConverter { mappingTree.visitComment(MappedElementKind.METHOD_ARG, methodArgMapping.javadoc()); } - public static EntryTree fromMappingIo(MemoryMappingTree mappingTree) { + public static EntryTree fromMappingIo(MemoryMappingTree mappingTree, ProgressListener progress) { EntryTree dstMappingTree = new HashEntryTree<>(); + progress.init(mappingTree.getClasses().size(), I18n.translate("progress.mappings.converting.from_mappingio")); + int steps = 0; for (ClassMapping classMapping : mappingTree.getClasses()) { + progress.step(steps++, classMapping.getDstName(0) != null ? classMapping.getDstName(0) : classMapping.getSrcName()); readClass(classMapping, dstMappingTree); } diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/enigma/EnigmaMappingsReader.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/enigma/EnigmaMappingsReader.java index 5461342..d5570e9 100644 --- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/enigma/EnigmaMappingsReader.java +++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/enigma/EnigmaMappingsReader.java @@ -40,12 +40,12 @@ public enum EnigmaMappingsReader implements MappingsReader { FILE { @Override public EntryTree read(Path path, ProgressListener progress, MappingSaveParameters saveParameters) throws IOException, MappingParseException { - progress.init(1, I18n.translate("progress.mappings.enigma_file.loading")); + progress.init(1, I18n.translate("progress.mappings.loading_file")); EntryTree mappings = new HashEntryTree<>(); readFile(path, mappings); - progress.step(1, I18n.translate("progress.mappings.enigma_file.done")); + progress.step(1, I18n.translate("progress.done")); return mappings; } @@ -60,7 +60,7 @@ public enum EnigmaMappingsReader implements MappingsReader { EntryTree mappings = new HashEntryTree<>(); List files = Files.walk(root).filter(f -> !Files.isDirectory(f)).filter(f -> f.toString().endsWith(".mapping")).toList(); - progress.init(files.size(), I18n.translate("progress.mappings.enigma_directory.loading")); + progress.init(files.size(), I18n.translate("progress.mappings.loading_directory")); int step = 0; for (Path file : files) { @@ -102,7 +102,7 @@ public enum EnigmaMappingsReader implements MappingsReader { throw new IllegalArgumentException("No paths to read mappings from"); } - progress.init(paths.length, I18n.translate("progress.mappings.enigma_directory.loading")); + progress.init(paths.length, I18n.translate("progress.mappings.loading_directory")); int step = 0; for (Path file : paths) { diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/enigma/EnigmaMappingsWriter.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/enigma/EnigmaMappingsWriter.java index df1af91..73f29a1 100644 --- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/enigma/EnigmaMappingsWriter.java +++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/enigma/EnigmaMappingsWriter.java @@ -58,7 +58,7 @@ public enum EnigmaMappingsWriter implements MappingsWriter { public void write(EntryTree mappings, MappingDelta delta, Path path, ProgressListener progress, MappingSaveParameters saveParameters) { Collection classes = mappings.getRootNodes().filter(entry -> entry.getEntry() instanceof ClassEntry).map(entry -> (ClassEntry) entry.getEntry()).toList(); - progress.init(classes.size(), I18n.translate("progress.mappings.enigma_file.writing")); + progress.init(classes.size(), I18n.translate("progress.mappings.writing")); int steps = 0; @@ -78,11 +78,9 @@ public enum EnigmaMappingsWriter implements MappingsWriter { Collection changedClasses = delta.getChangedRoots().filter(entry -> entry instanceof ClassEntry).map(entry -> (ClassEntry) entry).toList(); applyDeletions(path, changedClasses, mappings, delta.getBaseMappings(), saveParameters.getFileNameFormat()); - changedClasses = changedClasses.stream().filter(entry -> !isClassEmpty(mappings, entry)).collect(Collectors.toList()); - progress.init(changedClasses.size(), I18n.translate("progress.mappings.enigma_directory.writing")); - + progress.init(changedClasses.size(), I18n.translate("progress.mappings.writing")); AtomicInteger steps = new AtomicInteger(); Translator translator = new MappingTranslator(mappings, VoidEntryResolver.INSTANCE); diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/srg/SrgMappingsWriter.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/srg/SrgMappingsWriter.java index 4621efe..5addcad 100644 --- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/srg/SrgMappingsWriter.java +++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/srg/SrgMappingsWriter.java @@ -45,7 +45,7 @@ public enum SrgMappingsWriter implements MappingsWriter { List methodLines = new ArrayList<>(); List> rootEntries = Lists.newArrayList(mappings).stream().map(EntryTreeNode::getEntry).toList(); - progress.init(rootEntries.size(), I18n.translate("progress.mappings.srg_file.generating")); + progress.init(rootEntries.size(), I18n.translate("progress.mappings.converting")); int steps = 0; @@ -54,7 +54,7 @@ public enum SrgMappingsWriter implements MappingsWriter { writeEntry(classLines, fieldLines, methodLines, mappings, entry); } - progress.init(3, I18n.translate("progress.mappings.srg_file.writing")); + progress.init(3, I18n.translate("progress.mappings.writing")); try (PrintWriter writer = new LfPrintWriter(Files.newBufferedWriter(path))) { progress.step(0, I18n.translate("type.classes")); diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tiny/TinyMappingsReader.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tiny/TinyMappingsReader.java index 534a567..1575f46 100644 --- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tiny/TinyMappingsReader.java +++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tiny/TinyMappingsReader.java @@ -35,7 +35,7 @@ public enum TinyMappingsReader implements MappingsReader { EntryTree mappings = new HashEntryTree<>(); lines.remove(0); - progress.init(lines.size(), I18n.translate("progress.mappings.tiny_file.loading")); + progress.init(lines.size(), I18n.translate("progress.mappings.loading_file")); for (int lineNumber = 0; lineNumber < lines.size(); lineNumber++) { progress.step(lineNumber, ""); diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tinyv2/TinyV2Reader.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tinyv2/TinyV2Reader.java index eecbc35..28185f5 100644 --- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tinyv2/TinyV2Reader.java +++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tinyv2/TinyV2Reader.java @@ -46,7 +46,7 @@ public final class TinyV2Reader implements MappingsReader { private EntryTree read(Path path, List lines, ProgressListener progress) throws MappingParseException { EntryTree mappings = new HashEntryTree<>(); - progress.init(lines.size(), "progress.mappings.tiny_v2.loading"); + progress.init(lines.size(), "progress.mappings.loading_file"); BitSet state = new BitSet(STATE_SIZE); @SuppressWarnings({"unchecked", "rawtypes"}) MappingPair, RawEntryMapping>[] holds = new MappingPair[STATE_SIZE]; -- cgit v1.2.3 From 59aadb3c543da883acc1d29c7180cf889f03ba24 Mon Sep 17 00:00:00 2001 From: NebelNidas Date: Sat, 17 Jun 2023 11:50:56 +0200 Subject: Update to latest Mapping IO commit --- .../enigma/translation/mapping/serde/MappingFormat.java | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) (limited to 'enigma/src/main/java') diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java index 5bad929..f402c19 100644 --- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java +++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java @@ -21,15 +21,15 @@ import cuchaz.enigma.translation.mapping.serde.tinyv2.TinyV2Writer; import cuchaz.enigma.translation.mapping.tree.EntryTree; public enum MappingFormat { - ENIGMA_FILE(EnigmaMappingsWriter.FILE, EnigmaMappingsReader.FILE, null), - ENIGMA_DIRECTORY(EnigmaMappingsWriter.DIRECTORY, EnigmaMappingsReader.DIRECTORY, net.fabricmc.mappingio.format.MappingFormat.ENIGMA), + ENIGMA_FILE(EnigmaMappingsWriter.FILE, EnigmaMappingsReader.FILE, net.fabricmc.mappingio.format.MappingFormat.ENIGMA_FILE), + ENIGMA_DIRECTORY(EnigmaMappingsWriter.DIRECTORY, EnigmaMappingsReader.DIRECTORY, net.fabricmc.mappingio.format.MappingFormat.ENIGMA_DIR), ENIGMA_ZIP(EnigmaMappingsWriter.ZIP, EnigmaMappingsReader.ZIP, null), - TINY_V2(new TinyV2Writer("intermediary", "named"), new TinyV2Reader(), net.fabricmc.mappingio.format.MappingFormat.TINY_2), - TINY_FILE(TinyMappingsWriter.INSTANCE, TinyMappingsReader.INSTANCE, net.fabricmc.mappingio.format.MappingFormat.TINY), - SRG_FILE(SrgMappingsWriter.INSTANCE, null, net.fabricmc.mappingio.format.MappingFormat.SRG), - TSRG_FILE(null, null, net.fabricmc.mappingio.format.MappingFormat.TSRG), - TSRG_2_FILE(null, null, net.fabricmc.mappingio.format.MappingFormat.TSRG2), - PROGUARD(null, ProguardMappingsReader.INSTANCE, net.fabricmc.mappingio.format.MappingFormat.PROGUARD), + TINY_V2(new TinyV2Writer("intermediary", "named"), new TinyV2Reader(), net.fabricmc.mappingio.format.MappingFormat.TINY_2_FILE), + TINY_FILE(TinyMappingsWriter.INSTANCE, TinyMappingsReader.INSTANCE, net.fabricmc.mappingio.format.MappingFormat.TINY_FILE), + SRG_FILE(SrgMappingsWriter.INSTANCE, null, net.fabricmc.mappingio.format.MappingFormat.SRG_FILE), + TSRG_FILE(null, null, net.fabricmc.mappingio.format.MappingFormat.TSRG_FILE), + TSRG_2_FILE(null, null, net.fabricmc.mappingio.format.MappingFormat.TSRG_2_FILE), + PROGUARD(null, ProguardMappingsReader.INSTANCE, net.fabricmc.mappingio.format.MappingFormat.PROGUARD_FILE), RECAF(RecafMappingsWriter.INSTANCE, RecafMappingsReader.INSTANCE, null); private final MappingsWriter writer; -- cgit v1.2.3 From 58b67c0e8e8fa802b98f9ed43f2f38d9d4a35e2b Mon Sep 17 00:00:00 2001 From: NebelNidas Date: Sat, 17 Jun 2023 11:58:02 +0200 Subject: Add support for method vars and arg/var comments --- .../mapping/serde/MappingIoConverter.java | 76 ++++++++++++++++------ 1 file changed, 56 insertions(+), 20 deletions(-) (limited to 'enigma/src/main/java') diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java index 171f252..05d862a 100644 --- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java +++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java @@ -11,6 +11,7 @@ import net.fabricmc.mappingio.tree.MappingTree.ClassMapping; import net.fabricmc.mappingio.tree.MappingTree.FieldMapping; import net.fabricmc.mappingio.tree.MappingTree.MethodArgMapping; import net.fabricmc.mappingio.tree.MappingTree.MethodMapping; +import net.fabricmc.mappingio.tree.MappingTree.MethodVarMapping; import cuchaz.enigma.ProgressListener; import cuchaz.enigma.translation.mapping.EntryMap; @@ -116,28 +117,50 @@ public class MappingIoConverter { for (EntryTreeNode child : methodNode.getChildNodes()) { Entry entry = child.getEntry(); - if (entry instanceof LocalVariableEntry) { - writeMethodArg(child, mappingTree); + if (entry instanceof LocalVariableEntry local) { + if (local.isArgument()) { + writeMethodArg(child, mappingTree); + } else { + writeMethodVar(child, mappingTree); + } } } } - private static void writeMethodArg(EntryTreeNode methodArgNode, MemoryMappingTree mappingTree) { - if (methodArgNode.getValue() == null || methodArgNode.getValue().equals(EntryMapping.DEFAULT)) { + private static void writeMethodArg(EntryTreeNode argNode, MemoryMappingTree mappingTree) { + if (argNode.getValue() == null || argNode.getValue().equals(EntryMapping.DEFAULT)) { return; // Shortcut } - LocalVariableEntry methodArgEntry = ((LocalVariableEntry) methodArgNode.getEntry()); - mappingTree.visitMethodArg(-1, methodArgEntry.getIndex(), methodArgEntry.getName()); + LocalVariableEntry argEntry = ((LocalVariableEntry) argNode.getEntry()); + mappingTree.visitMethodArg(-1, argEntry.getIndex(), argEntry.getName()); - EntryMapping methodArgMapping = methodArgNode.getValue(); + EntryMapping argMapping = argNode.getValue(); - if (methodArgMapping == null) { - methodArgMapping = EntryMapping.DEFAULT; + if (argMapping == null) { + argMapping = EntryMapping.DEFAULT; } - mappingTree.visitDstName(MappedElementKind.METHOD_ARG, 0, methodArgMapping.targetName()); - mappingTree.visitComment(MappedElementKind.METHOD_ARG, methodArgMapping.javadoc()); + mappingTree.visitDstName(MappedElementKind.METHOD_ARG, 0, argMapping.targetName()); + mappingTree.visitComment(MappedElementKind.METHOD_ARG, argMapping.javadoc()); + } + + private static void writeMethodVar(EntryTreeNode varNode, MemoryMappingTree mappingTree) { + if (varNode.getValue() == null || varNode.getValue().equals(EntryMapping.DEFAULT)) { + return; // Shortcut + } + + LocalVariableEntry varEntry = ((LocalVariableEntry) varNode.getEntry()); + mappingTree.visitMethodVar(-1, varEntry.getIndex(), -1, -1, varEntry.getName()); + + EntryMapping varMapping = varNode.getValue(); + + if (varMapping == null) { + varMapping = EntryMapping.DEFAULT; + } + + mappingTree.visitDstName(MappedElementKind.METHOD_VAR, 0, varMapping.targetName()); + mappingTree.visitComment(MappedElementKind.METHOD_VAR, varMapping.javadoc()); } public static EntryTree fromMappingIo(MemoryMappingTree mappingTree, ProgressListener progress) { @@ -161,7 +184,7 @@ public class MappingIoConverter { dstName = dstName.substring(dstName.lastIndexOf('$') + 1); } - mappingTree.insert(currentClass, new EntryMapping(dstName)); + mappingTree.insert(currentClass, new EntryMapping(dstName, classMapping.getComment())); for (FieldMapping fieldMapping : classMapping.getFields()) { readField(fieldMapping, currentClass, mappingTree); @@ -174,23 +197,36 @@ public class MappingIoConverter { private static void readField(FieldMapping fieldMapping, ClassEntry parent, EntryTree mappingTree) { mappingTree.insert(new FieldEntry(parent, fieldMapping.getSrcName(), new TypeDescriptor(fieldMapping.getSrcDesc())), - new EntryMapping(fieldMapping.getDstName(0))); + new EntryMapping(fieldMapping.getDstName(0), fieldMapping.getComment())); } private static void readMethod(MethodMapping methodMapping, ClassEntry parent, EntryTree mappingTree) { MethodEntry currentMethod; mappingTree.insert(currentMethod = new MethodEntry(parent, methodMapping.getSrcName(), new MethodDescriptor(methodMapping.getSrcDesc())), - new EntryMapping(methodMapping.getDstName(0))); + new EntryMapping(methodMapping.getDstName(0), methodMapping.getComment())); + + for (MethodArgMapping argMapping : methodMapping.getArgs()) { + readMethodArg(argMapping, currentMethod, mappingTree); + } - for (MethodArgMapping methodArgMapping : methodMapping.getArgs()) { - readMethodArg(methodArgMapping, currentMethod, mappingTree); + for (MethodVarMapping varMapping : methodMapping.getVars()) { + readMethodVar(varMapping, currentMethod, mappingTree); } } - private static void readMethodArg(MethodArgMapping methodArgMapping, MethodEntry parent, EntryTree mappingTree) { - String methodArgSrcName = methodArgMapping.getSrcName() != null ? methodArgMapping.getSrcName() : ""; + private static void readMethodArg(MethodArgMapping argMapping, MethodEntry parent, EntryTree mappingTree) { + String srcName = argMapping.getSrcName() != null ? argMapping.getSrcName() : ""; + + mappingTree.insert( + new LocalVariableEntry(parent, argMapping.getLvIndex(), srcName, true, null), + new EntryMapping(argMapping.getDstName(0), argMapping.getComment())); + } + + private static void readMethodVar(MethodVarMapping varMapping, MethodEntry parent, EntryTree mappingTree) { + String srcName = varMapping.getSrcName() != null ? varMapping.getSrcName() : ""; - mappingTree.insert(new LocalVariableEntry(parent, methodArgMapping.getLvIndex(), methodArgSrcName, true, null), - new EntryMapping(methodArgMapping.getDstName(0))); + mappingTree.insert( + new LocalVariableEntry(parent, varMapping.getLvIndex(), srcName, false, null), + new EntryMapping(varMapping.getDstName(0), varMapping.getComment())); } } -- cgit v1.2.3 From 4681411ca1f9fcbe5eba5c4009175033e76c865c Mon Sep 17 00:00:00 2001 From: NebelNidas Date: Mon, 9 Oct 2023 12:29:35 +0200 Subject: Use `VisitableMappingTree` where possible --- .../mapping/serde/MappingIoConverter.java | 47 +++++++++++++--------- 1 file changed, 27 insertions(+), 20 deletions(-) (limited to 'enigma/src/main/java') diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java index 05d862a..a0912fa 100644 --- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java +++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java @@ -1,5 +1,7 @@ package cuchaz.enigma.translation.mapping.serde; +import java.io.IOException; +import java.io.UncheckedIOException; import java.util.Deque; import java.util.LinkedList; import java.util.List; @@ -7,6 +9,7 @@ import java.util.stream.StreamSupport; import net.fabricmc.mappingio.MappedElementKind; import net.fabricmc.mappingio.tree.MemoryMappingTree; +import net.fabricmc.mappingio.tree.VisitableMappingTree; import net.fabricmc.mappingio.tree.MappingTree.ClassMapping; import net.fabricmc.mappingio.tree.MappingTree.FieldMapping; import net.fabricmc.mappingio.tree.MappingTree.MethodArgMapping; @@ -29,27 +32,31 @@ import cuchaz.enigma.translation.representation.entry.MethodEntry; import cuchaz.enigma.utils.I18n; public class MappingIoConverter { - public static MemoryMappingTree toMappingIo(EntryTree mappings, ProgressListener progress) { - List> classes = StreamSupport.stream(mappings.spliterator(), false) - .filter(node -> node.getEntry() instanceof ClassEntry) - .toList(); + public static VisitableMappingTree toMappingIo(EntryTree mappings, ProgressListener progress) { + try { + List> classes = StreamSupport.stream(mappings.spliterator(), false) + .filter(node -> node.getEntry() instanceof ClassEntry) + .toList(); - progress.init(classes.size(), I18n.translate("progress.mappings.converting.to_mappingio")); - int steps = 0; + progress.init(classes.size(), I18n.translate("progress.mappings.converting.to_mappingio")); + int steps = 0; - MemoryMappingTree mappingTree = new MemoryMappingTree(); - mappingTree.visitNamespaces("intermediary", List.of("named")); + MemoryMappingTree mappingTree = new MemoryMappingTree(); + mappingTree.visitNamespaces("intermediary", List.of("named")); - for (EntryTreeNode classNode : classes) { - progress.step(steps++, classNode.getEntry().getFullName()); - writeClass(classNode, mappings, mappingTree); - } + for (EntryTreeNode classNode : classes) { + progress.step(steps++, classNode.getEntry().getFullName()); + writeClass(classNode, mappings, mappingTree); + } - mappingTree.visitEnd(); - return mappingTree; + mappingTree.visitEnd(); + return mappingTree; + } catch (IOException e) { + throw new UncheckedIOException(e); + } } - private static void writeClass(EntryTreeNode classNode, EntryMap oldMappingTree, MemoryMappingTree newMappingTree) { + private static void writeClass(EntryTreeNode classNode, EntryMap oldMappingTree, VisitableMappingTree newMappingTree) throws IOException { ClassEntry classEntry = (ClassEntry) classNode.getEntry(); EntryMapping mapping = oldMappingTree.get(classEntry); Deque parts = new LinkedList<>(); @@ -83,7 +90,7 @@ public class MappingIoConverter { } } - private static void writeField(EntryTreeNode fieldNode, MemoryMappingTree mappingTree) { + private static void writeField(EntryTreeNode fieldNode, VisitableMappingTree mappingTree) throws IOException { if (fieldNode.getValue() == null || fieldNode.getValue().equals(EntryMapping.DEFAULT)) { return; // Shortcut } @@ -101,7 +108,7 @@ public class MappingIoConverter { mappingTree.visitComment(MappedElementKind.FIELD, fieldMapping.javadoc()); } - private static void writeMethod(EntryTreeNode methodNode, MemoryMappingTree mappingTree) { + private static void writeMethod(EntryTreeNode methodNode, VisitableMappingTree mappingTree) throws IOException { MethodEntry methodEntry = ((MethodEntry) methodNode.getEntry()); mappingTree.visitMethod(methodEntry.getName(), methodEntry.getDesc().toString()); @@ -127,7 +134,7 @@ public class MappingIoConverter { } } - private static void writeMethodArg(EntryTreeNode argNode, MemoryMappingTree mappingTree) { + private static void writeMethodArg(EntryTreeNode argNode, VisitableMappingTree mappingTree) throws IOException { if (argNode.getValue() == null || argNode.getValue().equals(EntryMapping.DEFAULT)) { return; // Shortcut } @@ -145,7 +152,7 @@ public class MappingIoConverter { mappingTree.visitComment(MappedElementKind.METHOD_ARG, argMapping.javadoc()); } - private static void writeMethodVar(EntryTreeNode varNode, MemoryMappingTree mappingTree) { + private static void writeMethodVar(EntryTreeNode varNode, VisitableMappingTree mappingTree) throws IOException { if (varNode.getValue() == null || varNode.getValue().equals(EntryMapping.DEFAULT)) { return; // Shortcut } @@ -163,7 +170,7 @@ public class MappingIoConverter { mappingTree.visitComment(MappedElementKind.METHOD_VAR, varMapping.javadoc()); } - public static EntryTree fromMappingIo(MemoryMappingTree mappingTree, ProgressListener progress) { + public static EntryTree fromMappingIo(VisitableMappingTree mappingTree, ProgressListener progress) { EntryTree dstMappingTree = new HashEntryTree<>(); progress.init(mappingTree.getClasses().size(), I18n.translate("progress.mappings.converting.from_mappingio")); int steps = 0; -- cgit v1.2.3 From 75c6da42ca360084b57f7a384cd4a7bf93bdea0a Mon Sep 17 00:00:00 2001 From: NebelNidas Date: Mon, 9 Oct 2023 14:22:40 +0200 Subject: Use System Property for Mapping-IO --- .../translation/mapping/serde/MappingFormat.java | 107 +++++++++++++++++---- .../mapping/serde/MappingIoConverter.java | 10 +- 2 files changed, 97 insertions(+), 20 deletions(-) (limited to 'enigma/src/main/java') diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java index f402c19..4d34720 100644 --- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java +++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java @@ -1,10 +1,19 @@ package cuchaz.enigma.translation.mapping.serde; import java.io.IOException; +import java.io.UncheckedIOException; import java.nio.file.Path; +import java.util.Arrays; +import java.util.List; import javax.annotation.Nullable; +import net.fabricmc.mappingio.MappingReader; +import net.fabricmc.mappingio.MappingWriter; +import net.fabricmc.mappingio.tree.MemoryMappingTree; +import net.fabricmc.mappingio.tree.VisitOrder; +import net.fabricmc.mappingio.tree.VisitableMappingTree; + import cuchaz.enigma.ProgressListener; import cuchaz.enigma.translation.mapping.EntryMapping; import cuchaz.enigma.translation.mapping.MappingDelta; @@ -19,27 +28,30 @@ import cuchaz.enigma.translation.mapping.serde.tiny.TinyMappingsWriter; import cuchaz.enigma.translation.mapping.serde.tinyv2.TinyV2Reader; import cuchaz.enigma.translation.mapping.serde.tinyv2.TinyV2Writer; import cuchaz.enigma.translation.mapping.tree.EntryTree; +import cuchaz.enigma.utils.I18n; public enum MappingFormat { - ENIGMA_FILE(EnigmaMappingsWriter.FILE, EnigmaMappingsReader.FILE, net.fabricmc.mappingio.format.MappingFormat.ENIGMA_FILE), - ENIGMA_DIRECTORY(EnigmaMappingsWriter.DIRECTORY, EnigmaMappingsReader.DIRECTORY, net.fabricmc.mappingio.format.MappingFormat.ENIGMA_DIR), - ENIGMA_ZIP(EnigmaMappingsWriter.ZIP, EnigmaMappingsReader.ZIP, null), - TINY_V2(new TinyV2Writer("intermediary", "named"), new TinyV2Reader(), net.fabricmc.mappingio.format.MappingFormat.TINY_2_FILE), - TINY_FILE(TinyMappingsWriter.INSTANCE, TinyMappingsReader.INSTANCE, net.fabricmc.mappingio.format.MappingFormat.TINY_FILE), - SRG_FILE(SrgMappingsWriter.INSTANCE, null, net.fabricmc.mappingio.format.MappingFormat.SRG_FILE), - TSRG_FILE(null, null, net.fabricmc.mappingio.format.MappingFormat.TSRG_FILE), - TSRG_2_FILE(null, null, net.fabricmc.mappingio.format.MappingFormat.TSRG_2_FILE), - PROGUARD(null, ProguardMappingsReader.INSTANCE, net.fabricmc.mappingio.format.MappingFormat.PROGUARD_FILE), - RECAF(RecafMappingsWriter.INSTANCE, RecafMappingsReader.INSTANCE, null); + ENIGMA_FILE(EnigmaMappingsWriter.FILE, EnigmaMappingsReader.FILE, net.fabricmc.mappingio.format.MappingFormat.ENIGMA_FILE, true), + ENIGMA_DIRECTORY(EnigmaMappingsWriter.DIRECTORY, EnigmaMappingsReader.DIRECTORY, net.fabricmc.mappingio.format.MappingFormat.ENIGMA_DIR, true), + ENIGMA_ZIP(EnigmaMappingsWriter.ZIP, EnigmaMappingsReader.ZIP, null, false), + TINY_V2(new TinyV2Writer("intermediary", "named"), new TinyV2Reader(), net.fabricmc.mappingio.format.MappingFormat.TINY_2_FILE, true), + TINY_FILE(TinyMappingsWriter.INSTANCE, TinyMappingsReader.INSTANCE, net.fabricmc.mappingio.format.MappingFormat.TINY_FILE, true), + SRG_FILE(SrgMappingsWriter.INSTANCE, null, net.fabricmc.mappingio.format.MappingFormat.SRG_FILE, false), + TSRG_FILE(null, null, net.fabricmc.mappingio.format.MappingFormat.TSRG_FILE, false), + TSRG_2_FILE(null, null, net.fabricmc.mappingio.format.MappingFormat.TSRG_2_FILE, false), + PROGUARD(null, ProguardMappingsReader.INSTANCE, net.fabricmc.mappingio.format.MappingFormat.PROGUARD_FILE, true), + RECAF(RecafMappingsWriter.INSTANCE, RecafMappingsReader.INSTANCE, null, false); private final MappingsWriter writer; private final MappingsReader reader; private final net.fabricmc.mappingio.format.MappingFormat mappingIoCounterpart; + private final boolean hasMappingIoWriter; - MappingFormat(MappingsWriter writer, MappingsReader reader, net.fabricmc.mappingio.format.MappingFormat mappingIoCounterpart) { + MappingFormat(MappingsWriter writer, MappingsReader reader, net.fabricmc.mappingio.format.MappingFormat mappingIoCounterpart, boolean hasMappingIoWriter) { this.writer = writer; this.reader = reader; this.mappingIoCounterpart = mappingIoCounterpart; + this.hasMappingIoWriter = hasMappingIoWriter; } public void write(EntryTree mappings, Path path, ProgressListener progressListener, MappingSaveParameters saveParameters) { @@ -47,19 +59,49 @@ public enum MappingFormat { } public void write(EntryTree mappings, MappingDelta delta, Path path, ProgressListener progressListener, MappingSaveParameters saveParameters) { - if (writer == null) { - throw new IllegalStateException(name() + " does not support writing"); + if (!hasMappingIoWriter || !useMappingIo()) { + if (writer == null) { + throw new IllegalStateException(name() + " does not support writing"); + } + + writer.write(mappings, delta, path, progressListener, saveParameters); + return; } - writer.write(mappings, delta, path, progressListener, saveParameters); + try { + VisitableMappingTree tree = MappingIoConverter.toMappingIo(mappings, progressListener); + progressListener.init(1, I18n.translate("progress.mappings.writing")); + progressListener.step(1, null); // Reset message + + tree.accept(MappingWriter.create(path, mappingIoCounterpart), VisitOrder.createByName()); + progressListener.step(1, I18n.translate("progress.done")); + } catch (IOException e) { + throw new UncheckedIOException(e); + } } public EntryTree read(Path path, ProgressListener progressListener, MappingSaveParameters saveParameters) throws IOException, MappingParseException { - if (reader == null) { - throw new IllegalStateException(name() + " does not support reading"); + if (!useMappingIo()) { + if (reader == null) { + throw new IllegalStateException(name() + " does not support reading"); + } + + return reader.read(path, progressListener, saveParameters); } - return reader.read(path, progressListener, saveParameters); + String loadingMessage; + + if (mappingIoCounterpart.hasSingleFile()) { + loadingMessage = I18n.translate("progress.mappings.loading_file"); + } else { + loadingMessage = I18n.translate("progress.mappings.loading_directory"); + } + + progressListener.init(1, loadingMessage); + + VisitableMappingTree mappingTree = new MemoryMappingTree(); + MappingReader.read(path, mappingIoCounterpart, mappingTree); + return MappingIoConverter.fromMappingIo(mappingTree, progressListener); } @Nullable @@ -76,4 +118,35 @@ public enum MappingFormat { public net.fabricmc.mappingio.format.MappingFormat getMappingIoCounterpart() { return mappingIoCounterpart; } + + public boolean hasMappingIoWriter() { + return hasMappingIoWriter; + } + + public boolean isReadable() { + return reader != null || mappingIoCounterpart != null; + } + + public boolean isWritable() { + return writer != null || hasMappingIoWriter; + } + + private boolean useMappingIo() { + if (mappingIoCounterpart == null) return false; + return System.getProperty("enigma.use_mappingio", "true").equals("true"); + } + + public static List getReadableFormats() { + return Arrays.asList(values()) + .stream() + .filter(MappingFormat::isReadable) + .toList(); + } + + public static List getWritableFormats() { + return Arrays.asList(values()) + .stream() + .filter(MappingFormat::isWritable) + .toList(); + } } diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java index a0912fa..4372585 100644 --- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java +++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java @@ -33,19 +33,23 @@ import cuchaz.enigma.utils.I18n; public class MappingIoConverter { public static VisitableMappingTree toMappingIo(EntryTree mappings, ProgressListener progress) { + return toMappingIo(mappings, progress, "intermediary", "named"); + } + + public static VisitableMappingTree toMappingIo(EntryTree mappings, ProgressListener progress, String fromNs, String toNs) { try { List> classes = StreamSupport.stream(mappings.spliterator(), false) .filter(node -> node.getEntry() instanceof ClassEntry) .toList(); progress.init(classes.size(), I18n.translate("progress.mappings.converting.to_mappingio")); - int steps = 0; + int stepsDone = 0; MemoryMappingTree mappingTree = new MemoryMappingTree(); - mappingTree.visitNamespaces("intermediary", List.of("named")); + mappingTree.visitNamespaces(fromNs, List.of(toNs)); for (EntryTreeNode classNode : classes) { - progress.step(steps++, classNode.getEntry().getFullName()); + progress.step(++stepsDone, classNode.getEntry().getFullName()); writeClass(classNode, mappings, mappingTree); } -- cgit v1.2.3 From 2964590e594a757386558df577fd366eac045143 Mon Sep 17 00:00:00 2001 From: NebelNidas Date: Thu, 16 Nov 2023 13:43:18 +0100 Subject: Allow XSRG and CSRG to be imported --- .../java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'enigma/src/main/java') diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java index 4d34720..bbbf369 100644 --- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java +++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java @@ -36,7 +36,9 @@ public enum MappingFormat { ENIGMA_ZIP(EnigmaMappingsWriter.ZIP, EnigmaMappingsReader.ZIP, null, false), TINY_V2(new TinyV2Writer("intermediary", "named"), new TinyV2Reader(), net.fabricmc.mappingio.format.MappingFormat.TINY_2_FILE, true), TINY_FILE(TinyMappingsWriter.INSTANCE, TinyMappingsReader.INSTANCE, net.fabricmc.mappingio.format.MappingFormat.TINY_FILE, true), - SRG_FILE(SrgMappingsWriter.INSTANCE, null, net.fabricmc.mappingio.format.MappingFormat.SRG_FILE, false), + SRG_FILE(SrgMappingsWriter.INSTANCE, null, net.fabricmc.mappingio.format.MappingFormat.SRG_FILE, true), + XSRG_FILE(null, null, net.fabricmc.mappingio.format.MappingFormat.XSRG_FILE, true), + CSRG_FILE(null, null, net.fabricmc.mappingio.format.MappingFormat.CSRG_FILE, false), TSRG_FILE(null, null, net.fabricmc.mappingio.format.MappingFormat.TSRG_FILE, false), TSRG_2_FILE(null, null, net.fabricmc.mappingio.format.MappingFormat.TSRG_2_FILE, false), PROGUARD(null, ProguardMappingsReader.INSTANCE, net.fabricmc.mappingio.format.MappingFormat.PROGUARD_FILE, true), -- cgit v1.2.3 From 423f5cf98c6d419942301cca0c7c8169db8d4b30 Mon Sep 17 00:00:00 2001 From: NebelNidas Date: Thu, 16 Nov 2023 13:51:03 +0100 Subject: Fix importing mappings without field source descriptors --- .../translation/mapping/serde/MappingFormat.java | 8 +++- .../mapping/serde/MappingIoConverter.java | 50 +++++++++++++++++++--- 2 files changed, 50 insertions(+), 8 deletions(-) (limited to 'enigma/src/main/java') diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java index bbbf369..530aff4 100644 --- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java +++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java @@ -15,6 +15,7 @@ import net.fabricmc.mappingio.tree.VisitOrder; import net.fabricmc.mappingio.tree.VisitableMappingTree; import cuchaz.enigma.ProgressListener; +import cuchaz.enigma.analysis.index.JarIndex; import cuchaz.enigma.translation.mapping.EntryMapping; import cuchaz.enigma.translation.mapping.MappingDelta; import cuchaz.enigma.translation.mapping.serde.enigma.EnigmaMappingsReader; @@ -82,7 +83,12 @@ public enum MappingFormat { } } + @Deprecated public EntryTree read(Path path, ProgressListener progressListener, MappingSaveParameters saveParameters) throws IOException, MappingParseException { + return read(path, progressListener, saveParameters, null); + } + + public EntryTree read(Path path, ProgressListener progressListener, MappingSaveParameters saveParameters, JarIndex index) throws IOException, MappingParseException { if (!useMappingIo()) { if (reader == null) { throw new IllegalStateException(name() + " does not support reading"); @@ -103,7 +109,7 @@ public enum MappingFormat { VisitableMappingTree mappingTree = new MemoryMappingTree(); MappingReader.read(path, mappingIoCounterpart, mappingTree); - return MappingIoConverter.fromMappingIo(mappingTree, progressListener); + return MappingIoConverter.fromMappingIo(mappingTree, progressListener, index); } @Nullable diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java index 4372585..3843d8e 100644 --- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java +++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java @@ -7,6 +7,9 @@ import java.util.LinkedList; import java.util.List; import java.util.stream.StreamSupport; +import javax.annotation.Nullable; + +import org.jetbrains.annotations.ApiStatus; import net.fabricmc.mappingio.MappedElementKind; import net.fabricmc.mappingio.tree.MemoryMappingTree; import net.fabricmc.mappingio.tree.VisitableMappingTree; @@ -17,6 +20,7 @@ import net.fabricmc.mappingio.tree.MappingTree.MethodMapping; import net.fabricmc.mappingio.tree.MappingTree.MethodVarMapping; import cuchaz.enigma.ProgressListener; +import cuchaz.enigma.analysis.index.JarIndex; import cuchaz.enigma.translation.mapping.EntryMap; import cuchaz.enigma.translation.mapping.EntryMapping; import cuchaz.enigma.translation.mapping.tree.EntryTree; @@ -31,6 +35,7 @@ import cuchaz.enigma.translation.representation.entry.LocalVariableEntry; import cuchaz.enigma.translation.representation.entry.MethodEntry; import cuchaz.enigma.utils.I18n; +@ApiStatus.Internal public class MappingIoConverter { public static VisitableMappingTree toMappingIo(EntryTree mappings, ProgressListener progress) { return toMappingIo(mappings, progress, "intermediary", "named"); @@ -174,20 +179,20 @@ public class MappingIoConverter { mappingTree.visitComment(MappedElementKind.METHOD_VAR, varMapping.javadoc()); } - public static EntryTree fromMappingIo(VisitableMappingTree mappingTree, ProgressListener progress) { + public static EntryTree fromMappingIo(VisitableMappingTree mappingTree, ProgressListener progress, @Nullable JarIndex index) { EntryTree dstMappingTree = new HashEntryTree<>(); progress.init(mappingTree.getClasses().size(), I18n.translate("progress.mappings.converting.from_mappingio")); int steps = 0; for (ClassMapping classMapping : mappingTree.getClasses()) { progress.step(steps++, classMapping.getDstName(0) != null ? classMapping.getDstName(0) : classMapping.getSrcName()); - readClass(classMapping, dstMappingTree); + readClass(classMapping, dstMappingTree, index); } return dstMappingTree; } - private static void readClass(ClassMapping classMapping, EntryTree mappingTree) { + private static void readClass(ClassMapping classMapping, EntryTree mappingTree, JarIndex index) { ClassEntry currentClass = new ClassEntry(classMapping.getSrcName()); String dstName = classMapping.getDstName(0); @@ -198,7 +203,7 @@ public class MappingIoConverter { mappingTree.insert(currentClass, new EntryMapping(dstName, classMapping.getComment())); for (FieldMapping fieldMapping : classMapping.getFields()) { - readField(fieldMapping, currentClass, mappingTree); + readField(fieldMapping, currentClass, mappingTree, index); } for (MethodMapping methodMapping : classMapping.getMethods()) { @@ -206,9 +211,40 @@ public class MappingIoConverter { } } - private static void readField(FieldMapping fieldMapping, ClassEntry parent, EntryTree mappingTree) { - mappingTree.insert(new FieldEntry(parent, fieldMapping.getSrcName(), new TypeDescriptor(fieldMapping.getSrcDesc())), - new EntryMapping(fieldMapping.getDstName(0), fieldMapping.getComment())); + private static void readField(FieldMapping fieldMapping, ClassEntry parent, EntryTree mappingTree, JarIndex index) { + String srcDesc = fieldMapping.getSrcDesc(); + FieldEntry[] fieldEntries; + + if (srcDesc != null) { + fieldEntries = new FieldEntry[] { new FieldEntry(parent, fieldMapping.getSrcName(), new TypeDescriptor(fieldMapping.getSrcDesc())) }; + } else { + if (index == null) return; // Enigma requires source descriptors, and without an index we can't look them up + + fieldEntries = index.getChildrenByClass().get(parent).stream() + .filter(entry -> entry instanceof FieldEntry) + .filter(entry -> entry.getName().equals(fieldMapping.getSrcName())) + .toArray(FieldEntry[]::new); + + if (fieldEntries.length == 0) { // slow path for synthetics + fieldEntries = index.getEntryIndex().getFields().stream() + .filter(entry -> entry.getParent().getFullName().equals(parent.getFullName())) + .filter(entry -> { + if (entry.getName().equals(fieldMapping.getSrcName())) { + return true; + } else { + System.out.println("Entry name: " + entry.getName() + ", mapping name: " + fieldMapping.getSrcName()); + return false; + } + }) + .toArray(FieldEntry[]::new); + } + + if (fieldEntries.length == 0) return; // No target found, invalid mapping + } + + for (FieldEntry fieldEntry : fieldEntries) { + mappingTree.insert(fieldEntry, new EntryMapping(fieldMapping.getDstName(0), fieldMapping.getComment())); + } } private static void readMethod(MethodMapping methodMapping, ClassEntry parent, EntryTree mappingTree) { -- cgit v1.2.3 From edeeb253c9143b3cf53311e1c156fb9f1b2fe4db Mon Sep 17 00:00:00 2001 From: NebelNidas Date: Thu, 16 Nov 2023 14:40:57 +0100 Subject: Don't only write diffs when MIO writer was last used --- .../java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) (limited to 'enigma/src/main/java') diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java index 530aff4..88f722c 100644 --- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java +++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java @@ -49,6 +49,7 @@ public enum MappingFormat { private final MappingsReader reader; private final net.fabricmc.mappingio.format.MappingFormat mappingIoCounterpart; private final boolean hasMappingIoWriter; + private boolean lastUsedMappingIoWriter; MappingFormat(MappingsWriter writer, MappingsReader reader, net.fabricmc.mappingio.format.MappingFormat mappingIoCounterpart, boolean hasMappingIoWriter) { this.writer = writer; @@ -67,7 +68,8 @@ public enum MappingFormat { throw new IllegalStateException(name() + " does not support writing"); } - writer.write(mappings, delta, path, progressListener, saveParameters); + writer.write(mappings, lastUsedMappingIoWriter ? MappingDelta.added(mappings) : delta, path, progressListener, saveParameters); + lastUsedMappingIoWriter = false; return; } @@ -78,6 +80,7 @@ public enum MappingFormat { tree.accept(MappingWriter.create(path, mappingIoCounterpart), VisitOrder.createByName()); progressListener.step(1, I18n.translate("progress.done")); + lastUsedMappingIoWriter = true; } catch (IOException e) { throw new UncheckedIOException(e); } -- cgit v1.2.3 From 2d365a382db47a3503fb8007b16887d412eaa8dd Mon Sep 17 00:00:00 2001 From: NebelNidas Date: Thu, 16 Nov 2023 14:57:22 +0100 Subject: Mark MIO-related methods as internal --- .../java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'enigma/src/main/java') diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java index 88f722c..4521591 100644 --- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java +++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java @@ -13,6 +13,7 @@ import net.fabricmc.mappingio.MappingWriter; import net.fabricmc.mappingio.tree.MemoryMappingTree; import net.fabricmc.mappingio.tree.VisitOrder; import net.fabricmc.mappingio.tree.VisitableMappingTree; +import org.jetbrains.annotations.ApiStatus; import cuchaz.enigma.ProgressListener; import cuchaz.enigma.analysis.index.JarIndex; @@ -126,10 +127,12 @@ public enum MappingFormat { } @Nullable + @ApiStatus.Internal public net.fabricmc.mappingio.format.MappingFormat getMappingIoCounterpart() { return mappingIoCounterpart; } + @ApiStatus.Internal public boolean hasMappingIoWriter() { return hasMappingIoWriter; } @@ -142,6 +145,7 @@ public enum MappingFormat { return writer != null || hasMappingIoWriter; } + @ApiStatus.Internal private boolean useMappingIo() { if (mappingIoCounterpart == null) return false; return System.getProperty("enigma.use_mappingio", "true").equals("true"); -- cgit v1.2.3