authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-06-24 11:35:03-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-07-01 16:35:30-07:00
logc27ab8b45d767388eba5c3e69fc4b4764ae5e1c4
tree2e9e42a25fbf0aed4c683ea61723ff82aba769c1
parent743326f8e929238a843697397d21361c4081fead

std: update zstd to new API

5 files changed, 59 insertions(+), 41 deletions(-)

lib/std/compress/zstd.zig+6-4
......@@ -81,10 +81,11 @@ pub const table_size_max = struct {
8181fn testDecompress(gpa: std.mem.Allocator, compressed: []const u8) ![]u8 {
8282 var out: std.ArrayListUnmanaged(u8) = .empty;
8383 defer out.deinit(gpa);
84 try out.ensureUnusedCapacity(gpa, default_window_len);
8485
8586 var in: std.io.Reader = .fixed(compressed);
86 var zstd_stream: Decompress = .init(&in, .{});
87 try zstd_stream.reader().readRemainingArrayList(gpa, null, &out, .unlimited, default_window_len);
87 var zstd_stream: Decompress = .init(&in, &.{}, .{});
88 try zstd_stream.interface.appendRemaining(gpa, null, &out, .unlimited);
8889
8990 return out.toOwnedSlice(gpa);
9091}
......@@ -101,12 +102,13 @@ fn testExpectDecompressError(err: anyerror, compressed: []const u8) !void {
101102
102103 var out: std.ArrayListUnmanaged(u8) = .empty;
103104 defer out.deinit(gpa);
105 try out.ensureUnusedCapacity(gpa, default_window_len);
104106
105107 var in: std.io.Reader = .fixed(compressed);
106 var zstd_stream: Decompress = .init(&in, .{});
108 var zstd_stream: Decompress = .init(&in, &.{}, .{});
107109 try std.testing.expectError(
108110 error.ReadFailed,
109 zstd_stream.reader().readRemainingArrayList(gpa, null, &out, .unlimited, default_window_len),
111 zstd_stream.interface.appendRemaining(gpa, null, &out, .unlimited),
110112 );
111113 try std.testing.expectError(err, zstd_stream.err orelse {});
112114}
lib/std/compress/zstd/Decompress.zig+13-13
......@@ -7,6 +7,7 @@ const zstd = @import("../zstd.zig");
77const Writer = std.io.Writer;
88
99input: *Reader,
10interface: Reader,
1011state: State,
1112verify_checksum: bool,
1213err: ?Error = null,
......@@ -62,34 +63,33 @@ pub const Error = error{
6263 WindowSizeUnknown,
6364};
6465
65pub fn init(input: *Reader, options: Options) Decompress {
66pub fn init(input: *Reader, buffer: []u8, options: Options) Decompress {
6667 return .{
6768 .input = input,
6869 .state = .new_frame,
6970 .verify_checksum = options.verify_checksum,
71 .interface = .{
72 .vtable = &.{ .stream = stream },
73 .buffer = buffer,
74 .seek = 0,
75 .end = 0,
76 },
7077 };
7178}
7279
73pub fn reader(self: *Decompress) Reader {
74 return .{
75 .context = self,
76 .vtable = &.{ .read = read },
77 };
78}
79
80fn read(context: ?*anyopaque, bw: *Writer, limit: Limit) Reader.StreamError!usize {
81 const d: *Decompress = @ptrCast(@alignCast(context));
80fn stream(r: *Reader, w: *Writer, limit: Limit) Reader.StreamError!usize {
81 const d: *Decompress = @alignCast(@fieldParentPtr("interface", r));
8282 const in = d.input;
8383
8484 switch (d.state) {
8585 .new_frame => {
8686 // Allow error.EndOfStream only on the frame magic.
8787 const magic = try in.takeEnumNonexhaustive(Frame.Magic, .little);
88 initFrame(d, bw.buffer.len, magic) catch |err| {
88 initFrame(d, w.buffer.len, magic) catch |err| {
8989 d.err = err;
9090 return error.ReadFailed;
9191 };
92 return readInFrame(d, bw, limit, &d.state.in_frame) catch |err| switch (err) {
92 return readInFrame(d, w, limit, &d.state.in_frame) catch |err| switch (err) {
9393 error.ReadFailed => return error.ReadFailed,
9494 error.WriteFailed => return error.WriteFailed,
9595 else => |e| {
......@@ -99,7 +99,7 @@ fn read(context: ?*anyopaque, bw: *Writer, limit: Limit) Reader.StreamError!usiz
9999 };
100100 },
101101 .in_frame => |*in_frame| {
102 return readInFrame(d, bw, limit, in_frame) catch |err| switch (err) {
102 return readInFrame(d, w, limit, in_frame) catch |err| switch (err) {
103103 error.ReadFailed => return error.ReadFailed,
104104 error.WriteFailed => return error.WriteFailed,
105105 else => |e| {
lib/std/fs/File.zig+10-3
......@@ -1047,12 +1047,11 @@ pub const Reader = struct {
10471047 const r: *Reader = @fieldParentPtr("interface", io_reader);
10481048 switch (r.mode) {
10491049 .positional, .streaming => return w.sendFile(r, limit) catch |write_err| switch (write_err) {
1050 error.ReadFailed => return error.ReadFailed,
1051 error.WriteFailed => return error.WriteFailed,
10521050 error.Unimplemented => {
10531051 r.mode = r.mode.toReading();
10541052 return 0;
10551053 },
1054 else => |e| return e,
10561055 },
10571056 .positional_reading => {
10581057 if (is_windows) {
......@@ -1239,7 +1238,7 @@ pub const Reader = struct {
12391238
12401239 pub fn atEnd(r: *Reader) bool {
12411240 // Even if stat fails, size is set when end is encountered.
1242 const size = r.getSize() orelse return false;
1241 const size = r.size orelse return false;
12431242 return size - r.pos == 0;
12441243 }
12451244};
......@@ -1460,6 +1459,10 @@ pub const Writer = struct {
14601459 return 0;
14611460 },
14621461 };
1462 if (n == 0) {
1463 file_reader.size = file_reader.pos;
1464 return error.EndOfStream;
1465 }
14631466 file_reader.pos += n;
14641467 w.pos += n;
14651468 return n;
......@@ -1497,6 +1500,10 @@ pub const Writer = struct {
14971500 w.copy_file_range_err = err;
14981501 return 0;
14991502 };
1503 if (n == 0) {
1504 file_reader.size = file_reader.pos;
1505 return error.EndOfStream;
1506 }
15001507 file_reader.pos += n;
15011508 w.pos += n;
15021509 return n;
lib/std/io/Reader.zig+3-3
......@@ -146,7 +146,7 @@ pub fn discard(r: *Reader, limit: Limit) Error!usize {
146146 } else .unlimited;
147147 r.seek = 0;
148148 r.end = 0;
149 const n = r.vtable.discard(r, remaining);
149 const n = try r.vtable.discard(r, remaining);
150150 assert(n <= @intFromEnum(remaining));
151151 return buffered_len + n;
152152}
......@@ -386,7 +386,7 @@ pub fn readVecAll(r: *Reader, data: [][]u8) Error!void {
386386pub fn readAll(r: *Reader, w: *Writer, limit: Limit) StreamError!void {
387387 var remaining = limit;
388388 while (remaining.nonzero()) {
389 const n = try r.read(w, remaining);
389 const n = try r.stream(w, remaining);
390390 remaining = remaining.subtract(n).?;
391391 }
392392}
......@@ -1472,7 +1472,7 @@ pub fn Hashed(comptime Hasher: type) type {
14721472 fn discard(r: *Reader, limit: Limit) Error!usize {
14731473 const this: *@This() = @alignCast(@fieldParentPtr("interface", r));
14741474 var w = this.hasher.writer(&.{});
1475 const n = this.in.read(&w, limit) catch |err| switch (err) {
1475 const n = this.in.stream(&w, limit) catch |err| switch (err) {
14761476 error.WriteFailed => unreachable,
14771477 else => |e| return e,
14781478 };
lib/std/io/Writer.zig+27-18
......@@ -84,18 +84,29 @@ pub const Error = error{
8484 WriteFailed,
8585};
8686
87pub const ReadingFileError = error{
87pub const FileAllError = error{
8888 /// Detailed diagnostics are found on the `File.Reader` struct.
8989 ReadFailed,
9090 /// See the `Writer` implementation for detailed diagnostics.
9191 WriteFailed,
9292};
9393
94pub const FileReadingError = error{
95 /// Detailed diagnostics are found on the `File.Reader` struct.
96 ReadFailed,
97 /// See the `Writer` implementation for detailed diagnostics.
98 WriteFailed,
99 /// Reached the end of the file being read.
100 EndOfStream,
101};
102
94103pub const FileError = error{
95104 /// Detailed diagnostics are found on the `File.Reader` struct.
96105 ReadFailed,
97106 /// See the `Writer` implementation for detailed diagnostics.
98107 WriteFailed,
108 /// Reached the end of the file being read.
109 EndOfStream,
99110 /// Indicates the caller should do its own file reading; the callee cannot
100111 /// offer a more efficient implementation.
101112 Unimplemented,
......@@ -642,28 +653,24 @@ pub fn sendFileTo(w: *Writer, other: *Writer, file_reader: *File.Reader, limit:
642653}
643654
644655/// Asserts nonzero buffer capacity.
645pub fn sendFileReading(w: *Writer, file_reader: *File.Reader, limit: Limit) ReadingFileError!usize {
656pub fn sendFileReading(w: *Writer, file_reader: *File.Reader, limit: Limit) FileReadingError!usize {
646657 const dest = limit.slice(try w.writableSliceGreedy(1));
647 const n = file_reader.read(dest) catch |err| switch (err) {
648 error.EndOfStream => 0,
649 error.ReadFailed => return error.ReadFailed,
650 };
658 const n = try file_reader.read(dest);
651659 w.advance(n);
652660 return n;
653661}
654662
655pub fn sendFileAll(w: *Writer, file_reader: *File.Reader, limit: Limit) ReadingFileError!usize {
663pub fn sendFileAll(w: *Writer, file_reader: *File.Reader, limit: Limit) FileAllError!usize {
656664 var remaining = @intFromEnum(limit);
657665 while (remaining > 0) {
658666 const n = sendFile(w, file_reader, .limited(remaining)) catch |err| switch (err) {
659 error.EndOfStream => return 0,
660 error.ReadFailed => return error.ReadFailed,
661 error.WriteFailed => return error.WriteFailed,
667 error.EndOfStream => break,
662668 error.Unimplemented => {
663669 file_reader.mode = file_reader.mode.toReading();
664 try w.sendFileReadingAll(file_reader, remaining);
665 return;
670 remaining -= try w.sendFileReadingAll(file_reader, .limited(remaining));
671 break;
666672 },
673 else => |e| return e,
667674 };
668675 remaining -= n;
669676 }
......@@ -676,13 +683,15 @@ pub fn sendFileAll(w: *Writer, file_reader: *File.Reader, limit: Limit) ReadingF
676683/// that error code does not appear in this function's error set.
677684///
678685/// Asserts nonzero buffer capacity.
679pub fn sendFileReadingAll(w: *Writer, file_reader: *File.Reader, limit: Limit) ReadingFileError!void {
680 var remaining = limit;
681 while (remaining.nonzero()) {
682 const n = try sendFileReading(w, file_reader, remaining);
683 if (n == 0) return;
684 remaining = remaining.subtract(n).?;
686pub fn sendFileReadingAll(w: *Writer, file_reader: *File.Reader, limit: Limit) FileAllError!usize {
687 var remaining = @intFromEnum(limit);
688 while (remaining > 0) {
689 remaining -= sendFileReading(w, file_reader, .limited(remaining)) catch |err| switch (err) {
690 error.EndOfStream => break,
691 else => |e| return e,
692 };
685693 }
694 return @intFromEnum(limit) - remaining;
686695}
687696
688697pub fn alignBuffer(