Commit af24e722fba2245d50473dc7a6fb7671851e07dc | zig

lib/std/debug.zig+1-1

...	...	@@ -588,7 +588,7 @@ pub fn panicExtra(
588	588	// a minor annoyance with this is that it will result in the NoSpaceLeft
589	589	// error being part of the @panic stack trace (but that error should
590	590	// only happen rarely)
591		const msg = if (bw.print(format, args)) \|_\| bw.getWritten() else \|_\| blk: {
	591	const msg = if (bw.print(format, args)) \|_\| bw.buffered() else \|_\| blk: {
592	592	@memcpy(buf[size..], trunc_msg);
593	593	break :blk &buf;
594	594	};

lib/std/fs/Dir.zig+2-5

...	...	@@ -2612,10 +2612,7 @@ pub fn updateFile(
2612	2612	var atomic_file = try dest_dir.atomicFile(dest_path, .{ .mode = actual_mode });
2613	2613	defer atomic_file.deinit();
2614	2614
2615		var src_reader: File.Reader = .{
2616		.file = src_file,
2617		.size = src_stat.size,
2618		};
	2615	var src_reader: File.Reader = .initSize(src_file, &.{}, src_stat.size);
2619	2616	var buffer: [2000]u8 = undefined;
2620	2617	var dest_writer = atomic_file.file_writer.writer(&buffer);
2621	2618
...	...	@@ -2658,7 +2655,7 @@ pub fn copyFile(
2658	2655	var atomic_file = try dest_dir.atomicFile(dest_path, .{ .mode = mode });
2659	2656	defer atomic_file.deinit();
2660	2657
2661		try copy_file(in_file.handle, atomic_file.file.handle, size);
	2658	try copy_file(in_file.handle, atomic_file.file_writer.file.handle, size);
2662	2659	try atomic_file.finish();
2663	2660	}
2664	2661

lib/std/fs/File.zig+12-7

...	...	@@ -961,6 +961,14 @@ pub const Reader = struct {
961	961	};
962	962	}
963	963
	964	pub fn initSize(file: File, buffer: []u8, size: u64) Reader {
	965	return .{
	966	.file = file,
	967	.interface = initInterface(buffer),
	968	.size = size,
	969	};
	970	}
	971
964	972	pub fn getSize(r: *Reader) GetEndPosError!u64 {
965	973	return r.size orelse {
966	974	if (r.size_err) \|err\| return err;
...	...	@@ -1436,18 +1444,15 @@ pub fn readerStreaming(file: File) Reader {
1436	1444	///
1437	1445	/// Positional is more threadsafe, since the global seek position is not
1438	1446	/// affected.
1439		pub fn writer(file: File) Writer {
1440		return .{ .file = file };
	1447	pub fn writer(file: File, buffer: []u8) Writer {
	1448	return .init(file, buffer);
1441	1449	}
1442	1450
1443	1451	/// Positional is more threadsafe, since the global seek position is not
1444	1452	/// affected, but when such syscalls are not available, preemptively choosing
1445	1453	/// `Writer.Mode.streaming` will skip a failed syscall.
1446		pub fn writerStreaming(file: File) Writer {
1447		return .{
1448		.file = file,
1449		.mode = .streaming,
1450		};
	1454	pub fn writerStreaming(file: File, buffer: []u8) Writer {
	1455	return .initMode(file, buffer, .streaming);
1451	1456	}
1452	1457
1453	1458	const range_off: windows.LARGE_INTEGER = 0;

lib/std/http.zig+8-1

...	...	@@ -433,12 +433,18 @@ pub const Reader = struct {
433	433	///
434	434	/// See also:
435	435	/// * `interfaceDecompressing`
436		pub fn bodyReader(reader: *Reader, transfer_encoding: TransferEncoding, content_length: ?u64) std.io.Reader {
	436	pub fn bodyReader(
	437	reader: *Reader,
	438	buffer: []u8,
	439	transfer_encoding: TransferEncoding,
	440	content_length: ?u64,
	441	) std.io.Reader {
437	442	assert(reader.state == .received_head);
438	443	return switch (transfer_encoding) {
439	444	.chunked => {
440	445	reader.state = .{ .body_remaining_chunk_len = .head };
441	446	return .{
	447	.buffer = buffer,
442	448	.context = reader,
443	449	.vtable = &.{
444	450	.read = chunkedRead,
...	...	@@ -450,6 +456,7 @@ pub const Reader = struct {
450	456	if (content_length) \|len\| {
451	457	reader.state = .{ .body_remaining_content_length = len };
452	458	return .{
	459	.buffer = buffer,
453	460	.context = reader,
454	461	.vtable = &.{
455	462	.read = contentLengthRead,

lib/std/http/Client.zig+2-2

...	...	@@ -667,11 +667,11 @@ pub const Response = struct {
667	667	///
668	668	/// See also:
669	669	/// * `readerDecompressing`
670		pub fn reader(response: *Response) std.io.Reader {
	670	pub fn reader(response: *Response, buffer: []u8) std.io.Reader {
671	671	const req = response.request;
672	672	if (!req.method.responseHasBody()) return .ending;
673	673	const head = &response.head;
674		return req.reader.bodyReader(head.transfer_encoding, head.content_length);
	674	return req.reader.bodyReader(buffer, head.transfer_encoding, head.content_length);
675	675	}
676	676
677	677	/// If compressed body has been negotiated this will return decompressed bytes.

lib/std/http/test.zig+2-1

...	...	@@ -1198,8 +1198,9 @@ test "redirect to different connection" {
1198	1198
1199	1199	try req.sendBodiless();
1200	1200	var response = try req.receiveHead(&redirect_buffer);
	1201	var reader = response.reader(&.{});
1201	1202
1202		const body = try response.reader().readRemainingAlloc(gpa, .limited(8192));
	1203	const body = try reader.allocRemaining(gpa, .limited(8192));
1203	1204	defer gpa.free(body);
1204	1205
1205	1206	try expectEqualStrings("good job, you pass", body);

lib/std/io/Reader.zig+29-5

...	...	@@ -162,9 +162,9 @@ pub fn defaultDiscard(r: *Reader, limit: Limit) Error!usize {
162	162	};
163	163	if (n > @intFromEnum(limit)) {
164	164	const over_amt = n - @intFromEnum(limit);
165		assert(over_amt <= w.buffer.len); // limit may be exceeded only by an amount within buffer capacity.
166	165	r.seek = w.end - over_amt;
167	166	r.end = w.end;
	167	assert(r.end <= w.buffer.len); // limit may be exceeded only by an amount within buffer capacity.
168	168	return @intFromEnum(limit);
169	169	}
170	170	return n;
...	...	@@ -740,12 +740,20 @@ pub fn peekDelimiterInclusive(r: *Reader, delimiter: u8) DelimiterError![]u8 {
740	740	}
741	741	if (seek > 0) {
742	742	const remainder = buffer[seek..];
743		std.mem.copyForwards(u8, buffer[0..remainder.len], remainder);
	743	@memmove(buffer[0..remainder.len], remainder);
744	744	r.end = remainder.len;
745	745	r.seek = 0;
746	746	}
	747	var writer: Writer = .{
	748	.buffer = r.buffer,
	749	.vtable = &.{ .drain = Writer.fixedDrain },
	750	};
747	751	while (r.end < r.buffer.len) {
748		const n = try r.unbuffered_reader.readVec(&.{r.buffer[r.end..]});
	752	writer.end = r.end;
	753	const n = r.vtable.stream(r, &writer, .limited(r.buffer.len - r.end)) catch \|err\| switch (err) {
	754	error.WriteFailed => unreachable,
	755	else => \|e\| return e,
	756	};
749	757	const prev_end = r.end;
750	758	r.end = prev_end + n;
751	759	if (std.mem.indexOfScalarPos(u8, r.buffer[0..r.end], prev_end, delimiter)) \|end\| {
...	...	@@ -929,8 +937,16 @@ pub fn fill(r: *Reader, n: usize) Error!void {
929	937	return;
930	938	}
931	939	rebaseCapacity(r, n);
	940	var writer: Writer = .{
	941	.buffer = r.buffer,
	942	.vtable = &.{ .drain = Writer.fixedDrain },
	943	};
932	944	while (r.end < r.seek + n) {
933		r.end += try r.unbuffered_reader.readVec(&.{r.buffer[r.end..]});
	945	writer.end = r.end;
	946	r.end += r.vtable.stream(r, &writer, .limited(r.buffer.len - r.end)) catch \|err\| switch (err) {
	947	error.WriteFailed => unreachable,
	948	else => \|e\| return e,
	949	};
934	950	}
935	951	}
936	952
...	...	@@ -941,7 +957,15 @@ pub fn fill(r: *Reader, n: usize) Error!void {
941	957	/// Asserts buffer capacity is at least 1.
942	958	pub fn fillMore(r: *Reader) Error!void {
943	959	rebaseCapacity(r, 1);
944		r.end += try r.unbuffered_reader.readVec(&.{r.buffer[r.end..]});
	960	var writer: Writer = .{
	961	.buffer = r.buffer,
	962	.end = r.end,
	963	.vtable = &.{ .drain = Writer.fixedDrain },
	964	};
	965	r.end += r.vtable.stream(r, &writer, .limited(r.buffer.len - r.end)) catch \|err\| switch (err) {
	966	error.WriteFailed => unreachable,
	967	else => \|e\| return e,
	968	};
945	969	}
946	970
947	971	/// Returns the next byte from the stream or returns `error.EndOfStream`.

lib/std/io/Writer.zig+24-20

...	...	@@ -1722,7 +1722,7 @@ pub fn unimplementedSendFile(w: Writer, file_reader: File.Reader, limit: Limit
1722	1722	/// time to return an error. However, we still need to make sure all of the
1723	1723	/// available buffer has been filled. Also, it may be called from `flush` in
1724	1724	/// which case it should return successfully.
1725		fn fixedDrain(w: *Writer, data: []const []const u8, splat: usize) Error!usize {
	1725	pub fn fixedDrain(w: *Writer, data: []const []const u8, splat: usize) Error!usize {
1726	1726	if (data.len == 0) return 0;
1727	1727	for (data[0 .. data.len - 1]) \|bytes\| {
1728	1728	const dest = w.buffer[w.end..];
...	...	@@ -1860,24 +1860,30 @@ pub const Allocating = struct {
1860	1860	pub fn init(allocator: Allocator) Allocating {
1861	1861	return .{
1862	1862	.allocator = allocator,
1863		.interface = init_interface,
1864		.buffer = &.{},
	1863	.interface = .{
	1864	.buffer = &.{},
	1865	.vtable = &vtable,
	1866	},
1865	1867	};
1866	1868	}
1867	1869
1868	1870	pub fn initCapacity(allocator: Allocator, capacity: usize) error{OutOfMemory}!Allocating {
1869	1871	return .{
1870	1872	.allocator = allocator,
1871		.interface = init_interface,
1872		.buffer = try allocator.alloc(u8, capacity),
	1873	.interface = .{
	1874	.buffer = try allocator.alloc(u8, capacity),
	1875	.vtable = &vtable,
	1876	},
1873	1877	};
1874	1878	}
1875	1879
1876	1880	pub fn initOwnedSlice(allocator: Allocator, slice: []u8) Allocating {
1877	1881	return .{
1878	1882	.allocator = allocator,
1879		.interface = init_interface,
1880		.buffer = slice,
	1883	.interface = .{
	1884	.buffer = slice,
	1885	.vtable = &vtable,
	1886	},
1881	1887	};
1882	1888	}
1883	1889
...	...	@@ -1886,23 +1892,21 @@ pub const Allocating = struct {
1886	1892	defer array_list.* = .empty;
1887	1893	return .{
1888	1894	.allocator = allocator,
1889		.interface = init_interface,
1890		.buffer = array_list.allocatedSlice(),
1891		.end = array_list.items.len,
	1895	.interface = .{
	1896	.vtable = &vtable,
	1897	.buffer = array_list.allocatedSlice(),
	1898	.end = array_list.items.len,
	1899	},
1892	1900	};
1893	1901	}
1894	1902
1895		const init_interface: Writer = .{
1896		.interface = .{
1897		.vtable = &.{
1898		.drain = Allocating.drain,
1899		.sendFile = Allocating.sendFile,
1900		},
1901		},
	1903	const vtable: VTable = .{
	1904	.drain = Allocating.drain,
	1905	.sendFile = Allocating.sendFile,
1902	1906	};
1903	1907
1904	1908	pub fn deinit(a: *Allocating) void {
1905		a.allocator.free(a.buffer);
	1909	a.allocator.free(a.interface.buffer);
1906	1910	a.* = undefined;
1907	1911	}
1908	1912
...	...	@@ -1983,8 +1987,8 @@ pub const Allocating = struct {
1983	1987	}
1984	1988
1985	1989	fn setArrayList(a: *Allocating, list: std.ArrayListUnmanaged(u8)) void {
1986		a.buffer = list.allocatedSlice();
1987		a.end = list.items.len;
	1990	a.interface.buffer = list.allocatedSlice();
	1991	a.interface.end = list.items.len;
1988	1992	}
1989	1993
1990	1994	test Allocating {

lib/std/net.zig+2-6

...	...	@@ -970,7 +970,7 @@ pub fn getAddressList(gpa: Allocator, name: []const u8, port: u16) GetAddressLis
970	970	const name_c = try gpa.dupeZ(u8, name);
971	971	defer gpa.free(name_c);
972	972
973		const port_c = try std.fmt.allocPrintZ(gpa, "{}", .{port});
	973	const port_c = try std.fmt.allocPrintSentinel(gpa, "{d}", .{port}, 0);
974	974	defer gpa.free(port_c);
975	975
976	976	const hints: posix.addrinfo = .{
...	...	@@ -1985,10 +1985,7 @@ pub const Stream = struct {
1985	1985	return .{
1986	1986	.stream = stream,
1987	1987	.interface = .{
1988		.context = undefined,
1989		.vtable = &.{
1990		.drain = drain,
1991		},
	1988	.vtable = &.{ .drain = drain },
1992	1989	.buffer = buffer,
1993	1990	},
1994	1991	};
...	...	@@ -2090,7 +2087,6 @@ pub const Stream = struct {
2090	2087	pub fn init(stream: Stream, buffer: []u8) Writer {
2091	2088	return .{
2092	2089	.interface = .{
2093		.context = undefined,
2094	2090	.vtable = &.{
2095	2091	.drain = drain,
2096	2092	.sendFile = sendFile,

lib/std/tar/test.zig+3-3

...	...	@@ -347,7 +347,7 @@ test "run test cases" {
347	347
348	348	for (cases) \|case\| {
349	349	var br: std.io.Reader = .fixed(case.data);
350		var iter = tar.iterator(&br, .{
	350	var iter: tar.Iterator = .init(&br, .{
351	351	.file_name_buffer = &file_name_buffer,
352	352	.link_name_buffer = &link_name_buffer,
353	353	});
...	...	@@ -391,7 +391,7 @@ test "pax/gnu long names with small buffer" {
391	391
392	392	for (long_name_cases) \|case\| {
393	393	var br: std.io.Reader = .fixed(case.data);
394		var iter = tar.iterator(&br, .{
	394	var iter: tar.Iterator = .init(&br, .{
395	395	.file_name_buffer = &min_file_name_buffer,
396	396	.link_name_buffer = &min_link_name_buffer,
397	397	});
...	...	@@ -412,7 +412,7 @@ test "insufficient buffer in Header name filed" {
412	412	var min_link_name_buffer: [100]u8 = undefined;
413	413
414	414	var br: std.io.Reader = .fixed(cases[0].data);
415		var iter = tar.iterator(&br, .{
	415	var iter: tar.Iterator = .init(&br, .{
416	416	.file_name_buffer = &min_file_name_buffer,
417	417	.link_name_buffer = &min_link_name_buffer,
418	418	});

lib/std/tz.zig+5-3

...	...	@@ -55,10 +55,12 @@ pub const Tz = struct {
55	55	};
56	56
57	57	pub fn parse(allocator: std.mem.Allocator, reader: *std.io.Reader) !Tz {
58		var legacy_header = try reader.takeStruct(Header);
	58	var legacy_header = (try reader.takeStruct(Header)).*;
59	59	if (!std.mem.eql(u8, &legacy_header.magic, "TZif")) return error.BadHeader;
60		if (legacy_header.version != 0 and legacy_header.version != '2' and legacy_header.version != '3') return error.BadVersion;
61
	60	switch (legacy_header.version) {
	61	0, '2', '3' => {},
	62	else => return error.BadVersion,
	63	}
62	64	if (builtin.target.cpu.arch.endian() != std.builtin.Endian.big) {
63	65	std.mem.byteSwapAllFields(@TypeOf(legacy_header.counts), &legacy_header.counts);
64	66	}

lib/std/zig/system/linux.zig+6-9

...	...	@@ -355,20 +355,17 @@ fn testParser(
355	355	// When all the lines have been analyzed the finalize method is called.
356	356	fn CpuinfoParser(comptime impl: anytype) type {
357	357	return struct {
358		fn parse(arch: Target.Cpu.Arch, reader: anytype) anyerror!?Target.Cpu {
359		var line_buf: [1024]u8 = undefined;
	358	fn parse(arch: Target.Cpu.Arch, reader: *std.io.Reader) !?Target.Cpu {
360	359	var obj: impl = .{};
361
362		while (true) {
363		const line = (try reader.readUntilDelimiterOrEof(&line_buf, '\n')) orelse break;
	360	while (reader.takeDelimiterExclusive('\n')) \|line\| {
364	361	const colon_pos = mem.indexOfScalar(u8, line, ':') orelse continue;
365	362	const key = mem.trimEnd(u8, line[0..colon_pos], " \t");
366	363	const value = mem.trimStart(u8, line[colon_pos + 1 ..], " \t");
367
368		if (!try obj.line_hook(key, value))
369		break;
	364	if (!try obj.line_hook(key, value)) break;
	365	} else \|err\| switch (err) {
	366	error.EndOfStream => {},
	367	else => \|e\| return e,
370	368	}
371
372	369	return obj.finalize(arch);
373	370	}
374	371	};

lib/std/zip/test.zig+6-4

...	...	@@ -51,10 +51,10 @@ const FileStore = struct {
51	51	uncompressed_size: usize,
52	52	};
53	53
54		fn makeZip(file_writer: *std.fs.File.Writer, files: []const File, options: WriteZipOptions) !std.io.Reader {
	54	fn makeZip(file_writer: *std.fs.File.Writer, files: []const File, options: WriteZipOptions) !void {
55	55	const store = try std.testing.allocator.alloc(FileStore, files.len);
56	56	defer std.testing.allocator.free(store);
57		return makeZipWithStore(file_writer, files, options, store);
	57	try makeZipWithStore(file_writer, files, options, store);
58	58	}
59	59
60	60	fn makeZipWithStore(
...	...	@@ -312,7 +312,8 @@ fn testZipWithStore(
312	312
313	313	var file = tmp.createFile();
314	314	defer file.close();
315		var file_writer = file.writer();
	315	var buffer: [100]u8 = undefined;
	316	var file_writer = file.writer(&buffer);
316	317	try makeZipWithStore(&file_writer, test_files, write_opt, store);
317	318	var file_reader = file_writer.moveToReader();
318	319	try zip.extract(tmp.dir, &file_reader, options);
...	...	@@ -323,7 +324,8 @@ fn testZipError(expected_error: anyerror, file: File, options: zip.ExtractOption
323	324	defer tmp.cleanup();
324	325	const tmp_file = tmp.createFile();
325	326	defer tmp_file.close();
326		var file_writer = tmp_file.writer();
	327	var buffer: [100]u8 = undefined;
	328	var file_writer = tmp_file.writer(&buffer);
327	329	var store: [1]FileStore = undefined;
328	330	try makeZipWithStore(&file_writer, &[_]File{file}, .{}, &store);
329	331	var file_reader = file_writer.moveToReader();

author	Andrew Kelley <andrew@ziglang.org> 2025-06-23 03:48:12-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2025-07-01 16:35:29-07:00
log	af24e722fba2245d50473dc7a6fb7671851e07dc
tree	4dbc325e0836ffe5a62857c05d9949087251691c
parent	52b3275eb2cc11a9d81510f465458208eddfd796

update some stuff to std.io API