From bd5745ddf2f5a5d42553b30241f0a44550f1672e Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Thu, 10 Jul 2025 12:41:26 -0700 Subject: [PATCH 1/3] std.log.defaultLog: provide a small buffer --- lib/std/log.zig | 19 ++++++++----------- 1 file changed, 8 insertions(+), 11 deletions(-) diff --git a/lib/std/log.zig b/lib/std/log.zig index 20792dcb8f..ca3896e2da 100644 --- a/lib/std/log.zig +++ b/lib/std/log.zig @@ -137,8 +137,11 @@ pub fn defaultLogEnabled(comptime message_level: Level) bool { return comptime logEnabled(message_level, default_log_scope); } -/// The default implementation for the log function, custom log functions may +/// The default implementation for the log function. Custom log functions may /// forward log messages to this function. +/// +/// Uses a 64-byte buffer for formatted printing which is flushed before this +/// function returns. pub fn defaultLog( comptime message_level: Level, comptime scope: @Type(.enum_literal), @@ -147,16 +150,10 @@ pub fn defaultLog( ) void { const level_txt = comptime message_level.asText(); const prefix2 = if (scope == .default) ": " else "(" ++ @tagName(scope) ++ "): "; - const stderr = std.fs.File.stderr().deprecatedWriter(); - var bw = std.io.bufferedWriter(stderr); - const writer = bw.writer(); - - std.debug.lockStdErr(); - defer std.debug.unlockStdErr(); - nosuspend { - writer.print(level_txt ++ prefix2 ++ format ++ "\n", args) catch return; - bw.flush() catch return; - } + var buffer: [64]u8 = undefined; + const stderr = std.debug.lockStderrWriter(&buffer); + defer std.debug.unlockStderrWriter(); + nosuspend stderr.print(level_txt ++ prefix2 ++ format ++ "\n", args) catch return; } /// Returns a scoped logging namespace that logs all messages using the scope From 88e50b30c3c929761f2ae1a924b96f8bc7548b84 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Thu, 10 Jul 2025 12:58:47 -0700 Subject: [PATCH 2/3] std.debug.print: provide a small buffer --- lib/std/debug.zig | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/lib/std/debug.zig b/lib/std/debug.zig index 5da650266e..0f64b7f951 100644 --- a/lib/std/debug.zig +++ b/lib/std/debug.zig @@ -219,10 +219,14 @@ pub fn unlockStderrWriter() void { std.Progress.unlockStderrWriter(); } -/// Print to stderr, unbuffered, and silently returning on failure. Intended -/// for use in "printf debugging". Use `std.log` functions for proper logging. +/// Print to stderr, silently returning on failure. Intended for use in "printf +/// debugging". Use `std.log` functions for proper logging. +/// +/// Uses a 64-byte buffer for formatted printing which is flushed before this +/// function returns. pub fn print(comptime fmt: []const u8, args: anytype) void { - const bw = lockStderrWriter(&.{}); + var buffer: [64]u8 = undefined; + const bw = lockStderrWriter(&buffer); defer unlockStderrWriter(); nosuspend bw.print(fmt, args) catch return; } From e25541549852c8dcf4acbcc1a3f3d7ef4bcef9d7 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Thu, 10 Jul 2025 13:14:55 -0700 Subject: [PATCH 3/3] std: add some missing doc comments --- lib/std/Io/Reader.zig | 9 +++++++++ lib/std/Io/Writer.zig | 5 +++++ 2 files changed, 14 insertions(+) diff --git a/lib/std/Io/Reader.zig b/lib/std/Io/Reader.zig index c2f0b25017..518fdf2568 100644 --- a/lib/std/Io/Reader.zig +++ b/lib/std/Io/Reader.zig @@ -840,6 +840,9 @@ pub fn peekDelimiterExclusive(r: *Reader, delimiter: u8) DelimiterError![]u8 { /// Returns number of bytes streamed, which may be zero, or error.EndOfStream /// if the delimiter was not found. /// +/// Asserts buffer capacity of at least one. This function performs better with +/// larger buffers. +/// /// See also: /// * `streamDelimiterEnding` /// * `streamDelimiterLimit` @@ -858,6 +861,9 @@ pub fn streamDelimiter(r: *Reader, w: *Writer, delimiter: u8) StreamError!usize /// Returns number of bytes streamed, which may be zero. End of stream can be /// detected by checking if the next byte in the stream is the delimiter. /// +/// Asserts buffer capacity of at least one. This function performs better with +/// larger buffers. +/// /// See also: /// * `streamDelimiter` /// * `streamDelimiterLimit` @@ -884,6 +890,9 @@ pub const StreamDelimiterLimitError = error{ /// /// Returns number of bytes streamed, which may be zero. End of stream can be /// detected by checking if the next byte in the stream is the delimiter. +/// +/// Asserts buffer capacity of at least one. This function performs better with +/// larger buffers. pub fn streamDelimiterLimit( r: *Reader, w: *Writer, diff --git a/lib/std/Io/Writer.zig b/lib/std/Io/Writer.zig index d79959dcb1..73d504c437 100644 --- a/lib/std/Io/Writer.zig +++ b/lib/std/Io/Writer.zig @@ -560,6 +560,10 @@ pub fn writeAllPreserve(w: *Writer, preserve_length: usize, bytes: []const u8) E /// A user type may be a `struct`, `vector`, `union` or `enum` type. /// /// To print literal curly braces, escape them by writing them twice, e.g. `{{` or `}}`. +/// +/// Asserts `buffer` capacity of at least 2 if a union is printed. This +/// requirement could be lifted by adjusting the code, but if you trigger that +/// assertion it is a clue that you should probably be using a buffer. pub fn print(w: *Writer, comptime fmt: []const u8, args: anytype) Error!void { const ArgsType = @TypeOf(args); const args_type_info = @typeInfo(ArgsType); @@ -930,6 +934,7 @@ pub fn printAddress(w: *Writer, value: anytype) Error!void { @compileError("cannot format non-pointer type " ++ @typeName(T) ++ " with * specifier"); } +/// Asserts `buffer` capacity of at least 2 if `value` is a union. pub fn printValue( w: *Writer, comptime fmt: []const u8,