authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-06-03 22:42:53-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-07-01 16:35:29-07:00
logb393112674d0b948832c3223d5b300f080c71151
tree97392fff3cc17dc563f4a9cf54f5f1326e7b8d07
parent9d163c7ac3fbc6adfa7c6fa299647d0731f96167

std: update uses of unbuffered_writer

6 files changed, 39 insertions(+), 90 deletions(-)

lib/std/Progress.zig+7-9
......@@ -608,12 +608,10 @@ pub fn unlockStdErr() void {
608608}
609609
610610/// Protected by `stderr_mutex`.
611var stderr_buffered_writer: Writer = .{
612 .unbuffered_writer = stderr_file_writer.interface(),
613 .buffer = &.{},
614};
611const stderr_writer: *Writer = &stderr_file_writer.interface;
615612/// Protected by `stderr_mutex`.
616613var stderr_file_writer: std.fs.File.Writer = .{
614 .interface = std.fs.File.Writer.init_interface(&.{}),
617615 .file = if (is_windows) undefined else .stderr(),
618616 .mode = .streaming,
619617};
......@@ -628,14 +626,14 @@ pub fn lockStderrWriter(buffer: []u8) *Writer {
628626 stderr_mutex.lock();
629627 clearWrittenWithEscapeCodes() catch {};
630628 if (is_windows) stderr_file_writer.file = .stderr();
631 stderr_buffered_writer.flush() catch {};
632 stderr_buffered_writer.buffer = buffer;
633 return &stderr_buffered_writer;
629 stderr_writer.flush() catch {};
630 stderr_writer.buffer = buffer;
631 return &stderr_writer;
634632}
635633
636634pub fn unlockStderrWriter() void {
637 stderr_buffered_writer.flush() catch {};
638 stderr_buffered_writer.buffer = &.{};
635 stderr_writer.flush() catch {};
636 stderr_writer.buffer = &.{};
639637 stderr_mutex.unlock();
640638}
641639
lib/std/crypto/phc_encoding.zig+3-6
......@@ -197,12 +197,9 @@ pub fn serialize(params: anytype, str: []u8) Error![]const u8 {
197197/// Compute the number of bytes required to serialize `params`
198198pub fn calcSize(params: anytype) usize {
199199 var trash: [128]u8 = undefined;
200 var bw: Writer = .{
201 .unbuffered_writer = .discarding,
202 .buffer = &trash,
203 };
204 serializeTo(params, &bw) catch unreachable;
205 return bw.count;
200 var w: Writer = .discarding(&trash);
201 serializeTo(params, &w) catch unreachable;
202 return w.count;
206203}
207204
208205fn serializeTo(params: anytype, out: *Writer) !void {
lib/std/crypto/sha2.zig+7-10
......@@ -383,22 +383,19 @@ fn Sha2x32(comptime iv: Iv32, digest_bits: comptime_int) type {
383383 for (&d.s, v) |*dv, vv| dv.* +%= vv;
384384 }
385385
386 pub fn writable(this: *@This(), buffer: []u8) Writer {
386 pub fn writer(this: *@This(), buffer: []u8) Writer {
387387 return .{
388 .unbuffered_writer = .{
389 .context = this,
390 .vtable = &.{
391 .writeSplat = writeSplat,
392 .writeFile = Writer.unimplementedWriteFile,
393 },
394 },
388 .context = this,
389 .vtable = &.{ .drain = drain },
395390 .buffer = buffer,
396391 };
397392 }
398393
399 fn writeSplat(context: ?*anyopaque, data: []const []const u8, splat: usize) Writer.Error!usize {
400 const this: *@This() = @ptrCast(@alignCast(context));
394 fn drain(w: *Writer, data: []const []const u8, splat: usize) Writer.Error!usize {
395 const this: *@This() = @ptrCast(@alignCast(w.context));
401396 const start_total = this.total_len;
397 this.update(w.buffered());
398 w.end = 0;
402399 for (data[0 .. data.len - 1]) |slice| this.update(slice);
403400 for (0..splat) |_| this.update(data[data.len - 1]);
404401 return @intCast(this.total_len - start_total);
lib/std/fmt.zig+3-6
......@@ -845,14 +845,11 @@ pub fn bufPrintZ(buf: []u8, comptime fmt: []const u8, args: anytype) BufPrintErr
845845/// Count the characters needed for format.
846846pub fn count(comptime fmt: []const u8, args: anytype) usize {
847847 var trash_buffer: [64]u8 = undefined;
848 var bw: Writer = .{
849 .unbuffered_writer = .discarding,
850 .buffer = &trash_buffer,
851 };
852 bw.print(fmt, args) catch |err| switch (err) {
848 var w: Writer = .discarding(&trash_buffer);
849 w.print(fmt, args) catch |err| switch (err) {
853850 error.WriteFailed => unreachable,
854851 };
855 return bw.count;
852 return w.count;
856853}
857854
858855pub fn allocPrint(gpa: Allocator, comptime fmt: []const u8, args: anytype) Allocator.Error![]u8 {
lib/std/io/Writer.zig+17-54
......@@ -155,11 +155,7 @@ pub fn writeSplat(w: *Writer, data: []const []const u8, splat: usize) Error!usiz
155155 assert(data.len > 0);
156156 const buffer = w.buffer;
157157 const count = countSplat(0, data, splat);
158 if (w.end + count > buffer.len) {
159 const end = w.end;
160 const n = try w.vtable.drain(w, data, splat);
161 return n -| end;
162 }
158 if (w.end + count > buffer.len) return w.vtable.drain(w, data, splat);
163159 w.count += count;
164160 for (data) |bytes| {
165161 @memcpy(buffer[w.end..][0..bytes.len], bytes);
......@@ -168,7 +164,6 @@ pub fn writeSplat(w: *Writer, data: []const []const u8, splat: usize) Error!usiz
168164 const pattern = data[data.len - 1];
169165 if (splat == 0) {
170166 @branchHint(.unlikely);
171 // It was added in the loop above; undo it here.
172167 w.end -= pattern.len;
173168 return count;
174169 }
......@@ -245,24 +240,14 @@ pub fn writableSlice(w: *Writer, len: usize) Error![]u8 {
245240/// If `minimum_length` is zero, this is equivalent to `unusedCapacitySlice`.
246241pub fn writableSliceGreedy(w: *Writer, minimum_length: usize) Error![]u8 {
247242 assert(w.buffer.len >= minimum_length);
248 const cap_slice = w.buffer[w.end..];
249 if (cap_slice.len >= minimum_length) {
250 @branchHint(.likely);
251 return cap_slice;
252 }
253 const buffer = w.buffer[0..w.end];
254 const n = try w.unbuffered_writer.writeVec(&.{buffer});
255 if (n == buffer.len) {
256 @branchHint(.likely);
257 w.end = 0;
258 return w.buffer;
259 }
260 if (n > 0) {
261 const remainder = buffer[n..];
262 std.mem.copyForwards(u8, buffer[0..remainder.len], remainder);
263 w.end = remainder.len;
243 while (true) {
244 const cap_slice = w.buffer[w.end..];
245 if (cap_slice.len >= minimum_length) {
246 @branchHint(.likely);
247 return cap_slice;
248 }
249 assert(0 == try w.vtable.drain(w, &.{""}, 1));
264250 }
265 return w.buffer[w.end..];
266251}
267252
268253pub fn ensureUnusedCapacity(w: *Writer, n: usize) Error!void {
......@@ -358,39 +343,17 @@ pub fn print(w: *Writer, comptime format: []const u8, args: anytype) Error!void
358343}
359344
360345pub fn writeByte(w: *Writer, byte: u8) Error!void {
361 const buffer = w.buffer[0..w.end];
362 if (buffer.len < w.buffer.len) {
363 @branchHint(.likely);
364 buffer.ptr[buffer.len] = byte;
365 w.end = buffer.len + 1;
366 w.count += 1;
367 return;
368 }
369 var buffers: [2][]const u8 = .{ buffer, &.{byte} };
370 while (true) {
371 const n = try w.unbuffered_writer.writeVec(&buffers);
372 if (n == 0) {
373 @branchHint(.unlikely);
374 continue;
346 while (w.buffer.len - w.end == 0) {
347 const n = try w.vtable.drain(w, &.{&.{byte}}, 1);
348 if (n > 0) {
349 w.count += 1;
350 return;
375351 }
352 } else {
353 @branchHint(.likely);
354 w.buffer[w.end] = byte;
355 w.end += 1;
376356 w.count += 1;
377 if (n >= buffer.len) {
378 @branchHint(.likely);
379 if (n > buffer.len) {
380 @branchHint(.likely);
381 w.end = 0;
382 return;
383 } else {
384 buffer[0] = byte;
385 w.end = 1;
386 return;
387 }
388 }
389 const remainder = buffer[n..];
390 std.mem.copyForwards(u8, buffer[0..remainder.len], remainder);
391 buffer[remainder.len] = byte;
392 w.end = remainder.len + 1;
393 return;
394357 }
395358}
396359
lib/std/zon/stringify.zig+2-5
......@@ -1040,11 +1040,8 @@ pub const Serializer = struct {
10401040};
10411041
10421042test Serializer {
1043 var bw: Writer = .{
1044 .unbuffered_writer = .discarding,
1045 .buffer = &.{},
1046 };
1047 var s: Serializer = .{ .writer = &bw };
1043 var w: Writer = .discarding(&.{});
1044 var s: Serializer = .{ .writer = &w };
10481045 var vec2 = try s.beginStruct(.{});
10491046 try vec2.field("x", 1.5, .{});
10501047 try vec2.fieldPrefix("prefix");