add remapped patches as a testsoftspoon

1 files changed, 473 insertions, 0 deletions

diff --git a/patch-remap/mache-vineflower/net/minecraft/nbt/NbtIo.java.patch b/patch-remap/mache-vineflower/net/minecraft/nbt/NbtIo.java.patch
new file mode 100644
index 0000000000..fae3c9ea36
--- /dev/null
+++ b/patch-remap/mache-vineflower/net/minecraft/nbt/NbtIo.java.patch
@@ -0,0 +1,473 @@
+--- a/net/minecraft/nbt/NbtIo.java
++++ b/net/minecraft/nbt/NbtIo.java
+@@ -1,3 +1,4 @@
++// mc-dev import
+ package net.minecraft.nbt;
+ 
+ import java.io.BufferedOutputStream;
+@@ -10,6 +11,7 @@
+ import java.io.OutputStream;
+ import java.io.UTFDataFormatException;
+ import java.nio.file.Files;
++import java.nio.file.LinkOption;
+ import java.nio.file.OpenOption;
+ import java.nio.file.Path;
+ import java.nio.file.StandardOpenOption;
+@@ -23,87 +25,270 @@
+ import net.minecraft.util.FastBufferedInputStream;
+ 
+ public class NbtIo {
+-    private static final OpenOption[] SYNC_OUTPUT_OPTIONS = new OpenOption[]{
+-        StandardOpenOption.SYNC, StandardOpenOption.WRITE, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING
+-    };
+ 
+-    public static CompoundTag readCompressed(Path path, NbtAccounter nbtAccounter) throws IOException {
+-        CompoundTag var3;
+-        try (InputStream inputStream = Files.newInputStream(path)) {
+-            var3 = readCompressed(inputStream, nbtAccounter);
++    private static final OpenOption[] SYNC_OUTPUT_OPTIONS = new OpenOption[]{StandardOpenOption.SYNC, StandardOpenOption.WRITE, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING};
++
++    public NbtIo() {}
++
++    public static CompoundTag readCompressed(Path path, NbtAccounter nbtreadlimiter) throws IOException {
++        InputStream inputstream = Files.newInputStream(path);
++
++        CompoundTag nbttagcompound;
++
++        try {
++            nbttagcompound = readCompressed(inputstream, nbtreadlimiter);
++        } catch (Throwable throwable) {
++            if (inputstream != null) {
++                try {
++                    inputstream.close();
++                } catch (Throwable throwable1) {
++                    throwable.addSuppressed(throwable1);
++                }
++            }
++
++            throw throwable;
+         }
+ 
+-        return var3;
++        if (inputstream != null) {
++            inputstream.close();
++        }
++
++        return nbttagcompound;
+     }
+ 
+     private static DataInputStream createDecompressorStream(InputStream zippedStream) throws IOException {
+         return new DataInputStream(new FastBufferedInputStream(new GZIPInputStream(zippedStream)));
+     }
+ 
+-    private static DataOutputStream createCompressorStream(OutputStream outputStream) throws IOException {
+-        return new DataOutputStream(new BufferedOutputStream(new GZIPOutputStream(outputStream)));
++    private static DataOutputStream createCompressorStream(OutputStream outputstream) throws IOException {
++        return new DataOutputStream(new BufferedOutputStream(new GZIPOutputStream(outputstream)));
+     }
+ 
+-    public static CompoundTag readCompressed(InputStream inputStream, NbtAccounter nbtAccounter) throws IOException {
+-        CompoundTag var3;
+-        try (DataInputStream dataInputStream = createDecompressorStream(inputStream)) {
+-            var3 = read(dataInputStream, nbtAccounter);
++    public static CompoundTag readCompressed(InputStream inputstream, NbtAccounter nbtreadlimiter) throws IOException {
++        DataInputStream datainputstream = createDecompressorStream(inputstream);
++
++        CompoundTag nbttagcompound;
++
++        try {
++            nbttagcompound = read(datainputstream, nbtreadlimiter);
++        } catch (Throwable throwable) {
++            if (datainputstream != null) {
++                try {
++                    datainputstream.close();
++                } catch (Throwable throwable1) {
++                    throwable.addSuppressed(throwable1);
++                }
++            }
++
++            throw throwable;
+         }
+ 
+-        return var3;
++        if (datainputstream != null) {
++            datainputstream.close();
++        }
++
++        return nbttagcompound;
+     }
+ 
+-    public static void parseCompressed(Path path, StreamTagVisitor streamTagVisitor, NbtAccounter nbtAccounter) throws IOException {
+-        try (InputStream inputStream = Files.newInputStream(path)) {
+-            parseCompressed(inputStream, streamTagVisitor, nbtAccounter);
++    public static void parseCompressed(Path path, StreamTagVisitor streamtagvisitor, NbtAccounter nbtreadlimiter) throws IOException {
++        InputStream inputstream = Files.newInputStream(path);
++
++        try {
++            parseCompressed(inputstream, streamtagvisitor, nbtreadlimiter);
++        } catch (Throwable throwable) {
++            if (inputstream != null) {
++                try {
++                    inputstream.close();
++                } catch (Throwable throwable1) {
++                    throwable.addSuppressed(throwable1);
++                }
++            }
++
++            throw throwable;
+         }
++
++        if (inputstream != null) {
++            inputstream.close();
++        }
++
+     }
+ 
+-    public static void parseCompressed(InputStream inputStream, StreamTagVisitor streamTagVisitor, NbtAccounter nbtAccounter) throws IOException {
+-        try (DataInputStream dataInputStream = createDecompressorStream(inputStream)) {
+-            parse(dataInputStream, streamTagVisitor, nbtAccounter);
++    public static void parseCompressed(InputStream inputstream, StreamTagVisitor streamtagvisitor, NbtAccounter nbtreadlimiter) throws IOException {
++        DataInputStream datainputstream = createDecompressorStream(inputstream);
++
++        try {
++            parse(datainputstream, streamtagvisitor, nbtreadlimiter);
++        } catch (Throwable throwable) {
++            if (datainputstream != null) {
++                try {
++                    datainputstream.close();
++                } catch (Throwable throwable1) {
++                    throwable.addSuppressed(throwable1);
++                }
++            }
++
++            throw throwable;
+         }
++
++        if (datainputstream != null) {
++            datainputstream.close();
++        }
++
+     }
+ 
+-    public static void writeCompressed(CompoundTag compoundTag, Path path) throws IOException {
+-        try (
+-            OutputStream outputStream = Files.newOutputStream(path, SYNC_OUTPUT_OPTIONS);
+-            OutputStream outputStream1 = new BufferedOutputStream(outputStream);
+-        ) {
+-            writeCompressed(compoundTag, outputStream1);
++    public static void writeCompressed(CompoundTag nbttagcompound, Path path) throws IOException {
++        OutputStream outputstream = Files.newOutputStream(path, NbtIo.SYNC_OUTPUT_OPTIONS);
++
++        try {
++            BufferedOutputStream bufferedoutputstream = new BufferedOutputStream(outputstream);
++
++            try {
++                writeCompressed(nbttagcompound, (OutputStream) bufferedoutputstream);
++            } catch (Throwable throwable) {
++                try {
++                    bufferedoutputstream.close();
++                } catch (Throwable throwable1) {
++                    throwable.addSuppressed(throwable1);
++                }
++
++                throw throwable;
++            }
++
++            bufferedoutputstream.close();
++        } catch (Throwable throwable2) {
++            if (outputstream != null) {
++                try {
++                    outputstream.close();
++                } catch (Throwable throwable3) {
++                    throwable2.addSuppressed(throwable3);
++                }
++            }
++
++            throw throwable2;
+         }
++
++        if (outputstream != null) {
++            outputstream.close();
++        }
++
+     }
+ 
+     public static void writeCompressed(CompoundTag compoundTag, OutputStream outputStream) throws IOException {
+-        try (DataOutputStream dataOutputStream = createCompressorStream(outputStream)) {
+-            write(compoundTag, dataOutputStream);
++        DataOutputStream dataoutputstream = createCompressorStream(outputStream);
++
++        try {
++            write(compoundTag, (DataOutput) dataoutputstream);
++        } catch (Throwable throwable) {
++            if (dataoutputstream != null) {
++                try {
++                    dataoutputstream.close();
++                } catch (Throwable throwable1) {
++                    throwable.addSuppressed(throwable1);
++                }
++            }
++
++            throw throwable;
+         }
++
++        if (dataoutputstream != null) {
++            dataoutputstream.close();
++        }
++
+     }
+ 
+-    public static void write(CompoundTag compoundTag, Path path) throws IOException {
+-        try (
+-            OutputStream outputStream = Files.newOutputStream(path, SYNC_OUTPUT_OPTIONS);
+-            OutputStream outputStream1 = new BufferedOutputStream(outputStream);
+-            DataOutputStream dataOutputStream = new DataOutputStream(outputStream1);
+-        ) {
+-            write(compoundTag, dataOutputStream);
++    public static void write(CompoundTag nbttagcompound, Path path) throws IOException {
++        OutputStream outputstream = Files.newOutputStream(path, NbtIo.SYNC_OUTPUT_OPTIONS);
++
++        try {
++            BufferedOutputStream bufferedoutputstream = new BufferedOutputStream(outputstream);
++
++            try {
++                DataOutputStream dataoutputstream = new DataOutputStream(bufferedoutputstream);
++
++                try {
++                    write(nbttagcompound, (DataOutput) dataoutputstream);
++                } catch (Throwable throwable) {
++                    try {
++                        dataoutputstream.close();
++                    } catch (Throwable throwable1) {
++                        throwable.addSuppressed(throwable1);
++                    }
++
++                    throw throwable;
++                }
++
++                dataoutputstream.close();
++            } catch (Throwable throwable2) {
++                try {
++                    bufferedoutputstream.close();
++                } catch (Throwable throwable3) {
++                    throwable2.addSuppressed(throwable3);
++                }
++
++                throw throwable2;
++            }
++
++            bufferedoutputstream.close();
++        } catch (Throwable throwable4) {
++            if (outputstream != null) {
++                try {
++                    outputstream.close();
++                } catch (Throwable throwable5) {
++                    throwable4.addSuppressed(throwable5);
++                }
++            }
++
++            throw throwable4;
+         }
++
++        if (outputstream != null) {
++            outputstream.close();
++        }
++
+     }
+ 
+     @Nullable
+     public static CompoundTag read(Path path) throws IOException {
+-        if (!Files.exists(path)) {
++        if (!Files.exists(path, new LinkOption[0])) {
+             return null;
+         } else {
+-            CompoundTag var3;
+-            try (
+-                InputStream inputStream = Files.newInputStream(path);
+-                DataInputStream dataInputStream = new DataInputStream(inputStream);
+-            ) {
+-                var3 = read(dataInputStream, NbtAccounter.unlimitedHeap());
++            InputStream inputstream = Files.newInputStream(path);
++
++            CompoundTag nbttagcompound;
++
++            try {
++                DataInputStream datainputstream = new DataInputStream(inputstream);
++
++                try {
++                    nbttagcompound = read(datainputstream, NbtAccounter.unlimitedHeap());
++                } catch (Throwable throwable) {
++                    try {
++                        datainputstream.close();
++                    } catch (Throwable throwable1) {
++                        throwable.addSuppressed(throwable1);
++                    }
++
++                    throw throwable;
++                }
++
++                datainputstream.close();
++            } catch (Throwable throwable2) {
++                if (inputstream != null) {
++                    try {
++                        inputstream.close();
++                    } catch (Throwable throwable3) {
++                        throwable2.addSuppressed(throwable3);
++                    }
++                }
++
++                throw throwable2;
+             }
+ 
+-            return var3;
++            if (inputstream != null) {
++                inputstream.close();
++            }
++
++            return nbttagcompound;
+         }
+     }
+ 
+@@ -112,9 +297,10 @@
+     }
+ 
+     public static CompoundTag read(DataInput input, NbtAccounter accounter) throws IOException {
+-        Tag unnamedTag = readUnnamedTag(input, accounter);
+-        if (unnamedTag instanceof CompoundTag) {
+-            return (CompoundTag)unnamedTag;
++        Tag nbtbase = readUnnamedTag(input, accounter);
++
++        if (nbtbase instanceof CompoundTag) {
++            return (CompoundTag) nbtbase;
+         } else {
+             throw new IOException("Root tag must be a named compound tag");
+         }
+@@ -124,37 +310,41 @@
+         writeUnnamedTagWithFallback(compoundTag, output);
+     }
+ 
+-    public static void parse(DataInput dataInput, StreamTagVisitor streamTagVisitor, NbtAccounter nbtAccounter) throws IOException {
+-        TagType<?> type = TagTypes.getType(dataInput.readByte());
+-        if (type == EndTag.TYPE) {
+-            if (streamTagVisitor.visitRootEntry(EndTag.TYPE) == StreamTagVisitor.ValueResult.CONTINUE) {
+-                streamTagVisitor.visitEnd();
++    public static void parse(DataInput datainput, StreamTagVisitor streamtagvisitor, NbtAccounter nbtreadlimiter) throws IOException {
++        TagType<?> nbttagtype = TagTypes.getType(datainput.readByte());
++
++        if (nbttagtype == EndTag.TYPE) {
++            if (streamtagvisitor.visitRootEntry(EndTag.TYPE) == StreamTagVisitor.b.CONTINUE) {
++                streamtagvisitor.visitEnd();
+             }
++
+         } else {
+-            switch (streamTagVisitor.visitRootEntry(type)) {
++            switch (streamtagvisitor.visitRootEntry(nbttagtype)) {
+                 case HALT:
+                 default:
+                     break;
+                 case BREAK:
+-                    StringTag.skipString(dataInput);
+-                    type.skip(dataInput, nbtAccounter);
++                    StringTag.skipString(datainput);
++                    nbttagtype.skip(datainput, nbtreadlimiter);
+                     break;
+                 case CONTINUE:
+-                    StringTag.skipString(dataInput);
+-                    type.parse(dataInput, streamTagVisitor, nbtAccounter);
++                    StringTag.skipString(datainput);
++                    nbttagtype.parse(datainput, streamtagvisitor, nbtreadlimiter);
+             }
++
+         }
+     }
+ 
+-    public static Tag readAnyTag(DataInput dataInput, NbtAccounter nbtAccounter) throws IOException {
+-        byte _byte = dataInput.readByte();
+-        return (Tag)(_byte == 0 ? EndTag.INSTANCE : readTagSafe(dataInput, nbtAccounter, _byte));
++    public static Tag readAnyTag(DataInput datainput, NbtAccounter nbtreadlimiter) throws IOException {
++        byte b0 = datainput.readByte();
++
++        return (Tag) (b0 == 0 ? EndTag.INSTANCE : readTagSafe(datainput, nbtreadlimiter, b0));
+     }
+ 
+-    public static void writeAnyTag(Tag tag, DataOutput dataOutput) throws IOException {
+-        dataOutput.writeByte(tag.getId());
+-        if (tag.getId() != 0) {
+-            tag.write(dataOutput);
++    public static void writeAnyTag(Tag nbtbase, DataOutput dataoutput) throws IOException {
++        dataoutput.writeByte(nbtbase.getId());
++        if (nbtbase.getId() != 0) {
++            nbtbase.write(dataoutput);
+         }
+     }
+ 
+@@ -166,44 +356,48 @@
+         }
+     }
+ 
+-    public static void writeUnnamedTagWithFallback(Tag tag, DataOutput dataOutput) throws IOException {
+-        writeUnnamedTag(tag, new NbtIo.StringFallbackDataOutput(dataOutput));
++    public static void writeUnnamedTagWithFallback(Tag nbtbase, DataOutput dataoutput) throws IOException {
++        writeUnnamedTag(nbtbase, new NbtIo.a(dataoutput));
+     }
+ 
+-    private static Tag readUnnamedTag(DataInput dataInput, NbtAccounter nbtAccounter) throws IOException {
+-        byte _byte = dataInput.readByte();
+-        if (_byte == 0) {
++    private static Tag readUnnamedTag(DataInput datainput, NbtAccounter nbtreadlimiter) throws IOException {
++        byte b0 = datainput.readByte();
++
++        if (b0 == 0) {
+             return EndTag.INSTANCE;
+         } else {
+-            StringTag.skipString(dataInput);
+-            return readTagSafe(dataInput, nbtAccounter, _byte);
++            StringTag.skipString(datainput);
++            return readTagSafe(datainput, nbtreadlimiter, b0);
+         }
+     }
+ 
+-    private static Tag readTagSafe(DataInput dataInput, NbtAccounter nbtAccounter, byte b) {
++    private static Tag readTagSafe(DataInput datainput, NbtAccounter nbtreadlimiter, byte b0) {
+         try {
+-            return TagTypes.getType(b).load(dataInput, nbtAccounter);
+-        } catch (IOException var6) {
+-            CrashReport crashReport = CrashReport.forThrowable(var6, "Loading NBT data");
+-            CrashReportCategory crashReportCategory = crashReport.addCategory("NBT Tag");
+-            crashReportCategory.setDetail("Tag type", b);
+-            throw new ReportedNbtException(crashReport);
++            return TagTypes.getType(b0).load(datainput, nbtreadlimiter);
++        } catch (IOException ioexception) {
++            CrashReport crashreport = CrashReport.forThrowable(ioexception, "Loading NBT data");
++            CrashReportCategory crashreportsystemdetails = crashreport.addCategory("NBT Tag");
++
++            crashreportsystemdetails.setDetail("Tag type", (Object) b0);
++            throw new ReportedNbtException(crashreport);
+         }
+     }
+ 
+-    public static class StringFallbackDataOutput extends DelegateDataOutput {
+-        public StringFallbackDataOutput(DataOutput dataOutput) {
+-            super(dataOutput);
++    public static class a extends DelegateDataOutput {
++
++        public a(DataOutput dataoutput) {
++            super(dataoutput);
+         }
+ 
+         @Override
+-        public void writeUTF(String string) throws IOException {
++        public void writeUTF(String s) throws IOException {
+             try {
+-                super.writeUTF(string);
+-            } catch (UTFDataFormatException var3) {
+-                Util.logAndPauseIfInIde("Failed to write NBT String", var3);
++                super.writeUTF(s);
++            } catch (UTFDataFormatException utfdataformatexception) {
++                Util.logAndPauseIfInIde("Failed to write NBT String", utfdataformatexception);
+                 super.writeUTF("");
+             }
++
+         }
+     }
+ }