mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2026-02-19 07:48:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

std.io.Reader.bufferContents -> buffered

Browse Source
This commit is contained in:
Andrew Kelley 2025-06-24 10:37:59 -07:00
parent 9d18e31fee
commit 743326f8e9
10 changed files with 30 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/compiler/std-docs.zig
View File

@ -342,7 +342,7 @@ fn buildWasmBinary(
}
if (poller.reader(.stderr).buffer.len > 0) {
std.debug.print("{s}", .{poller.reader(.stderr).bufferContents()});
std.debug.print("{s}", .{poller.reader(.stderr).buffered()});
}
// Send EOF to stdin.

6
lib/std/Build/Fuzz/WebServer.zig
View File

@ -285,9 +285,9 @@ fn buildWasmBinary(
const stdout_br = poller.reader(.stdout);
poll: while (true) {
const Header = std.zig.Server.Message.Header;
while (stdout_br.bufferContents().len < @sizeOf(Header)) if (!try poller.poll()) break :poll;
while (stdout_br.buffered().len < @sizeOf(Header)) if (!try poller.poll()) break :poll;
const header = (stdout_br.takeStruct(Header) catch unreachable).*;
while (stdout_br.bufferContents().len < header.bytes_len) if (!try poller.poll()) break :poll;
while (stdout_br.buffered().len < header.bytes_len) if (!try poller.poll()) break :poll;
const body = stdout_br.take(header.bytes_len) catch unreachable;
switch (header.tag) {
.zig_version => {
@ -328,7 +328,7 @@ fn buildWasmBinary(
}
const stderr_br = poller.reader(.stderr);
const stderr_contents = stderr_br.bufferContents();
const stderr_contents = stderr_br.buffered();
if (stderr_contents.len > 0) {
std.debug.print("{s}", .{stderr_contents});
}

6
lib/std/Build/Step.zig
View File

@ -516,9 +516,9 @@ fn zigProcessUpdate(s: *Step, zp: *ZigProcess, watch: bool) !?Path {
const stdout_br = zp.poller.reader(.stdout);
poll: while (true) {
const Header = std.zig.Server.Message.Header;
while (stdout_br.bufferContents().len < @sizeOf(Header)) if (!try zp.poller.poll()) break :poll;
while (stdout_br.buffered().len < @sizeOf(Header)) if (!try zp.poller.poll()) break :poll;
const header = (stdout_br.takeStruct(Header) catch unreachable).*;
while (stdout_br.bufferContents().len < header.bytes_len) if (!try zp.poller.poll()) break :poll;
while (stdout_br.buffered().len < header.bytes_len) if (!try zp.poller.poll()) break :poll;
const body = stdout_br.take(header.bytes_len) catch unreachable;
switch (header.tag) {
.zig_version => {
@ -610,7 +610,7 @@ fn zigProcessUpdate(s: *Step, zp: *ZigProcess, watch: bool) !?Path {
s.result_duration_ns = timer.read();
const stderr_br = zp.poller.reader(.stderr);
const stderr_contents = stderr_br.bufferContents();
const stderr_contents = stderr_br.buffered();
if (stderr_contents.len > 0) {
try s.result_error_msgs.append(arena, try arena.dupe(u8, stderr_contents));
}

2
lib/std/Build/Step/CheckObject.zig
View File

@ -1785,7 +1785,7 @@ const ElfDumper = struct {
.p64 => @sizeOf(u64),
};
_ = try br.discard(.limited(num * ptr_size));
const strtab = br.bufferContents();
const strtab = br.buffered();
assert(ctx.symtab.len == 0);
ctx.symtab = try ctx.gpa.alloc(ArSymtabEntry, num);

16
lib/std/Build/Step/Run.zig
View File

@ -1529,9 +1529,9 @@ fn evalZigTest(
const stderr_br = poller.reader(.stderr);
const any_write_failed = first_write_failed or poll: while (true) {
const Header = std.zig.Server.Message.Header;
while (stdout_br.bufferContents().len < @sizeOf(Header)) if (!try poller.poll()) break :poll false;
while (stdout_br.buffered().len < @sizeOf(Header)) if (!try poller.poll()) break :poll false;
const header = (stdout_br.takeStruct(Header) catch unreachable).*;
while (stdout_br.bufferContents().len < header.bytes_len) if (!try poller.poll()) break :poll false;
while (stdout_br.buffered().len < header.bytes_len) if (!try poller.poll()) break :poll false;
const body = stdout_br.take(header.bytes_len) catch unreachable;
switch (header.tag) {
.zig_version => {
@ -1589,7 +1589,7 @@ fn evalZigTest(
if (tr_hdr.flags.fail or tr_hdr.flags.leak or tr_hdr.flags.log_err_count > 0) {
const name = std.mem.sliceTo(md.string_bytes[md.names[tr_hdr.index]..], 0);
const stderr_contents = stderr_br.bufferContents();
const stderr_contents = stderr_br.buffered();
stderr_br.toss(stderr_contents.len);
const msg = std.mem.trim(u8, stderr_contents, "\n");
const label = if (tr_hdr.flags.fail)
@ -1650,7 +1650,7 @@ fn evalZigTest(
while (try poller.poll()) {}
}
const stderr_contents = std.mem.trim(u8, stderr_br.bufferContents(), "\n");
const stderr_contents = std.mem.trim(u8, stderr_br.buffered(), "\n");
if (stderr_contents.len > 0) {
run.step.result_stderr = try arena.dupe(u8, stderr_contents);
}
@ -1777,15 +1777,15 @@ fn evalGeneric(run: *Run, child: *std.process.Child) !StdIoResult {
while (try poller.poll()) {
if (run.stdio_limit.toInt()) |limit| {
if (poller.reader(.stderr).bufferContents().len > limit)
if (poller.reader(.stderr).buffered().len > limit)
return error.StdoutStreamTooLong;
if (poller.reader(.stderr).bufferContents().len > limit)
if (poller.reader(.stderr).buffered().len > limit)
return error.StderrStreamTooLong;
}
}
stdout_bytes = poller.reader(.stdout).bufferContents();
stderr_bytes = poller.reader(.stderr).bufferContents();
stdout_bytes = poller.reader(.stdout).buffered();
stderr_bytes = poller.reader(.stderr).buffered();
} else {
var fr = stdout.readerStreaming();
stdout_bytes = fr.interface().readRemainingAlloc(arena, run.stdio_limit) catch |err| switch (err) {

4
lib/std/compress/flate/Compress.zig
View File

@ -783,7 +783,7 @@ fn read(
},
else => |e| return e,
};
const buffer_contents = c.input.bufferContents();
const buffer_contents = c.input.buffered();
const min_lookahead = flate.match.min_length + flate.match.max_length;
const history_plus_lookahead_len = flate.history_len + min_lookahead;
if (buffer_contents.len < history_plus_lookahead_len) return 0;
@ -797,7 +797,7 @@ fn read(
return bw.count - start;
},
.final => {
const buffer_contents = c.input.bufferContents();
const buffer_contents = c.input.buffered();
const start = bw.count;
const n = c.tokenizeSlice(bw, limit, buffer_contents) catch |err| switch (err) {
error.WriteFailed => return error.WriteFailed,

4
lib/std/crypto/tls/Client.zig
View File

@ -1068,12 +1068,12 @@ fn read(context: ?*anyopaque, bw: *Writer, limit: std.io.Limit) Reader.StreamErr
const record_len = mem.readInt(u16, record_header[3..][0..2], .big);
if (record_len > max_ciphertext_len) return failRead(c, error.TlsRecordOverflow);
const record_end = 5 + record_len;
if (record_end > input.bufferContents().len) {
if (record_end > input.buffered().len) {
input.fillMore() catch |err| switch (err) {
error.EndOfStream => return failRead(c, error.TlsConnectionTruncated),
error.ReadFailed => return error.ReadFailed,
};
if (record_end > input.bufferContents().len) return 0;
if (record_end > input.buffered().len) return 0;
}
var cleartext_stack_buffer: [max_ciphertext_len]u8 = undefined;

10
lib/std/http.zig
View File

@ -418,7 +418,7 @@ pub const Reader = struct {
},
error.ReadFailed => return error.ReadFailed,
};
head_end += hp.feed(in.bufferContents()[head_end..]);
head_end += hp.feed(in.buffered()[head_end..]);
if (hp.state == .finished) {
reader.head_buffer = in.steal(head_end);
reader.state = .received_head;
@ -577,7 +577,7 @@ pub const Reader = struct {
.head => {
var cp: ChunkParser = .init;
while (true) {
const i = cp.feed(in.bufferContents());
const i = cp.feed(in.buffered());
switch (cp.state) {
.invalid => return error.HttpChunkInvalid,
.data => {
@ -645,7 +645,7 @@ pub const Reader = struct {
.head => {
var cp: ChunkParser = .init;
while (true) {
const i = cp.feed(in.bufferContents());
const i = cp.feed(in.buffered());
switch (cp.state) {
.invalid => return error.HttpChunkInvalid,
.data => {
@ -699,10 +699,10 @@ pub const Reader = struct {
while (true) {
if (trailers_len >= in.buffer.len) return error.HttpHeadersOversize;
try in.fill(trailers_len + 1);
trailers_len += hp.feed(in.bufferContents()[trailers_len..]);
trailers_len += hp.feed(in.buffered()[trailers_len..]);
if (hp.state == .finished) {
reader.state = .ready;
reader.trailers = in.bufferContents()[0..trailers_len];
reader.trailers = in.buffered()[0..trailers_len];
in.toss(trailers_len);
return amt_read;
}

8
lib/std/process/Child.zig
View File

@ -352,11 +352,11 @@ fn writeBufferedReaderToArrayList(allocator: Allocator, list: *std.ArrayListUnma
assert(r.seek == 0);
if (list.capacity == 0) {
list.* = .{
.items = r.bufferContents(),
.items = r.buffered(),
.capacity = r.buffer.len,
};
} else {
try list.appendSlice(allocator, r.bufferContents());
try list.appendSlice(allocator, r.buffered());
}
}
@ -383,9 +383,9 @@ pub fn collectOutput(
defer poller.deinit();
while (try poller.poll()) {
if (poller.reader(.stdout).bufferContents().len > max_output_bytes)
if (poller.reader(.stdout).buffered().len > max_output_bytes)
return error.StdoutStreamTooLong;
if (poller.reader(.stderr).bufferContents().len > max_output_bytes)
if (poller.reader(.stderr).buffered().len > max_output_bytes)
return error.StderrStreamTooLong;
}

2
src/Package/Fetch/git.zig
View File

@ -1347,7 +1347,7 @@ fn indexPackFirstPass(
const pack_header = try PackHeader.read(&pack_hashed.interface);
for (0..pack_header.total_objects) |_| {
const entry_offset = pack.pos - pack_hashed.interface.bufferContents().len;
const entry_offset = pack.pos - pack_hashed.interface.buffered().len;
var entry_buffer: [64]u8 = undefined; // Buffer only needed for loading EntryHeader.
var entry_crc32_reader = pack_hashed.interface.hashed(std.hash.Crc32.init(), &entry_buffer);
const entry_crc32_br = &entry_crc32_reader.interface;