Commit 837f2bfc697c604b0d16d789b4ca2752f58b0ed5 | zig

lib/compiler/test_runner.zig+4-6

...	...	@@ -69,13 +69,11 @@ var stdout_buffer: [std.heap.page_size_min]u8 align(std.heap.page_size_min) = un
69	69
70	70	fn mainServer() !void {
71	71	@disableInstrumentation();
72		var stdin_reader = std.fs.File.stdin().reader();
73		var stdout_writer = std.fs.File.stdout().writer();
74		var stdin_buffered_reader = stdin_reader.interface().buffered(&stdin_buffer);
75		var stdout_buffered_writer = stdout_writer.interface().buffered(&stdout_buffer);
	72	var stdin_reader = std.fs.File.stdin().reader(&stdin_buffer);
	73	var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
76	74	var server = try std.zig.Server.init(.{
77		.in = &stdin_buffered_reader,
78		.out = &stdout_buffered_writer,
	75	.in = &stdin_reader.interface,
	76	.out = &stdout_writer.interface,
79	77	.zig_version = builtin.zig_version_string,
80	78	});
81	79

lib/std/compress/flate/Decompress.zig+53-76

...	...	@@ -1,22 +1,3 @@
1		//! Inflate decompresses deflate bit stream. Reads compressed data from reader
2		//! provided in init. Decompressed data are stored in internal hist buffer and
3		//! can be accesses iterable `next` or reader interface.
4		//!
5		//! Container defines header/footer wrapper around deflate bit stream. Can be
6		//! gzip or zlib.
7		//!
8		//! Deflate bit stream consists of multiple blocks. Block can be one of three types:
9		//! * stored, non compressed, max 64k in size
10		//! * fixed, huffman codes are predefined
11		//! * dynamic, huffman code tables are encoded at the block start
12		//!
13		//! `step` function runs decoder until internal `hist` buffer is full. Client than needs to read
14		//! that data in order to proceed with decoding.
15		//!
16		//! Allocates 74.5K of internal buffers, most important are:
17		//! * 64K for history (CircularBuffer)
18		//! * ~10K huffman decoders (Literal and DistanceDecoder)
19
20	1	const std = @import("../../std.zig");
21	2	const flate = std.compress.flate;
22	3	const Container = flate.Container;
...	...	@@ -24,16 +5,16 @@ const Token = @import("Token.zig");
24	5	const testing = std.testing;
25	6	const Decompress = @This();
26	7	const Writer = std.io.Writer;
	8	const Reader = std.io.Reader;
27	9
28		input: *std.io.Reader,
29		// Hashes, produces checksum, of uncompressed data for gzip/zlib footer.
	10	input: *Reader,
	11	interface: Reader,
	12	/// Hashes, produces checksum, of uncompressed data for gzip/zlib footer.
30	13	hasher: Container.Hasher,
31	14
32		// dynamic block huffman code decoders
33	15	lit_dec: LiteralDecoder,
34	16	dst_dec: DistanceDecoder,
35	17
36		// current read state
37	18	final_block: bool,
38	19	state: State,
39	20
...	...	@@ -68,8 +49,16 @@ pub const Error = Container.Error \|\| error{
68	49	MissingEndOfBlockCode,
69	50	};
70	51
71		pub fn init(input: *std.io.Reader, container: Container) Decompress {
	52	pub fn init(input: *Reader, container: Container, buffer: []u8) Decompress {
72	53	return .{
	54	.interface = .{
	55	// TODO populate discard so that when an amount is discarded that
	56	// includes an entire frame, skip decoding that frame.
	57	.vtable = &.{ .stream = stream },
	58	.buffer = buffer,
	59	.seek = 0,
	60	.end = 0,
	61	},
73	62	.input = input,
74	63	.hasher = .init(container),
75	64	.lit_dec = .{},
...	...	@@ -140,13 +129,9 @@ fn decodeSymbol(self: *Decompress, decoder: anytype) !Symbol {
140	129	return sym;
141	130	}
142	131
143		pub fn read(
144		context: ?*anyopaque,
145		bw: *Writer,
146		limit: std.io.Limit,
147		) std.io.Reader.StreamError!usize {
148		const d: *Decompress = @alignCast(@ptrCast(context));
149		return readInner(d, bw, limit) catch \|err\| switch (err) {
	132	pub fn stream(r: Reader, w: Writer, limit: std.io.Limit) Reader.StreamError!usize {
	133	const d: *Decompress = @alignCast(@fieldParentPtr("interface", r));
	134	return readInner(d, w, limit) catch \|err\| switch (err) {
150	135	error.EndOfStream => return error.EndOfStream,
151	136	error.WriteFailed => return error.WriteFailed,
152	137	else => \|e\| {
...	...	@@ -158,11 +143,7 @@ pub fn read(
158	143	};
159	144	}
160	145
161		fn readInner(
162		d: *Decompress,
163		bw: *Writer,
164		limit: std.io.Limit,
165		) (Error \|\| error{ WriteFailed, EndOfStream })!usize {
	146	fn readInner(d: Decompress, w: Writer, limit: std.io.Limit) (Error \|\| Reader.StreamError)!usize {
166	147	const in = d.input;
167	148	sw: switch (d.state) {
168	149	.protocol_header => switch (d.hasher.container()) {
...	...	@@ -266,76 +247,75 @@ fn readInner(
266	247	}
267	248	},
268	249	.stored_block => \|remaining_len\| {
269		const out = try bw.writableSliceGreedyPreserving(flate.history_len, 1);
	250	const out = try w.writableSliceGreedyPreserving(flate.history_len, 1);
270	251	const limited_out = limit.min(.limited(remaining_len)).slice(out);
271		const n = try d.input.readVec(bw, &.{limited_out});
	252	const n = try d.input.readVec(&.{limited_out});
272	253	if (remaining_len - n == 0) {
273	254	d.state = if (d.final_block) .protocol_footer else .block_header;
274	255	} else {
275		d.state = .{ .stored_block = remaining_len - n };
	256	d.state = .{ .stored_block = @intCast(remaining_len - n) };
276	257	}
277		bw.advance(n);
	258	w.advance(n);
278	259	return n;
279	260	},
280	261	.fixed_block => {
281		const start = bw.count;
282		while (@intFromEnum(limit) > bw.count - start) {
	262	const start = w.count;
	263	while (@intFromEnum(limit) > w.count - start) {
283	264	const code = try d.readFixedCode();
284	265	switch (code) {
285		0...255 => try bw.writeBytePreserving(flate.history_len, @intCast(code)),
	266	0...255 => try w.writeBytePreserving(flate.history_len, @intCast(code)),
286	267	256 => {
287	268	d.state = if (d.final_block) .protocol_footer else .block_header;
288		return bw.count - start;
	269	return w.count - start;
289	270	},
290	271	257...285 => {
291	272	// Handles fixed block non literal (length) code.
292	273	// Length code is followed by 5 bits of distance code.
293		const rebased_code = code - 257;
294		const length = try d.decodeLength(rebased_code);
	274	const length = try d.decodeLength(@intCast(code - 257));
295	275	const distance = try d.decodeDistance(try d.takeBitsReverseBuffered(u5));
296		try writeMatch(bw, length, distance);
	276	try writeMatch(w, length, distance);
297	277	},
298	278	else => return error.InvalidCode,
299	279	}
300	280	}
301	281	d.state = .fixed_block;
302		return bw.count - start;
	282	return w.count - start;
303	283	},
304	284	.dynamic_block => {
305	285	// In larger archives most blocks are usually dynamic, so decompression
306	286	// performance depends on this logic.
307		const start = bw.count;
308		while (@intFromEnum(limit) > bw.count - start) {
	287	const start = w.count;
	288	while (@intFromEnum(limit) > w.count - start) {
309	289	const sym = try d.decodeSymbol(&d.lit_dec);
310	290
311	291	switch (sym.kind) {
312		.literal => d.hist.write(sym.symbol),
	292	.literal => try w.writeBytePreserving(flate.history_len, sym.symbol),
313	293	.match => {
314	294	// Decode match backreference <length, distance>
315	295	const length = try d.decodeLength(sym.symbol);
316	296	const dsm = try d.decodeSymbol(&d.dst_dec);
317	297	const distance = try d.decodeDistance(dsm.symbol);
318		try writeMatch(bw, length, distance);
	298	try writeMatch(w, length, distance);
319	299	},
320	300	.end_of_block => {
321	301	d.state = if (d.final_block) .protocol_footer else .block_header;
322		return bw.count - start;
	302	return w.count - start;
323	303	},
324	304	}
325	305	}
326	306	d.state = .dynamic_block;
327		return bw.count - start;
	307	return w.count - start;
328	308	},
329	309	.protocol_footer => {
330	310	d.alignBitsToByte();
331		switch (d.hasher.container()) {
	311	switch (d.hasher) {
332	312	.gzip => \|*gzip\| {
333		if (try reader.read(u32) != gzip.final()) return error.WrongGzipChecksum;
334		if (try reader.read(u32) != gzip.count) return error.WrongGzipSize;
	313	if (try in.takeInt(u32, .little) != gzip.crc.final()) return error.WrongGzipChecksum;
	314	if (try in.takeInt(u32, .little) != gzip.count) return error.WrongGzipSize;
335	315	},
336	316	.zlib => \|*zlib\| {
337	317	const chksum: u32 = @byteSwap(zlib.final());
338		if (try reader.read(u32) != chksum) return error.WrongZlibChecksum;
	318	if (try in.takeInt(u32, .big) != chksum) return error.WrongZlibChecksum;
339	319	},
340	320	.raw => {},
341	321	}
...	...	@@ -355,15 +335,12 @@ fn writeMatch(bw: *Writer, length: u16, distance: u16) !void {
355	335	@panic("TODO");
356	336	}
357	337
358		pub fn reader(self: *Decompress, buffer: []u8) std.io.Reader {
359		return .{
360		.context = self,
361		.vtable = &.{ .read = read },
362		.buffer = buffer,
363		};
	338	fn takeBits(d: *Decompress, comptime T: type) !T {
	339	_ = d;
	340	@panic("TODO");
364	341	}
365	342
366		fn takeBits(d: *Decompress, comptime T: type) !T {
	343	fn takeBitsReverseBuffered(d: *Decompress, comptime T: type) !T {
367	344	_ = d;
368	345	@panic("TODO");
369	346	}
...	...	@@ -725,8 +702,8 @@ test "decompress" {
725	702	},
726	703	};
727	704	for (cases) \|c\| {
728		var fb: std.io.Reader = .fixed(c.in);
729		var aw: std.io.Writer.Allocating = .init(testing.allocator);
	705	var fb: Reader = .fixed(c.in);
	706	var aw: Writer.Allocating = .init(testing.allocator);
730	707	defer aw.deinit();
731	708
732	709	var decompress: Decompress = .init(&fb, .raw);
...	...	@@ -784,8 +761,8 @@ test "gzip decompress" {
784	761	},
785	762	};
786	763	for (cases) \|c\| {
787		var fb: std.io.Reader = .fixed(c.in);
788		var aw: std.io.Writer.Allocating = .init(testing.allocator);
	764	var fb: Reader = .fixed(c.in);
	765	var aw: Writer.Allocating = .init(testing.allocator);
789	766	defer aw.deinit();
790	767
791	768	var decompress: Decompress = .init(&fb, .gzip);
...	...	@@ -812,8 +789,8 @@ test "zlib decompress" {
812	789	},
813	790	};
814	791	for (cases) \|c\| {
815		var fb: std.io.Reader = .fixed(c.in);
816		var aw: std.io.Writer.Allocating = .init(testing.allocator);
	792	var fb: Reader = .fixed(c.in);
	793	var aw: Writer.Allocating = .init(testing.allocator);
817	794	defer aw.deinit();
818	795
819	796	var decompress: Decompress = .init(&fb, .zlib);
...	...	@@ -872,8 +849,8 @@ test "fuzzing tests" {
872	849	};
873	850
874	851	inline for (cases, 0..) \|c, case_no\| {
875		var in: std.io.Reader = .fixed(@embedFile("testdata/fuzz/" ++ c.input ++ ".input"));
876		var aw: std.io.Writer.Allocating = .init(testing.allocator);
	852	var in: Reader = .fixed(@embedFile("testdata/fuzz/" ++ c.input ++ ".input"));
	853	var aw: Writer.Allocating = .init(testing.allocator);
877	854	defer aw.deinit();
878	855	errdefer std.debug.print("test case failed {}\n", .{case_no});
879	856
...	...	@@ -893,8 +870,8 @@ test "bug 18966" {
893	870	const input = @embedFile("testdata/fuzz/bug_18966.input");
894	871	const expect = @embedFile("testdata/fuzz/bug_18966.expect");
895	872
896		var in: std.io.Reader = .fixed(input);
897		var aw: std.io.Writer.Allocating = .init(testing.allocator);
	873	var in: Reader = .fixed(input);
	874	var aw: Writer.Allocating = .init(testing.allocator);
898	875	defer aw.deinit();
899	876
900	877	var decompress: Decompress = .init(&in, .gzip);
...	...	@@ -909,7 +886,7 @@ test "reading into empty buffer" {
909	886	0b0000_0001, 0b0000_1100, 0x00, 0b1111_0011, 0xff, // deflate fixed buffer header len, nlen
910	887	'H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', 0x0a, // non compressed data
911	888	};
912		var in: std.io.Reader = .fixed(input);
	889	var in: Reader = .fixed(input);
913	890	var decomp: Decompress = .init(&in, .raw);
914	891	var decompress_br = decomp.readable(&.{});
915	892	var buf: [0]u8 = undefined;

lib/std/crypto/Certificate/Bundle.zig+14-13

...	...	@@ -200,10 +200,9 @@ pub fn addCertsFromFilePathAbsolute(
200	200	gpa: Allocator,
201	201	abs_file_path: []const u8,
202	202	) AddCertsFromFilePathError!void {
203		assert(fs.path.isAbsolute(abs_file_path));
204		var file = try fs.openFileAbsolute(abs_file_path, .{});
205		defer file.close();
206		return addCertsFromFile(cb, gpa, file);
	203	var file_reader: fs.File.Reader = .init(try fs.openFileAbsolute(abs_file_path, .{}), &.{});
	204	defer file_reader.file.close();
	205	return addCertsFromFile(cb, gpa, &file_reader, std.time.timestamp());
207	206	}
208	207
209	208	pub fn addCertsFromFilePath(
...	...	@@ -212,9 +211,9 @@ pub fn addCertsFromFilePath(
212	211	dir: fs.Dir,
213	212	sub_file_path: []const u8,
214	213	) AddCertsFromFilePathError!void {
215		var file = try dir.openFile(sub_file_path, .{});
216		defer file.close();
217		return addCertsFromFile(cb, gpa, file);
	214	var file_reader: fs.File.Reader = .init(try dir.openFile(sub_file_path, .{}), &.{});
	215	defer file_reader.file.close();
	216	return addCertsFromFile(cb, gpa, &file_reader, std.time.timestamp());
218	217	}
219	218
220	219	pub const AddCertsFromFileError = Allocator.Error \|\|
...	...	@@ -224,10 +223,14 @@ pub const AddCertsFromFileError = Allocator.Error \|\|
224	223	std.base64.Error \|\|
225	224	error{ CertificateAuthorityBundleTooBig, MissingEndCertificateMarker };
226	225
227		pub fn addCertsFromFile(cb: *Bundle, gpa: Allocator, file: fs.File) AddCertsFromFileError!void {
228		var file_reader = file.reader();
	226	/// `file_reader` needs no buffer since it will be read directly into `Bundle`.
	227	pub fn addCertsFromFile(
	228	cb: *Bundle,
	229	gpa: Allocator,
	230	file_reader: *fs.File.Reader,
	231	now_sec: i64,
	232	) AddCertsFromFileError!void {
229	233	const size = try file_reader.getSize();
230		var br = file_reader.interface().unbuffered();
231	234
232	235	// We borrow `bytes` as a temporary buffer for the base64-encoded data.
233	236	// This is possible by computing the decoded length and reserving the space
...	...	@@ -238,7 +241,7 @@ pub fn addCertsFromFile(cb: *Bundle, gpa: Allocator, file: fs.File) AddCertsFrom
238	241	try cb.bytes.ensureUnusedCapacity(gpa, needed_capacity);
239	242	const end_reserved: u32 = @intCast(cb.bytes.items.len + decoded_size_upper_bound);
240	243	const buffer = cb.bytes.allocatedSlice()[end_reserved..];
241		const end_index = br.readSliceShort(buffer) catch \|err\| switch (err) {
	244	const end_index = file_reader.interface.readSliceShort(buffer) catch \|err\| switch (err) {
242	245	error.ReadFailed => return file_reader.err.?,
243	246	};
244	247	const encoded_bytes = buffer[0..end_index];
...	...	@@ -246,8 +249,6 @@ pub fn addCertsFromFile(cb: *Bundle, gpa: Allocator, file: fs.File) AddCertsFrom
246	249	const begin_marker = "-----BEGIN CERTIFICATE-----";
247	250	const end_marker = "-----END CERTIFICATE-----";
248	251
249		const now_sec = std.time.timestamp();
250
251	252	var start_index: usize = 0;
252	253	while (mem.indexOfPos(u8, encoded_bytes, start_index, begin_marker)) \|begin_marker_start\| {
253	254	const cert_start = begin_marker_start + begin_marker.len;

lib/std/debug/Dwarf.zig+3-2

...	...	@@ -2240,9 +2240,10 @@ pub const ElfModule = struct {
2240	2240	if (chdr.ch_type != .ZLIB) continue;
2241	2241	const ch_size = chdr.ch_size;
2242	2242
2243		var zlib_stream: std.compress.flate.Decompress = .init(&section_reader, .zlib);
	2243	var zlib_stream: std.compress.flate.Decompress = .init(&section_reader, .zlib, &.{});
2244	2244
2245		const decompressed_section = zlib_stream.reader().readRemainingAlloc(gpa, .limited(ch_size)) catch continue;
	2245	const decompressed_section = zlib_stream.interface.allocRemaining(gpa, .limited(ch_size)) catch
	2246	continue;
2246	2247	if (decompressed_section.len != ch_size) {
2247	2248	gpa.free(decompressed_section);
2248	2249	continue;

lib/std/fmt.zig+12-12

...	...	@@ -830,11 +830,11 @@ pub const BufPrintError = error{
830	830
831	831	/// Print a Formatter string into `buf`. Returns a slice of the bytes printed.
832	832	pub fn bufPrint(buf: []u8, comptime fmt: []const u8, args: anytype) BufPrintError![]u8 {
833		var bw: Writer = .fixed(buf);
834		bw.print(fmt, args) catch \|err\| switch (err) {
	833	var w: Writer = .fixed(buf);
	834	w.print(fmt, args) catch \|err\| switch (err) {
835	835	error.WriteFailed => return error.NoSpaceLeft,
836	836	};
837		return bw.getWritten();
	837	return w.buffered();
838	838	}
839	839
840	840	pub fn bufPrintZ(buf: []u8, comptime fmt: []const u8, args: anytype) BufPrintError![:0]u8 {
...	...	@@ -1012,17 +1012,17 @@ test "int.padded" {
1012	1012	test "buffer" {
1013	1013	{
1014	1014	var buf1: [32]u8 = undefined;
1015		var bw: Writer = .fixed(&buf1);
1016		try bw.printValue("", .{}, 1234, std.options.fmt_max_depth);
1017		try std.testing.expectEqualStrings("1234", bw.getWritten());
	1015	var w: Writer = .fixed(&buf1);
	1016	try w.printValue("", .{}, 1234, std.options.fmt_max_depth);
	1017	try std.testing.expectEqualStrings("1234", w.buffered());
1018	1018
1019		bw = .fixed(&buf1);
1020		try bw.printValue("c", .{}, 'a', std.options.fmt_max_depth);
1021		try std.testing.expectEqualStrings("a", bw.getWritten());
	1019	w = .fixed(&buf1);
	1020	try w.printValue("c", .{}, 'a', std.options.fmt_max_depth);
	1021	try std.testing.expectEqualStrings("a", w.buffered());
1022	1022
1023		bw = .fixed(&buf1);
1024		try bw.printValue("b", .{}, 0b1100, std.options.fmt_max_depth);
1025		try std.testing.expectEqualStrings("1100", bw.getWritten());
	1023	w = .fixed(&buf1);
	1024	try w.printValue("b", .{}, 0b1100, std.options.fmt_max_depth);
	1025	try std.testing.expectEqualStrings("1100", w.buffered());
1026	1026	}
1027	1027	}
1028	1028

lib/std/fs/AtomicFile.zig+3-5

...	...	@@ -26,6 +26,7 @@ pub fn init(
26	26	mode: File.Mode,
27	27	dir: Dir,
28	28	close_dir_on_deinit: bool,
	29	write_buffer: []u8,
29	30	) InitError!AtomicFile {
30	31	var rand_buf: [random_bytes_len]u8 = undefined;
31	32	var tmp_path_buf: [tmp_path_len:0]u8 = undefined;
...	...	@@ -35,16 +36,13 @@ pub fn init(
35	36	const tmp_path = fs.base64_encoder.encode(&tmp_path_buf, &rand_buf);
36	37	tmp_path_buf[tmp_path.len] = 0;
37	38
38		const file = dir.createFile(
39		tmp_path,
40		.{ .mode = mode, .exclusive = true },
41		) catch \|err\| switch (err) {
	39	const file = dir.createFile(tmp_path, .{ .mode = mode, .exclusive = true }) catch \|err\| switch (err) {
42	40	error.PathAlreadyExists => continue,
43	41	else => \|e\| return e,
44	42	};
45	43
46	44	return .{
47		.file_writer = file.writer(),
	45	.file_writer = file.writer(write_buffer),
48	46	.tmp_path_buf = tmp_path_buf,
49	47	.dest_basename = dest_basename,
50	48	.file_open = true,

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

...	...	@@ -2609,12 +2609,15 @@ pub fn updateFile(
2609	2609	try dest_dir.makePath(dirname);
2610	2610	}
2611	2611
2612		var atomic_file = try dest_dir.atomicFile(dest_path, .{ .mode = actual_mode });
	2612	var buffer: [2000]u8 = undefined;
	2613	var atomic_file = try dest_dir.atomicFile(dest_path, .{
	2614	.mode = actual_mode,
	2615	.write_buffer = &buffer,
	2616	});
2613	2617	defer atomic_file.deinit();
2614	2618
2615	2619	var src_reader: File.Reader = .initSize(src_file, &.{}, src_stat.size);
2616		var buffer: [2000]u8 = undefined;
2617		var dest_writer = atomic_file.file_writer.writer(&buffer);
	2620	const dest_writer = &atomic_file.file_writer.interface;
2618	2621
2619	2622	dest_writer.writeFileAll(&src_reader, .{}) catch \|err\| switch (err) {
2620	2623	error.ReadFailed => return src_reader.err.?,
...	...	@@ -2715,6 +2718,7 @@ fn copy_file(fd_in: posix.fd_t, fd_out: posix.fd_t, maybe_size: ?u64) CopyFileRa
2715	2718	pub const AtomicFileOptions = struct {
2716	2719	mode: File.Mode = File.default_mode,
2717	2720	make_path: bool = false,
	2721	write_buffer: []u8,
2718	2722	};
2719	2723
2720	2724	/// Directly access the `.file` field, and then call `AtomicFile.finish` to
...	...	@@ -2732,9 +2736,9 @@ pub fn atomicFile(self: Dir, dest_path: []const u8, options: AtomicFileOptions)
2732	2736	else
2733	2737	try self.openDir(dirname, .{});
2734	2738
2735		return AtomicFile.init(fs.path.basename(dest_path), options.mode, dir, true);
	2739	return .init(fs.path.basename(dest_path), options.mode, dir, true, options.write_buffer);
2736	2740	} else {
2737		return AtomicFile.init(dest_path, options.mode, self, false);
	2741	return .init(dest_path, options.mode, self, false, options.write_buffer);
2738	2742	}
2739	2743	}
2740	2744

lib/std/http/test.zig+6-12

...	...	@@ -19,10 +19,8 @@ test "trailers" {
19	19	const connection = try net_server.accept();
20	20	defer connection.stream.close();
21	21
22		var stream_reader = connection.stream.reader();
23		var stream_writer = connection.stream.writer();
24		var connection_br = stream_reader.interface().buffered(&recv_buffer);
25		var connection_bw = stream_writer.interface().buffered(&send_buffer);
	22	var connection_br = connection.stream.reader(&recv_buffer);
	23	var connection_bw = connection.stream.writer(&send_buffer);
26	24	var server = http.Server.init(&connection_br, &connection_bw);
27	25
28	26	try expectEqual(.ready, server.reader.state);
...	...	@@ -104,10 +102,8 @@ test "HTTP server handles a chunked transfer coding request" {
104	102	const connection = try net_server.accept();
105	103	defer connection.stream.close();
106	104
107		var stream_reader = connection.stream.reader();
108		var stream_writer = connection.stream.writer();
109		var connection_br = stream_reader.interface().buffered(&recv_buffer);
110		var connection_bw = stream_writer.interface().buffered(&send_buffer);
	105	var connection_br = connection.stream.reader(&recv_buffer);
	106	var connection_bw = connection.stream.writer(&send_buffer);
111	107	var server = http.Server.init(&connection_br, &connection_bw);
112	108	var request = try server.receiveHead();
113	109
...	...	@@ -1163,10 +1159,8 @@ test "redirect to different connection" {
1163	1159	global.other_port.?,
1164	1160	});
1165	1161
1166		var stream_reader = connection.stream.reader();
1167		var stream_writer = connection.stream.writer();
1168		var connection_br = stream_reader.interface().buffered(&recv_buffer);
1169		var connection_bw = stream_writer.interface().buffered(&send_buffer);
	1162	var connection_br = connection.stream.reader(&recv_buffer);
	1163	var connection_bw = connection.stream.writer(&send_buffer);
1170	1164	var server = http.Server.init(&connection_br, &connection_bw);
1171	1165	var request = try server.receiveHead();
1172	1166	try expectEqualStrings(request.head.target, "/help");

lib/std/io/Reader.zig+11-11

...	...	@@ -13,7 +13,7 @@ const Limit = std.io.Limit;
13	13
14	14	pub const Limited = @import("Reader/Limited.zig");
15	15
16		context: ?*anyopaque,
	16	context: ?*anyopaque = null,
17	17	vtable: *const VTable,
18	18	buffer: []u8,
19	19	/// Number of bytes which have been consumed from `buffer`.
...	...	@@ -214,7 +214,7 @@ pub const LimitedAllocError = Allocator.Error \|\| ShortError \|\| error{StreamTooLo
214	214	pub fn allocRemaining(r: *Reader, gpa: Allocator, limit: Limit) LimitedAllocError![]u8 {
215	215	var buffer: ArrayList(u8) = .empty;
216	216	defer buffer.deinit(gpa);
217		try appendRemaining(r, gpa, null, &buffer, limit, 1);
	217	try appendRemaining(r, gpa, null, &buffer, limit);
218	218	return buffer.toOwnedSlice(gpa);
219	219	}
220	220
...	...	@@ -237,13 +237,13 @@ pub fn appendRemaining(
237	237	limit: Limit,
238	238	) LimitedAllocError!void {
239	239	const buffer = r.buffer;
240		const buffered = buffer[r.seek..r.end];
241		const copy_len = limit.minInt(buffered.len);
	240	const buffer_contents = buffer[r.seek..r.end];
	241	const copy_len = limit.minInt(buffer_contents.len);
242	242	try list.ensureUnusedCapacity(gpa, copy_len);
243	243	@memcpy(list.unusedCapacitySlice()[0..copy_len], buffer[0..copy_len]);
244	244	list.items.len += copy_len;
245	245	r.seek += copy_len;
246		if (copy_len == buffered.len) {
	246	if (copy_len == buffer_contents.len) {
247	247	r.seek = 0;
248	248	r.end = 0;
249	249	}
...	...	@@ -251,7 +251,7 @@ pub fn appendRemaining(
251	251	while (true) {
252	252	try list.ensureUnusedCapacity(gpa, 1);
253	253	const dest = remaining.slice(list.unusedCapacitySlice());
254		const additional_buffer = if (@intFromEnum(remaining) == dest.len) buffer else &.{};
	254	const additional_buffer: []u8 = if (@intFromEnum(remaining) == dest.len) buffer else &.{};
255	255	const n = readVec(r, &.{ dest, additional_buffer }) catch \|err\| switch (err) {
256	256	error.EndOfStream => break,
257	257	error.ReadFailed => return error.ReadFailed,
...	...	@@ -276,7 +276,7 @@ pub fn appendRemaining(
276	276	/// The reader's internal logical seek position moves forward in accordance
277	277	/// with the number of bytes returned from this function.
278	278	pub fn readVec(r: *Reader, data: []const []u8) Error!usize {
279		return readVec(r, data, .unlimited);
	279	return readVecLimit(r, data, .unlimited);
280	280	}
281	281
282	282	/// Equivalent to `readVec` but reads at most `limit` bytes.
...	...	@@ -290,9 +290,9 @@ pub fn readVecLimit(r: *Reader, data: []const []u8, limit: Limit) Error!usize {
290	290	comptime assert(@intFromEnum(Limit.unlimited) == std.math.maxInt(usize));
291	291	var remaining = @intFromEnum(limit);
292	292	for (data, 0..) \|buf, i\| {
293		const buffered = r.buffer[r.seek..r.end];
294		const copy_len = @min(buffered.len, buf.len, remaining);
295		@memcpy(buf[0..copy_len], buffered[0..copy_len]);
	293	const buffer_contents = r.buffer[r.seek..r.end];
	294	const copy_len = @min(buffer_contents.len, buf.len, remaining);
	295	@memcpy(buf[0..copy_len], buffer_contents[0..copy_len]);
296	296	r.seek += copy_len;
297	297	remaining -= copy_len;
298	298	if (remaining == 0) break;
...	...	@@ -354,7 +354,7 @@ pub fn readVecLimit(r: *Reader, data: []const []u8, limit: Limit) Error!usize {
354	354	return @intFromEnum(limit) - remaining;
355	355	}
356	356
357		pub fn bufferContents(r: *Reader) []u8 {
	357	pub fn buffered(r: *Reader) []u8 {
358	358	return r.buffer[r.seek..r.end];
359	359	}
360	360

lib/std/io/Writer.zig+137-16

...	...	@@ -57,8 +57,9 @@ pub const VTable = struct {
57	57	/// Copies contents from an open file to the logical sink. `buffer[0..end]`
58	58	/// is consumed first, followed by `limit` bytes from `file_reader`.
59	59	///
60		/// Number of bytes actually written is returned, excluding bytes from
61		/// `buffer`. Bytes from `buffer` are tracked by modifying `end`.
	60	/// Number of bytes logically written is returned. This excludes bytes from
	61	/// `buffer` because they have already been logically written. Number of
	62	/// bytes consumed from `buffer` are tracked by modifying `end`.
62	63	///
63	64	/// Number of bytes returned may be zero, which does not necessarily mean
64	65	/// end-of-stream. A subsequent call may return nonzero, or signal end of
...	...	@@ -162,7 +163,11 @@ pub fn writeSplat(w: *Writer, data: []const []const u8, splat: usize) Error!usiz
162	163	assert(data.len > 0);
163	164	const buffer = w.buffer;
164	165	const count = countSplat(0, data, splat);
165		if (w.end + count > buffer.len) return w.vtable.drain(w, data, splat);
	166	if (w.end + count > buffer.len) {
	167	const n = try w.vtable.drain(w, data, splat);
	168	w.count += n;
	169	return n;
	170	}
166	171	w.count += count;
167	172	for (data) \|bytes\| {
168	173	@memcpy(buffer[w.end..][0..bytes.len], bytes);
...	...	@@ -213,6 +218,18 @@ pub fn flush(w: *Writer) Error!void {
213	218	assert(0 == try w.vtable.drain(w, &.{}, 0));
214	219	}
215	220
	221	/// Calls `VTable.drain` but hides the last `preserve_length` bytes from the
	222	/// implementation, keeping them buffered.
	223	pub fn drainLimited(w: *Writer, preserve_length: usize) Error!void {
	224	const temp_end = w.end -\| preserve_length;
	225	const preserved = w.buffer[temp_end..w.end];
	226	w.end = temp_end;
	227	defer w.end += preserved.len;
	228	assert(0 == try w.vtable.drain(w, &.{""}, 1));
	229	assert(w.end <= temp_end + preserved.len);
	230	@memmove(w.buffer[w.end..][0..preserved.len], preserved);
	231	}
	232
216	233	pub fn unusedCapacitySlice(w: *const Writer) []u8 {
217	234	return w.buffer[w.end..];
218	235	}
...	...	@@ -246,13 +263,30 @@ pub fn writableSlice(w: *Writer, len: usize) Error![]u8 {
246	263	/// If `minimum_length` is zero, this is equivalent to `unusedCapacitySlice`.
247	264	pub fn writableSliceGreedy(w: *Writer, minimum_length: usize) Error![]u8 {
248	265	assert(w.buffer.len >= minimum_length);
249		while (true) {
250		const cap_slice = w.buffer[w.end..];
251		if (cap_slice.len >= minimum_length) {
252		@branchHint(.likely);
253		return cap_slice;
254		}
	266	while (w.buffer.len - w.end < minimum_length) {
255	267	assert(0 == try w.vtable.drain(w, &.{""}, 1));
	268	} else {
	269	@branchHint(.likely);
	270	return w.buffer[w.end..];
	271	}
	272	}
	273
	274	/// Asserts the provided buffer has total capacity enough for `minimum_length`
	275	/// and `preserve_length` combined.
	276	///
	277	/// Does not `advance` the buffer end position.
	278	///
	279	/// When draining the buffer, ensures that at least `preserve_length` bytes
	280	/// remain buffered.
	281	///
	282	/// If `preserve_length` is zero, this is equivalent to `writableSliceGreedy`.
	283	pub fn writableSliceGreedyPreserving(w: *Writer, preserve_length: usize, minimum_length: usize) Error![]u8 {
	284	assert(w.buffer.len >= preserve_length + minimum_length);
	285	while (w.buffer.len - w.end < minimum_length) {
	286	try drainLimited(w, preserve_length);
	287	} else {
	288	@branchHint(.likely);
	289	return w.buffer[w.end..];
256	290	}
257	291	}
258	292
...	...	@@ -376,20 +410,56 @@ pub fn write(w: *Writer, bytes: []const u8) Error!usize {
376	410	w.count += bytes.len;
377	411	return bytes.len;
378	412	}
379		return w.vtable.drain(w, &.{bytes}, 1);
	413	const n = try w.vtable.drain(w, &.{bytes}, 1);
	414	w.count += n;
	415	return n;
	416	}
	417
	418	/// Asserts `buffer` capacity exceeds `preserve_length`.
	419	pub fn writePreserving(w: *Writer, preserve_length: usize, bytes: []const u8) Error!usize {
	420	assert(preserve_length <= w.buffer.len);
	421	if (w.end + bytes.len <= w.buffer.len) {
	422	@branchHint(.likely);
	423	@memcpy(w.buffer[w.end..][0..bytes.len], bytes);
	424	w.end += bytes.len;
	425	w.count += bytes.len;
	426	return bytes.len;
	427	}
	428	const temp_end = w.end -\| preserve_length;
	429	const preserved = w.buffer[temp_end..w.end];
	430	w.end = temp_end;
	431	defer w.end += preserved.len;
	432	const n = try w.vtable.drain(w, &.{bytes}, 1);
	433	w.count += n;
	434	assert(w.end <= temp_end + preserved.len);
	435	@memmove(w.buffer[w.end..][0..preserved.len], preserved);
	436	return n;
380	437	}
381	438
382		/// Calls `write` as many times as necessary such that all of `bytes` are
	439	/// Calls `drain` as many times as necessary such that all of `bytes` are
383	440	/// transferred.
384	441	pub fn writeAll(w: *Writer, bytes: []const u8) Error!void {
385	442	var index: usize = 0;
386	443	while (index < bytes.len) index += try w.write(bytes[index..]);
387	444	}
388	445
	446	/// Calls `drain` as many times as necessary such that all of `bytes` are
	447	/// transferred.
	448	///
	449	/// When draining the buffer, ensures that at least `preserve_length` bytes
	450	/// remain buffered.
	451	///
	452	/// Asserts `buffer` capacity exceeds `preserve_length`.
	453	pub fn writeAllPreserving(w: *Writer, preserve_length: usize, bytes: []const u8) Error!void {
	454	var index: usize = 0;
	455	while (index < bytes.len) index += try w.writePreserving(preserve_length, bytes[index..]);
	456	}
	457
389	458	pub fn print(w: *Writer, comptime format: []const u8, args: anytype) Error!void {
390	459	try std.fmt.format(w, format, args);
391	460	}
392	461
	462	/// Calls `drain` as many times as necessary such that `byte` is transferred.
393	463	pub fn writeByte(w: *Writer, byte: u8) Error!void {
394	464	while (w.buffer.len - w.end == 0) {
395	465	const n = try w.vtable.drain(w, &.{&.{byte}}, 1);
...	...	@@ -405,6 +475,19 @@ pub fn writeByte(w: *Writer, byte: u8) Error!void {
405	475	}
406	476	}
407	477
	478	/// When draining the buffer, ensures that at least `preserve_length` bytes
	479	/// remain buffered.
	480	pub fn writeBytePreserving(w: *Writer, preserve_length: usize, byte: u8) Error!void {
	481	while (w.buffer.len - w.end == 0) {
	482	try drainLimited(w, preserve_length);
	483	} else {
	484	@branchHint(.likely);
	485	w.buffer[w.end] = byte;
	486	w.end += 1;
	487	w.count += 1;
	488	}
	489	}
	490
408	491	/// Writes the same byte many times, performing the underlying write call as
409	492	/// many times as necessary.
410	493	pub fn splatByteAll(w: *Writer, byte: u8, n: usize) Error!void {
...	...	@@ -496,9 +579,43 @@ pub fn writeSliceSwap(w: *Writer, Elem: type, slice: []const Elem) Error!void {
496	579	/// See `sendFileReading` for an alternative that does not have
497	580	/// `error.Unimplemented` in the error set.
498	581	pub fn sendFile(w: Writer, file_reader: File.Reader, limit: Limit) FileError!usize {
499		const end = w.end;
500		const n = try w.vtable.sendFile(w, file_reader, limit);
501		return n -\| end;
	582	return w.vtable.sendFile(w, file_reader, limit);
	583	}
	584
	585	/// Forwards a `sendFile` to a second `Writer` instance. `w` is only used for
	586	/// its buffer, but it has its `end` and `count` adjusted accordingly depending
	587	/// on how much was consumed.
	588	///
	589	/// Returns how many bytes from `file_reader` were consumed.
	590	pub fn sendFileTo(w: Writer, other: Writer, file_reader: *File.Reader, limit: Limit) FileError!usize {
	591	const header = w.buffered();
	592	const new_end = other.end + header.len;
	593	if (new_end <= other.buffer.len) {
	594	@memcpy(other.buffer[other.end..][0..header.len], header);
	595	other.end = new_end;
	596	w.end = 0;
	597	return other.vtable.sendFile(other, file_reader, limit);
	598	}
	599	assert(header.len > 0);
	600	var vec_buf: [2][]const u8 = .{ header, undefined };
	601	var vec_i: usize = 1;
	602	const buffered_contents = limit.slice(file_reader.buffered());
	603	if (buffered_contents.len > 0) {
	604	vec_buf[vec_i] = buffered_contents;
	605	vec_i += 1;
	606	}
	607	const n = try other.vtable.drain(other, vec_buf[0..vec_i], 1);
	608	other.count += n;
	609	if (n < header.len) {
	610	const remaining = w.buffer[n..w.end];
	611	@memmove(w.buffer[0..remaining.len], remaining);
	612	w.end = remaining.len;
	613	return 0;
	614	}
	615	w.end = 0;
	616	const tossed = n - header.len;
	617	file_reader.interface.toss(tossed);
	618	return tossed;
502	619	}
503	620
504	621	/// Asserts nonzero buffer capacity.
...	...	@@ -1696,8 +1813,12 @@ pub fn discardingSendFile(w: Writer, file_reader: File.Reader, limit: Limit) F
1696	1813	}
1697	1814	}
1698	1815
1699		/// This function is used by `VTable.drain` function implementations to
1700		/// implement partial drains.
	1816	/// Removes the first `n` bytes from `buffer` by shifting buffer contents,
	1817	/// returning how many bytes are left after consuming the entire buffer, or
	1818	/// zero if the entire buffer was not consumed.
	1819	///
	1820	/// Useful for `VTable.drain` function implementations to implement partial
	1821	/// drains.
1701	1822	pub fn consume(w: *Writer, n: usize) usize {
1702	1823	if (n < w.end) {
1703	1824	const remaining = w.buffer[n..w.end];

lib/std/net.zig+1-1

...	...	@@ -2093,7 +2093,7 @@ pub const Stream = struct {
2093	2093	},
2094	2094	.buffer = buffer,
2095	2095	},
2096		.file_writer = .initMode(stream.handle, &.{}, .streaming),
	2096	.file_writer = .initMode(.{ .handle = stream.handle }, &.{}, .streaming),
2097	2097	};
2098	2098	}
2099	2099

author	Andrew Kelley <andrew@ziglang.org> 2025-06-23 15:19:50-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2025-07-01 16:35:30-07:00
log	837f2bfc697c604b0d16d789b4ca2752f58b0ed5
tree	12b1b4957144957d3840327b90cf409a6328e1e5
parent	af24e722fba2245d50473dc7a6fb7671851e07dc

hello world compiling again