Commit 6a25bfc4751ab959f32390963d902bec731129d8 | zig

author	Andrew Kelley <andrew@ziglang.org> 2025-10-08 19:14:01-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2025-10-09 12:08:36-07:00
log	6a25bfc4751ab959f32390963d902bec731129d8
tree	8c571a4bb06990b52699e208fd55d3b62ae7a1ad
parent	52730f3f2191aa242b030b9c5f3ca33a7f4fea88

std.Io.Reader: rework peekDelimiterInclusive

Now it's based on calling fillMore rather than an illegal aliased stream
into the Reader buffer.

This commit also includes a disambiguation block inspired by #25162. If
`StreamTooLong` was added to `RebaseError` then this logic could be
replaced by removing the exit condition from the while loop. That error
code would represent when `buffer` capacity is too small for an
operation, replacing the current use of asserts.

1 files changed, 28 insertions(+), 19 deletions(-)

lib
- std
  - Io
    Reader.zig

lib/std/Io/Reader.zig+28-19

 @@ -760,28 +760,37 @@ pub fn takeDelimiterInclusive(r: *Reader, delimiter: u8) DelimiterError![]u8 {
 /// * `peekDelimiterExclusive`
 /// * `takeDelimiterInclusive`
 pub fn peekDelimiterInclusive(r: *Reader, delimiter: u8) DelimiterError![]u8 {
-    const buffer = r.buffer[0..r.end];
+    {
-    const seek = r.seek;
+        const contents = r.buffer[0..r.end];
-    if (std.mem.indexOfScalarPos(u8, buffer, seek, delimiter)) |delimiter_index| {
+        const seek = r.seek;
-        @branchHint(.likely);
+        if (std.mem.findScalarPos(u8, contents, seek, delimiter)) |end| {
-        return buffer[seek .. delimiter_index + 1];
+            @branchHint(.likely);
+            return contents[seek .. end + 1];
+        }
     }
-    // TODO take a parameter for max search length rather than relying on buffer capacity
+    while (true) {
-    try rebase(r, r.buffer.len);
+        const content_len = r.end - r.seek;
-    while (r.buffer.len - r.end != 0) {
+        if (r.buffer.len - content_len == 0) break;
-        const existing_buffered_len = r.end - r.seek;
+        try fillMore(r);
-        const end_cap = r.buffer[r.end..];
+        const seek = r.seek;
-        var writer: Writer = .fixed(end_cap);
+        const contents = r.buffer[0..r.end];
-        const n = r.vtable.stream(r, &writer, .limited(end_cap.len)) catch |err| switch (err) {
+        if (std.mem.findScalarPos(u8, contents, seek + content_len, delimiter)) |end| {
-            error.WriteFailed => unreachable,
+            return contents[seek .. end + 1];
-            else => |e| return e,
-        };
-        r.end += n;
-        if (std.mem.indexOfScalarPos(u8, r.buffer[0..r.end], r.seek + existing_buffered_len, delimiter)) |delimiter_index| {
-            return r.buffer[r.seek .. delimiter_index + 1];
         }
     }
-    return error.StreamTooLong;
+    // It might or might not be end of stream. There is no more buffer space
+    // left to disambiguate. If `StreamTooLong` was added to `RebaseError` then
+    // this logic could be replaced by removing the exit condition from the
+    // above while loop. That error code would represent when `buffer` capacity
+    // is too small for an operation, replacing the current use of asserts.
+    var failing_writer = Writer.failing;
+    while (r.vtable.stream(r, &failing_writer, .limited(1))) |n| {
+        assert(n == 0);
+    } else |err| switch (err) {
+        error.WriteFailed => return error.StreamTooLong,
+        error.ReadFailed => |e| return e,
+        error.EndOfStream => |e| return e,
+    }
 }
 /// Returns a slice of the next bytes of buffered data from the stream until