authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-08-01 00:22:03-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-08-06 22:42:42-07:00
log499bf2a1c77f21fc8724c9999fa233f283f3dc77
treec53cce032b9bfccbf714f6ae69c8320d6a32b3ed
parent8b571723fa1487099cd0e676062dfd703ef6847f

std.Io: delete BufferedReader

6 files changed, 13 insertions(+), 232 deletions(-)

lib/compiler/resinator/errors.zig+2-6
...@@ -1078,11 +1078,9 @@ const CorrespondingLines = struct {...@@ -1078,11 +1078,9 @@ const CorrespondingLines = struct {
1078 at_eof: bool = false,1078 at_eof: bool = false,
1079 span: SourceMappings.CorrespondingSpan,1079 span: SourceMappings.CorrespondingSpan,
1080 file: std.fs.File,1080 file: std.fs.File,
1081 buffered_reader: BufferedReaderType,1081 buffered_reader: *std.Io.Reader,
1082 code_page: SupportedCodePage,1082 code_page: SupportedCodePage,
10831083
1084 const BufferedReaderType = std.io.BufferedReader(512, std.fs.File.DeprecatedReader);
1085
1086 pub fn init(cwd: std.fs.Dir, err_details: ErrorDetails, line_for_comparison: []const u8, corresponding_span: SourceMappings.CorrespondingSpan, corresponding_file: []const u8) !CorrespondingLines {1084 pub fn init(cwd: std.fs.Dir, err_details: ErrorDetails, line_for_comparison: []const u8, corresponding_span: SourceMappings.CorrespondingSpan, corresponding_file: []const u8) !CorrespondingLines {
1087 // We don't do line comparison for this error, so don't print the note if the line1085 // We don't do line comparison for this error, so don't print the note if the line
1088 // number is different1086 // number is different
...@@ -1101,9 +1099,7 @@ const CorrespondingLines = struct {...@@ -1101,9 +1099,7 @@ const CorrespondingLines = struct {
1101 .buffered_reader = undefined,1099 .buffered_reader = undefined,
1102 .code_page = err_details.code_page,1100 .code_page = err_details.code_page,
1103 };1101 };
1104 corresponding_lines.buffered_reader = BufferedReaderType{1102 corresponding_lines.buffered_reader = corresponding_lines.file.reader();
1105 .unbuffered_reader = corresponding_lines.file.deprecatedReader(),
1106 };
1107 errdefer corresponding_lines.deinit();1103 errdefer corresponding_lines.deinit();
11081104
1109 var fbs = std.io.fixedBufferStream(&corresponding_lines.line_buf);1105 var fbs = std.io.fixedBufferStream(&corresponding_lines.line_buf);
lib/docs/wasm/markdown.zig+6-7
...@@ -145,13 +145,12 @@ fn mainImpl() !void {...@@ -145,13 +145,12 @@ fn mainImpl() !void {
145 var parser = try Parser.init(gpa);145 var parser = try Parser.init(gpa);
146 defer parser.deinit();146 defer parser.deinit();
147147
148 var stdin_buf = std.io.bufferedReader(std.fs.File.stdin().deprecatedReader());148 var stdin_buffer: [1024]u8 = undefined;
149 var line_buf = std.ArrayList(u8).init(gpa);149 var stdin_reader = std.fs.File.stdin().reader(&stdin_buffer);
150 defer line_buf.deinit();150
151 while (stdin_buf.reader().streamUntilDelimiter(line_buf.writer(), '\n', null)) {151 while (stdin_reader.takeDelimiterExclusive('\n')) |line| {
152 if (line_buf.getLastOrNull() == '\r') _ = line_buf.pop();152 const trimmed = std.mem.trimRight(u8, line, '\r');
153 try parser.feedLine(line_buf.items);153 try parser.feedLine(trimmed);
154 line_buf.clearRetainingCapacity();
155 } else |err| switch (err) {154 } else |err| switch (err) {
156 error.EndOfStream => {},155 error.EndOfStream => {},
157 else => |e| return e,156 else => |e| return e,
lib/std/Io.zig-7
...@@ -428,12 +428,6 @@ pub const BufferedWriter = @import("Io/buffered_writer.zig").BufferedWriter;...@@ -428,12 +428,6 @@ pub const BufferedWriter = @import("Io/buffered_writer.zig").BufferedWriter;
428/// Deprecated in favor of `Writer`.428/// Deprecated in favor of `Writer`.
429pub const bufferedWriter = @import("Io/buffered_writer.zig").bufferedWriter;429pub const bufferedWriter = @import("Io/buffered_writer.zig").bufferedWriter;
430/// Deprecated in favor of `Reader`.430/// Deprecated in favor of `Reader`.
431pub const BufferedReader = @import("Io/buffered_reader.zig").BufferedReader;
432/// Deprecated in favor of `Reader`.
433pub const bufferedReader = @import("Io/buffered_reader.zig").bufferedReader;
434/// Deprecated in favor of `Reader`.
435pub const bufferedReaderSize = @import("Io/buffered_reader.zig").bufferedReaderSize;
436/// Deprecated in favor of `Reader`.
437pub const FixedBufferStream = @import("Io/fixed_buffer_stream.zig").FixedBufferStream;431pub const FixedBufferStream = @import("Io/fixed_buffer_stream.zig").FixedBufferStream;
438/// Deprecated in favor of `Reader`.432/// Deprecated in favor of `Reader`.
439pub const fixedBufferStream = @import("Io/fixed_buffer_stream.zig").fixedBufferStream;433pub const fixedBufferStream = @import("Io/fixed_buffer_stream.zig").fixedBufferStream;
...@@ -926,7 +920,6 @@ pub fn PollFiles(comptime StreamEnum: type) type {...@@ -926,7 +920,6 @@ pub fn PollFiles(comptime StreamEnum: type) type {
926test {920test {
927 _ = Reader;921 _ = Reader;
928 _ = Writer;922 _ = Writer;
929 _ = BufferedReader;
930 _ = BufferedWriter;923 _ = BufferedWriter;
931 _ = CountingWriter;924 _ = CountingWriter;
932 _ = CountingReader;925 _ = CountingReader;
lib/std/Io/buffered_reader.zig deleted-201
...@@ -1,201 +0,0 @@
1const std = @import("../std.zig");
2const io = std.io;
3const mem = std.mem;
4const assert = std.debug.assert;
5const testing = std.testing;
6
7pub fn BufferedReader(comptime buffer_size: usize, comptime ReaderType: type) type {
8 return struct {
9 unbuffered_reader: ReaderType,
10 buf: [buffer_size]u8 = undefined,
11 start: usize = 0,
12 end: usize = 0,
13
14 pub const Error = ReaderType.Error;
15 pub const Reader = io.GenericReader(*Self, Error, read);
16
17 const Self = @This();
18
19 pub fn read(self: *Self, dest: []u8) Error!usize {
20 // First try reading from the already buffered data onto the destination.
21 const current = self.buf[self.start..self.end];
22 if (current.len != 0) {
23 const to_transfer = @min(current.len, dest.len);
24 @memcpy(dest[0..to_transfer], current[0..to_transfer]);
25 self.start += to_transfer;
26 return to_transfer;
27 }
28
29 // If dest is large, read from the unbuffered reader directly into the destination.
30 if (dest.len >= buffer_size) {
31 return self.unbuffered_reader.read(dest);
32 }
33
34 // If dest is small, read from the unbuffered reader into our own internal buffer,
35 // and then transfer to destination.
36 self.end = try self.unbuffered_reader.read(&self.buf);
37 const to_transfer = @min(self.end, dest.len);
38 @memcpy(dest[0..to_transfer], self.buf[0..to_transfer]);
39 self.start = to_transfer;
40 return to_transfer;
41 }
42
43 pub fn reader(self: *Self) Reader {
44 return .{ .context = self };
45 }
46 };
47}
48
49pub fn bufferedReader(reader: anytype) BufferedReader(4096, @TypeOf(reader)) {
50 return .{ .unbuffered_reader = reader };
51}
52
53pub fn bufferedReaderSize(comptime size: usize, reader: anytype) BufferedReader(size, @TypeOf(reader)) {
54 return .{ .unbuffered_reader = reader };
55}
56
57test "OneByte" {
58 const OneByteReadReader = struct {
59 str: []const u8,
60 curr: usize,
61
62 const Error = error{NoError};
63 const Self = @This();
64 const Reader = io.GenericReader(*Self, Error, read);
65
66 fn init(str: []const u8) Self {
67 return Self{
68 .str = str,
69 .curr = 0,
70 };
71 }
72
73 fn read(self: *Self, dest: []u8) Error!usize {
74 if (self.str.len <= self.curr or dest.len == 0)
75 return 0;
76
77 dest[0] = self.str[self.curr];
78 self.curr += 1;
79 return 1;
80 }
81
82 fn reader(self: *Self) Reader {
83 return .{ .context = self };
84 }
85 };
86
87 const str = "This is a test";
88 var one_byte_stream = OneByteReadReader.init(str);
89 var buf_reader = bufferedReader(one_byte_stream.reader());
90 const stream = buf_reader.reader();
91
92 const res = try stream.readAllAlloc(testing.allocator, str.len + 1);
93 defer testing.allocator.free(res);
94 try testing.expectEqualSlices(u8, str, res);
95}
96
97fn smallBufferedReader(underlying_stream: anytype) BufferedReader(8, @TypeOf(underlying_stream)) {
98 return .{ .unbuffered_reader = underlying_stream };
99}
100test "Block" {
101 const BlockReader = struct {
102 block: []const u8,
103 reads_allowed: usize,
104 curr_read: usize,
105
106 const Error = error{NoError};
107 const Self = @This();
108 const Reader = io.GenericReader(*Self, Error, read);
109
110 fn init(block: []const u8, reads_allowed: usize) Self {
111 return Self{
112 .block = block,
113 .reads_allowed = reads_allowed,
114 .curr_read = 0,
115 };
116 }
117
118 fn read(self: *Self, dest: []u8) Error!usize {
119 if (self.curr_read >= self.reads_allowed) return 0;
120 @memcpy(dest[0..self.block.len], self.block);
121
122 self.curr_read += 1;
123 return self.block.len;
124 }
125
126 fn reader(self: *Self) Reader {
127 return .{ .context = self };
128 }
129 };
130
131 const block = "0123";
132
133 // len out == block
134 {
135 var test_buf_reader: BufferedReader(4, BlockReader) = .{
136 .unbuffered_reader = BlockReader.init(block, 2),
137 };
138 const reader = test_buf_reader.reader();
139 var out_buf: [4]u8 = undefined;
140 _ = try reader.readAll(&out_buf);
141 try testing.expectEqualSlices(u8, &out_buf, block);
142 _ = try reader.readAll(&out_buf);
143 try testing.expectEqualSlices(u8, &out_buf, block);
144 try testing.expectEqual(try reader.readAll(&out_buf), 0);
145 }
146
147 // len out < block
148 {
149 var test_buf_reader: BufferedReader(4, BlockReader) = .{
150 .unbuffered_reader = BlockReader.init(block, 2),
151 };
152 const reader = test_buf_reader.reader();
153 var out_buf: [3]u8 = undefined;
154 _ = try reader.readAll(&out_buf);
155 try testing.expectEqualSlices(u8, &out_buf, "012");
156 _ = try reader.readAll(&out_buf);
157 try testing.expectEqualSlices(u8, &out_buf, "301");
158 const n = try reader.readAll(&out_buf);
159 try testing.expectEqualSlices(u8, out_buf[0..n], "23");
160 try testing.expectEqual(try reader.readAll(&out_buf), 0);
161 }
162
163 // len out > block
164 {
165 var test_buf_reader: BufferedReader(4, BlockReader) = .{
166 .unbuffered_reader = BlockReader.init(block, 2),
167 };
168 const reader = test_buf_reader.reader();
169 var out_buf: [5]u8 = undefined;
170 _ = try reader.readAll(&out_buf);
171 try testing.expectEqualSlices(u8, &out_buf, "01230");
172 const n = try reader.readAll(&out_buf);
173 try testing.expectEqualSlices(u8, out_buf[0..n], "123");
174 try testing.expectEqual(try reader.readAll(&out_buf), 0);
175 }
176
177 // len out == 0
178 {
179 var test_buf_reader: BufferedReader(4, BlockReader) = .{
180 .unbuffered_reader = BlockReader.init(block, 2),
181 };
182 const reader = test_buf_reader.reader();
183 var out_buf: [0]u8 = undefined;
184 _ = try reader.readAll(&out_buf);
185 try testing.expectEqualSlices(u8, &out_buf, "");
186 }
187
188 // len bufreader buf > block
189 {
190 var test_buf_reader: BufferedReader(5, BlockReader) = .{
191 .unbuffered_reader = BlockReader.init(block, 2),
192 };
193 const reader = test_buf_reader.reader();
194 var out_buf: [4]u8 = undefined;
195 _ = try reader.readAll(&out_buf);
196 try testing.expectEqualSlices(u8, &out_buf, block);
197 _ = try reader.readAll(&out_buf);
198 try testing.expectEqualSlices(u8, &out_buf, block);
199 try testing.expectEqual(try reader.readAll(&out_buf), 0);
200 }
201}
lib/std/Io/test.zig+3-3
...@@ -45,9 +45,9 @@ test "write a file, read it, then delete it" {...@@ -45,9 +45,9 @@ test "write a file, read it, then delete it" {
45 const expected_file_size: u64 = "begin".len + data.len + "end".len;45 const expected_file_size: u64 = "begin".len + data.len + "end".len;
46 try expectEqual(expected_file_size, file_size);46 try expectEqual(expected_file_size, file_size);
4747
48 var buf_stream = io.bufferedReader(file.deprecatedReader());48 var file_buffer: [1024]u8 = undefined;
49 const st = buf_stream.reader();49 var file_reader = file.reader(&file_buffer);
50 const contents = try st.readAllAlloc(std.testing.allocator, 2 * 1024);50 const contents = try file_reader.interface.allocRemaining(std.testing.allocator, .limited(2 * 1024));
51 defer std.testing.allocator.free(contents);51 defer std.testing.allocator.free(contents);
5252
53 try expect(mem.eql(u8, contents[0.."begin".len], "begin"));53 try expect(mem.eql(u8, contents[0.."begin".len], "begin"));
src/Package/Fetch.zig+2-8
...@@ -1194,14 +1194,8 @@ fn unpackResource(...@@ -1194,14 +1194,8 @@ fn unpackResource(
1194 },1194 },
1195 .@"tar.xz" => {1195 .@"tar.xz" => {
1196 const gpa = f.arena.child_allocator;1196 const gpa = f.arena.child_allocator;
1197 const reader = resource.reader();1197 var dcp = std.compress.xz.decompress(gpa, resource.reader().adaptToOldInterface()) catch |err|
1198 var br = std.io.bufferedReaderSize(std.crypto.tls.max_ciphertext_record_len, reader);1198 return f.fail(f.location_tok, try eb.printString("unable to decompress tarball: {t}", .{err}));
1199 var dcp = std.compress.xz.decompress(gpa, br.reader()) catch |err| {
1200 return f.fail(f.location_tok, try eb.printString(
1201 "unable to decompress tarball: {s}",
1202 .{@errorName(err)},
1203 ));
1204 };
1205 defer dcp.deinit();1199 defer dcp.deinit();
1206 var adapter_buffer: [1024]u8 = undefined;1200 var adapter_buffer: [1024]u8 = undefined;
1207 var adapter = dcp.reader().adaptToNewApi(&adapter_buffer);1201 var adapter = dcp.reader().adaptToNewApi(&adapter_buffer);