path: root/patch-remap/mache-vineflower/net/minecraft/nbt/NbtIo.java.patch

--- 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("");
             }
+
         }
     }
 }