authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-06-27 17:46:22-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-07-01 16:35:30-07:00
logc9915e949ebd4aa0d4d24ef5808ba0b1cff2ecfe
tree88e25116a93a810f1972dbb2b2232fbf41cf1b43
parentbc9db143c9e2beb166c637dd7fc56c4912f93794

std: fix some compilation errors

14 files changed, 90 insertions(+), 106 deletions(-)

lib/std/Build.zig+2-2
......@@ -2802,8 +2802,8 @@ pub fn dumpBadGetPathHelp(
28022802 src_builder: *Build,
28032803 asking_step: ?*Step,
28042804) anyerror!void {
2805 var fw = stderr.writer();
2806 var bw = fw.interface().unbuffered();
2805 var fw = stderr.writer(&.{});
2806 const bw = &fw.interface;
28072807 try bw.print(
28082808 \\getPath() was called on a GeneratedFile that wasn't built yet.
28092809 \\ source package path: {s}
lib/std/Build/Cache.zig+2-2
......@@ -661,9 +661,9 @@ pub const Manifest = struct {
661661 } {
662662 const gpa = self.cache.gpa;
663663 const input_file_count = self.files.entries.len;
664 var manifest_reader = self.manifest_file.?.reader(); // Reads positionally from zero.
664 var manifest_reader = self.manifest_file.?.reader(&.{}); // Reads positionally from zero.
665665 const limit: std.io.Limit = .limited(manifest_file_size_max);
666 const file_contents = manifest_reader.interface().allocRemaining(gpa, limit) catch |err| switch (err) {
666 const file_contents = manifest_reader.interface.allocRemaining(gpa, limit) catch |err| switch (err) {
667667 error.OutOfMemory => return error.OutOfMemory,
668668 error.StreamTooLong => return error.OutOfMemory,
669669 error.ReadFailed => {
lib/std/Build/Step.zig+2-2
......@@ -287,8 +287,8 @@ pub fn cast(step: *Step, comptime T: type) ?*T {
287287
288288/// For debugging purposes, prints identifying information about this Step.
289289pub fn dump(step: *Step, file: std.fs.File) void {
290 var fw = file.writer();
291 var bw = fw.interface().unbuffered();
290 var fw = file.writer(&.{});
291 const bw = &fw.interface;
292292 const tty_config = std.io.tty.detectConfig(file);
293293 const debug_info = std.debug.getSelfDebugInfo() catch |err| {
294294 bw.print("Unable to dump stack trace: Unable to open debug info: {s}\n", .{
lib/std/Build/Step/ConfigHeader.zig+3-3
......@@ -753,17 +753,17 @@ fn testReplaceVariablesAutoconfAt(
753753 expected: []const u8,
754754 values: std.StringArrayHashMap(Value),
755755) !void {
756 var output: std.ArrayList(u8) = .init(allocator);
756 var output: std.io.Writer.Allocating = .init(allocator);
757757 defer output.deinit();
758758
759759 const used = try allocator.alloc(bool, values.count());
760760 for (used) |*u| u.* = false;
761761 defer allocator.free(used);
762762
763 try expand_variables_autoconf_at(&output, contents, values, used);
763 try expand_variables_autoconf_at(&output.interface, contents, values, used);
764764
765765 for (used) |u| if (!u) return error.UnusedValue;
766 try std.testing.expectEqualStrings(expected, output.items);
766 try std.testing.expectEqualStrings(expected, output.getWritten());
767767}
768768
769769fn testReplaceVariablesCMake(
lib/std/Build/Step/Options.zig+1-1
......@@ -667,5 +667,5 @@ test Options {
667667 \\
668668 , options.contents.items);
669669
670 _ = try std.zig.Ast.parse(arena.allocator(), try options.contents.toOwnedSliceSentinel(0), .zig);
670 _ = try std.zig.Ast.parse(arena.allocator(), try options.contents.toOwnedSliceSentinel(arena.allocator(), 0), .zig);
671671}
lib/std/Thread.zig+9-8
......@@ -163,11 +163,12 @@ pub fn setName(self: Thread, name: []const u8) SetNameError!void {
163163 } else {
164164 var buf: [32]u8 = undefined;
165165 const path = try std.fmt.bufPrint(&buf, "/proc/self/task/{d}/comm", .{self.getHandle()});
166
167166 const file = try std.fs.cwd().openFile(path, .{ .mode = .write_only });
168167 defer file.close();
169
170 try file.writer().writeAll(name);
168 var fw = file.writer(&.{});
169 fw.interface.writeAll(name) catch |err| switch (err) {
170 error.WriteFailed => return fw.err.?,
171 };
171172 return;
172173 },
173174 .windows => {
......@@ -277,13 +278,13 @@ pub fn getName(self: Thread, buffer_ptr: *[max_name_len:0]u8) GetNameError!?[]co
277278 } else {
278279 var buf: [32]u8 = undefined;
279280 const path = try std.fmt.bufPrint(&buf, "/proc/self/task/{d}/comm", .{self.getHandle()});
280
281281 const file = try std.fs.cwd().openFile(path, .{});
282282 defer file.close();
283
284 const data_len = try file.reader().readAll(buffer_ptr[0 .. max_name_len + 1]);
285
286 return if (data_len >= 1) buffer[0 .. data_len - 1] else null;
283 var fr = file.reader(&.{});
284 const n = fr.interface.readSliceShort(buffer_ptr[0 .. max_name_len + 1]) catch |err| switch (err) {
285 error.ReadFailed => return fr.err.?,
286 };
287 return if (n == 0) null else buffer[0 .. n - 1];
287288 },
288289 .windows => {
289290 const buf_capacity = @sizeOf(windows.UNICODE_STRING) + (@sizeOf(u16) * max_name_len);
lib/std/compress/flate.zig+27-27
......@@ -232,16 +232,15 @@ test "compress/decompress" {
232232 {
233233 var original: std.io.Reader = .fixed(data);
234234 var compressed: Writer = .fixed(&cmp_buf);
235 var compress: Compress = .init(&original, .raw);
236 var compress_br = compress.readable(&.{});
237 const n = try compress_br.readRemaining(&compressed, .{ .level = level });
235 var compress: Compress = .init(&original, &.{}, .{ .container = .raw, .level = level });
236 const n = try compress.reader.streamRemaining(&compressed);
238237 if (compressed_size == 0) {
239238 if (container == .gzip)
240239 print("case {d} gzip level {} compressed size: {d}\n", .{ case_no, level, compressed.pos });
241 compressed_size = compressed.pos;
240 compressed_size = compressed.end;
242241 }
243242 try testing.expectEqual(compressed_size, n);
244 try testing.expectEqual(compressed_size, compressed.pos);
243 try testing.expectEqual(compressed_size, compressed.end);
245244 }
246245 // decompress compressed stream to decompressed stream
247246 {
......@@ -450,12 +449,15 @@ test "gzip header" {
450449}
451450
452451test "public interface" {
453 const plain_data = [_]u8{ 'H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', 0x0a };
452 const plain_data_buf = [_]u8{ 'H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', 0x0a };
454453
455454 // deflate final stored block, header + plain (stored) data
456455 const deflate_block = [_]u8{
457456 0b0000_0001, 0b0000_1100, 0x00, 0b1111_0011, 0xff, // deflate fixed buffer header len, nlen
458 } ++ plain_data;
457 } ++ plain_data_buf;
458
459 const plain_data: []const u8 = &plain_data_buf;
460 const gzip_data: []const u8 = &deflate_block;
459461
460462 //// gzip header/footer + deflate block
461463 //const gzip_data =
......@@ -471,23 +473,21 @@ test "public interface" {
471473 // TODO
472474 //const gzip = @import("gzip.zig");
473475 //const zlib = @import("zlib.zig");
474 const flate = @This();
475476
476 //try testInterface(gzip, &gzip_data, &plain_data);
477 //try testInterface(zlib, &zlib_data, &plain_data);
478 try testInterface(flate, &deflate_block, &plain_data);
479}
480
481fn testInterface(comptime pkg: type, gzip_data: []const u8, plain_data: []const u8) !void {
482477 var buffer1: [64]u8 = undefined;
483478 var buffer2: [64]u8 = undefined;
484479
480 // TODO These used to be functions, need to migrate the tests
481 const decompress = void;
482 const compress = void;
483 const store = void;
484
485485 // decompress
486486 {
487487 var plain: Writer = .fixed(&buffer2);
488488
489489 var in: std.io.Reader = .fixed(gzip_data);
490 try pkg.decompress(&in, &plain);
490 try decompress(&in, &plain);
491491 try testing.expectEqualSlices(u8, plain_data, plain.getWritten());
492492 }
493493
......@@ -497,10 +497,10 @@ fn testInterface(comptime pkg: type, gzip_data: []const u8, plain_data: []const
497497 var compressed: Writer = .fixed(&buffer1);
498498
499499 var in: std.io.Reader = .fixed(plain_data);
500 try pkg.compress(&in, &compressed, .{});
500 try compress(&in, &compressed, .{});
501501
502502 var compressed_br: std.io.Reader = .fixed(&buffer1);
503 try pkg.decompress(&compressed_br, &plain);
503 try decompress(&compressed_br, &plain);
504504 try testing.expectEqualSlices(u8, plain_data, plain.getWritten());
505505 }
506506
......@@ -510,12 +510,12 @@ fn testInterface(comptime pkg: type, gzip_data: []const u8, plain_data: []const
510510 var compressed: Writer = .fixed(&buffer1);
511511
512512 var in: std.io.Reader = .fixed(plain_data);
513 var cmp = try pkg.compressor(&compressed, .{});
513 var cmp = try Compress(&compressed, .{});
514514 try cmp.compress(&in);
515515 try cmp.finish();
516516
517517 var compressed_br: std.io.Reader = .fixed(&buffer1);
518 var dcp = pkg.decompressor(&compressed_br);
518 var dcp = Decompress(&compressed_br);
519519 try dcp.decompress(&plain);
520520 try testing.expectEqualSlices(u8, plain_data, plain.getWritten());
521521 }
......@@ -528,10 +528,10 @@ fn testInterface(comptime pkg: type, gzip_data: []const u8, plain_data: []const
528528 var compressed: Writer = .fixed(&buffer1);
529529
530530 var in: std.io.Reader = .fixed(plain_data);
531 try pkg.huffman.compress(&in, &compressed);
531 try huffman.compress(&in, &compressed);
532532
533533 var compressed_br: std.io.Reader = .fixed(&buffer1);
534 try pkg.decompress(&compressed_br, &plain);
534 try decompress(&compressed_br, &plain);
535535 try testing.expectEqualSlices(u8, plain_data, plain.getWritten());
536536 }
537537
......@@ -541,12 +541,12 @@ fn testInterface(comptime pkg: type, gzip_data: []const u8, plain_data: []const
541541 var compressed: Writer = .fixed(&buffer1);
542542
543543 var in: std.io.Reader = .fixed(plain_data);
544 var cmp = try pkg.huffman.compressor(&compressed);
544 var cmp = try huffman.Compressor(&compressed);
545545 try cmp.compress(&in);
546546 try cmp.finish();
547547
548548 var compressed_br: std.io.Reader = .fixed(&buffer1);
549 try pkg.decompress(&compressed_br, &plain);
549 try decompress(&compressed_br, &plain);
550550 try testing.expectEqualSlices(u8, plain_data, plain.getWritten());
551551 }
552552 }
......@@ -559,10 +559,10 @@ fn testInterface(comptime pkg: type, gzip_data: []const u8, plain_data: []const
559559 var compressed: Writer = .fixed(&buffer1);
560560
561561 var in: std.io.Reader = .fixed(plain_data);
562 try pkg.store.compress(&in, &compressed);
562 try store.compress(&in, &compressed);
563563
564564 var compressed_br: std.io.Reader = .fixed(&buffer1);
565 try pkg.decompress(&compressed_br, &plain);
565 try decompress(&compressed_br, &plain);
566566 try testing.expectEqualSlices(u8, plain_data, plain.getWritten());
567567 }
568568
......@@ -572,12 +572,12 @@ fn testInterface(comptime pkg: type, gzip_data: []const u8, plain_data: []const
572572 var compressed: Writer = .fixed(&buffer1);
573573
574574 var in: std.io.Reader = .fixed(plain_data);
575 var cmp = try pkg.store.compressor(&compressed);
575 var cmp = try store.compressor(&compressed);
576576 try cmp.compress(&in);
577577 try cmp.finish();
578578
579579 var compressed_br: std.io.Reader = .fixed(&buffer1);
580 try pkg.decompress(&compressed_br, &plain);
580 try decompress(&compressed_br, &plain);
581581 try testing.expectEqualSlices(u8, plain_data, plain.getWritten());
582582 }
583583 }
lib/std/compress/flate/Compress.zig+17-23
......@@ -48,6 +48,7 @@ const expect = testing.expect;
4848const mem = std.mem;
4949const math = std.math;
5050const Writer = std.io.Writer;
51const Reader = std.io.Reader;
5152
5253const Compress = @This();
5354const Token = @import("Token.zig");
......@@ -64,20 +65,13 @@ input: *std.io.Reader,
6465block_writer: BlockWriter,
6566level: LevelArgs,
6667hasher: Container.Hasher,
68reader: std.io.Reader,
6769
6870// Match and literal at the previous position.
6971// Used for lazy match finding in processWindow.
7072prev_match: ?Token = null,
7173prev_literal: ?u8 = null,
7274
73pub fn reader(c: *Compress, buffer: []u8) std.io.Reader {
74 return .{
75 .context = c,
76 .vtable = .{ .read = read },
77 .buffer = buffer,
78 };
79}
80
8175pub const Options = struct {
8276 level: Level = .default,
8377 container: Container = .raw,
......@@ -125,13 +119,17 @@ const LevelArgs = struct {
125119 }
126120};
127121
128pub fn init(input: *std.io.Reader, options: Options) Compress {
122pub fn init(input: *std.io.Reader, buffer: []u8, options: Options) Compress {
129123 return .{
130124 .input = input,
131125 .block_writer = undefined,
132126 .level = .get(options.level),
133127 .hasher = .init(options.container),
134128 .state = .header,
129 .reader = .{
130 .buffer = buffer,
131 .stream = stream,
132 },
135133 };
136134}
137135
......@@ -758,16 +756,12 @@ fn byFreq(context: void, a: LiteralNode, b: LiteralNode) bool {
758756 return a.freq < b.freq;
759757}
760758
761fn read(
762 context: ?*anyopaque,
763 bw: *Writer,
764 limit: std.io.Limit,
765) std.io.Reader.StreamError!usize {
766 const c: *Compress = @ptrCast(@alignCast(context));
759fn stream(r: *Reader, w: *Writer, limit: std.io.Limit) Reader.StreamError!usize {
760 const c: *Compress = @fieldParentPtr("reader", r);
767761 switch (c.state) {
768762 .header => |i| {
769763 const header = c.hasher.container().header();
770 const n = try bw.write(header[i..]);
764 const n = try w.write(header[i..]);
771765 if (header.len - i - n == 0) {
772766 c.state = .middle;
773767 } else {
......@@ -788,18 +782,18 @@ fn read(
788782 const history_plus_lookahead_len = flate.history_len + min_lookahead;
789783 if (buffer_contents.len < history_plus_lookahead_len) return 0;
790784 const lookahead = buffer_contents[flate.history_len..];
791 const start = bw.count;
792 const n = try c.tokenizeSlice(bw, limit, lookahead) catch |err| switch (err) {
785 const start = w.count;
786 const n = try c.tokenizeSlice(w, limit, lookahead) catch |err| switch (err) {
793787 error.WriteFailed => return error.WriteFailed,
794788 };
795789 c.hasher.update(lookahead[0..n]);
796790 c.input.toss(n);
797 return bw.count - start;
791 return w.count - start;
798792 },
799793 .final => {
800794 const buffer_contents = c.input.buffered();
801 const start = bw.count;
802 const n = c.tokenizeSlice(bw, limit, buffer_contents) catch |err| switch (err) {
795 const start = w.count;
796 const n = c.tokenizeSlice(w, limit, buffer_contents) catch |err| switch (err) {
803797 error.WriteFailed => return error.WriteFailed,
804798 };
805799 if (buffer_contents.len - n == 0) {
......@@ -840,12 +834,12 @@ fn read(
840834 },
841835 }
842836 }
843 return bw.count - start;
837 return w.count - start;
844838 },
845839 .ended => return error.EndOfStream,
846840 .footer => |i| {
847841 const remaining = c.footer_buffer[i..];
848 const n = try bw.write(limit.slice(remaining));
842 const n = try w.write(limit.slice(remaining));
849843 c.state = if (n == remaining) .ended else .{ .footer = i - n };
850844 return n;
851845 },
lib/std/compress/flate/Decompress.zig+6-6
......@@ -708,7 +708,7 @@ test "decompress" {
708708
709709 var decompress: Decompress = .init(&fb, .raw);
710710 var decompress_br = decompress.readable(&.{});
711 _ = try decompress_br.readRemaining(&aw.interface);
711 _ = try decompress_br.streamRemaining(&aw.interface);
712712 try testing.expectEqualStrings(c.out, aw.getWritten());
713713 }
714714}
......@@ -767,7 +767,7 @@ test "gzip decompress" {
767767
768768 var decompress: Decompress = .init(&fb, .gzip);
769769 var decompress_br = decompress.readable(&.{});
770 _ = try decompress_br.readRemaining(&aw.interface);
770 _ = try decompress_br.streamRemaining(&aw.interface);
771771 try testing.expectEqualStrings(c.out, aw.getWritten());
772772 }
773773}
......@@ -795,7 +795,7 @@ test "zlib decompress" {
795795
796796 var decompress: Decompress = .init(&fb, .zlib);
797797 var decompress_br = decompress.readable(&.{});
798 _ = try decompress_br.readRemaining(&aw.interface);
798 _ = try decompress_br.streamRemaining(&aw.interface);
799799 try testing.expectEqualStrings(c.out, aw.getWritten());
800800 }
801801}
......@@ -857,10 +857,10 @@ test "fuzzing tests" {
857857 var decompress: Decompress = .init(&in, .raw);
858858 var decompress_br = decompress.readable(&.{});
859859 if (c.err) |expected_err| {
860 try testing.expectError(error.ReadFailed, decompress_br.readRemaining(&aw.interface));
860 try testing.expectError(error.ReadFailed, decompress_br.streamRemaining(&aw.interface));
861861 try testing.expectError(expected_err, decompress.read_err.?);
862862 } else {
863 _ = try decompress_br.readRemaining(&aw.interface);
863 _ = try decompress_br.streamRemaining(&aw.interface);
864864 try testing.expectEqualStrings(c.out, aw.getWritten());
865865 }
866866 }
......@@ -876,7 +876,7 @@ test "bug 18966" {
876876
877877 var decompress: Decompress = .init(&in, .gzip);
878878 var decompress_br = decompress.readable(&.{});
879 _ = try decompress_br.readRemaining(&aw.interface);
879 _ = try decompress_br.streamRemaining(&aw.interface);
880880 try testing.expectEqualStrings(expect, aw.getWritten());
881881}
882882
lib/std/fs/Dir.zig+3-3
......@@ -2030,14 +2030,14 @@ pub fn readFileIntoArrayList(
20302030 var file = try dir.openFile(file_path, .{});
20312031 defer file.close();
20322032
2033 var file_reader = file.reader();
2033 var file_reader = file.reader(&.{});
20342034
20352035 // Apply size hint by adjusting the array list's capacity.
20362036 if (size_hint) |size| {
20372037 try list.ensureUnusedCapacity(gpa, size);
20382038 file_reader.size = size;
20392039 } else if (file_reader.getSize()) |size| {
2040 // If the file size doesn't fit a usize it'll be certainly exceed the limit.
2040 // If the file size doesn't fit a usize it will certainly exceed the limit.
20412041 try list.ensureUnusedCapacity(gpa, std.math.cast(usize, size) orelse return error.StreamTooLong);
20422042 } else |err| switch (err) {
20432043 // Ignore most errors; size hint is only an optimization.
......@@ -2045,7 +2045,7 @@ pub fn readFileIntoArrayList(
20452045 else => |e| return e,
20462046 }
20472047
2048 file_reader.interface().readRemainingArrayList(gpa, alignment, list, limit, 128) catch |err| switch (err) {
2048 file_reader.interface.appendRemaining(gpa, alignment, list, limit) catch |err| switch (err) {
20492049 error.OutOfMemory => return error.OutOfMemory,
20502050 error.StreamTooLong => return error.StreamTooLong,
20512051 error.ReadFailed => return file_reader.err.?,
lib/std/io/Reader.zig+6-9
......@@ -170,6 +170,12 @@ pub fn defaultDiscard(r: *Reader, limit: Limit) Error!usize {
170170 return n;
171171}
172172
173/// "Pump" exactly `n` bytes from the reader to the writer.
174pub fn streamExact(r: *Reader, w: *Writer, n: usize) StreamError!void {
175 var remaining = n;
176 while (remaining != 0) remaining -= try r.stream(w, .limited(remaining));
177}
178
173179/// "Pump" data from the reader to the writer, handling `error.EndOfStream` as
174180/// a success case.
175181///
......@@ -381,15 +387,6 @@ pub fn readVecAll(r: *Reader, data: [][]u8) Error!void {
381387 }
382388}
383389
384/// "Pump" data from the reader to the writer.
385pub fn readAll(r: *Reader, w: *Writer, limit: Limit) StreamError!void {
386 var remaining = limit;
387 while (remaining.nonzero()) {
388 const n = try r.stream(w, remaining);
389 remaining = remaining.subtract(n).?;
390 }
391}
392
393390/// Returns the next `len` bytes from the stream, filling the buffer as
394391/// necessary.
395392///
lib/std/tar.zig+2-2
......@@ -381,8 +381,8 @@ pub const Iterator = struct {
381381 return n;
382382 }
383383
384 pub fn readRemaining(file: *File, out: *std.io.Writer) std.io.Reader.StreamRemainingError!void {
385 return file.reader().readRemaining(out);
384 pub fn streamRemaining(file: *File, out: *std.io.Writer) std.io.Reader.StreamRemainingError!usize {
385 return file.reader().streamRemaining(out);
386386 }
387387 };
388388
lib/std/zip.zig+8-14
......@@ -305,8 +305,7 @@ pub const Iterator = struct {
305305 if (locator_end_offset > stream_len)
306306 return error.ZipTruncated;
307307 try input.seekTo(stream_len - locator_end_offset);
308 var br = input.interface().unbuffered();
309 const locator = br.takeStructEndian(EndLocator64, .little) catch |err| switch (err) {
308 const locator = input.interface.takeStructEndian(EndLocator64, .little) catch |err| switch (err) {
310309 error.ReadFailed => return input.err.?,
311310 error.EndOfStream => return error.EndOfStream,
312311 };
......@@ -319,7 +318,7 @@ pub const Iterator = struct {
319318
320319 try input.seekTo(locator.record_file_offset);
321320
322 const record64 = br.takeStructEndian(EndRecord64, .little) catch |err| switch (err) {
321 const record64 = input.interface.takeStructEndian(EndRecord64, .little) catch |err| switch (err) {
323322 error.ReadFailed => return input.err.?,
324323 error.EndOfStream => return error.EndOfStream,
325324 };
......@@ -375,8 +374,7 @@ pub const Iterator = struct {
375374 const header_zip_offset = self.cd_zip_offset + self.cd_record_offset;
376375 const input = self.input;
377376 try input.seekTo(header_zip_offset);
378 var br = input.interface().unbuffered();
379 const header = br.takeStructEndian(CentralDirectoryFileHeader, .little) catch |err| switch (err) {
377 const header = input.interface.takeStructEndian(CentralDirectoryFileHeader, .little) catch |err| switch (err) {
380378 error.ReadFailed => return input.err.?,
381379 error.EndOfStream => return error.EndOfStream,
382380 };
......@@ -407,7 +405,7 @@ pub const Iterator = struct {
407405 const extra = extra_buf[0..header.extra_len];
408406
409407 try input.seekTo(header_zip_offset + @sizeOf(CentralDirectoryFileHeader) + header.filename_len);
410 br.readSlice(extra) catch |err| switch (err) {
408 input.interface.readSlice(extra) catch |err| switch (err) {
411409 error.ReadFailed => return input.err.?,
412410 error.EndOfStream => return error.EndOfStream,
413411 };
......@@ -472,16 +470,13 @@ pub const Iterator = struct {
472470 const filename = filename_buf[0..self.filename_len];
473471 {
474472 try stream.seekTo(self.header_zip_offset + @sizeOf(CentralDirectoryFileHeader));
475 var stream_br = stream.readable(&.{});
476 try stream_br.readSlice(filename);
473 try stream.interface.readSlice(filename);
477474 }
478475
479476 const local_data_header_offset: u64 = local_data_header_offset: {
480477 const local_header = blk: {
481478 try stream.seekTo(self.file_offset);
482 var read_buffer: [@sizeOf(LocalFileHeader)]u8 = undefined;
483 var stream_br = stream.readable(&read_buffer);
484 break :blk try stream_br.takeStructEndian(LocalFileHeader, .little);
479 break :blk try stream.interface.takeStructEndian(LocalFileHeader, .little);
485480 };
486481 if (!std.mem.eql(u8, &local_header.signature, &local_file_header_sig))
487482 return error.ZipBadFileOffset;
......@@ -507,8 +502,7 @@ pub const Iterator = struct {
507502
508503 {
509504 try stream.seekTo(self.file_offset + @sizeOf(LocalFileHeader) + local_header.filename_len);
510 var stream_br = stream.readable(&.{});
511 try stream_br.readSlice(extra);
505 try stream.interface.readSlice(extra);
512506 }
513507
514508 var extra_offset: usize = 0;
......@@ -577,7 +571,7 @@ pub const Iterator = struct {
577571 @as(u64, @sizeOf(LocalFileHeader)) +
578572 local_data_header_offset;
579573 try stream.seekTo(local_data_file_offset);
580 var limited_file_reader = stream.interface().limited(.limited(self.compressed_size));
574 var limited_file_reader = stream.interface.limited(.limited(self.compressed_size));
581575 var file_read_buffer: [1000]u8 = undefined;
582576 var decompress_read_buffer: [1000]u8 = undefined;
583577 var limited_br = limited_file_reader.reader().buffered(&file_read_buffer);
lib/std/zip/test.zig+2-4
......@@ -63,9 +63,7 @@ fn makeZipWithStore(
6363 options: WriteZipOptions,
6464 store: []FileStore,
6565) !void {
66 var buffer: [200]u8 = undefined;
67 var bw = file_writer.writer(&buffer);
68 try writeZip(&bw, files, store, options);
66 try writeZip(&file_writer.interface, files, store, options);
6967}
7068
7169const WriteZipOptions = struct {
......@@ -201,7 +199,7 @@ const Zipper = struct {
201199 var br: std.io.Reader = .fixed(opt.content);
202200 var compress: std.compress.flate.Compress = .init(&br, .{});
203201 var compress_br = compress.reader(&.{});
204 const n = try compress_br.readRemaining(writer);
202 const n = try compress_br.streamRemaining(writer);
205203 assert(br.seek == opt.content.len);
206204 try testing.expectEqual(n, writer.count - offset);
207205 compressed_size = @intCast(n);