Commit 0a1a738320219961c0809a92ac7607a5525aa33e | zig

lib/compiler/aro/aro/Driver.zig+12-12

...	...	@@ -585,6 +585,8 @@ pub fn errorDescription(e: anyerror) []const u8 {
585	585	};
586	586	}
587	587
	588	var stdout_buffer: [4096]u8 = undefined;
	589
588	590	/// The entry point of the Aro compiler.
589	591	/// MAY call `exit` if `fast_exit` is set.
590	592	pub fn main(d: Driver, tc: Toolchain, args: []const []const u8, comptime fast_exit: bool) !void {
...	...	@@ -688,13 +690,13 @@ fn processSource(
688	690	else
689	691	std.fs.File.stdout();
690	692	defer if (d.output_name != null) file.close();
	693	var file_buffer: [1024]u8 = undefined;
	694	var file_writer = file.writer(&file_buffer);
691	695
692		var buf_w = std.io.bufferedWriter(file.deprecatedWriter());
693
694		pp.prettyPrintTokens(buf_w.writer(), dump_mode) catch \|er\|
	696	pp.prettyPrintTokens(&file_writer.interface, dump_mode) catch \|er\|
695	697	return d.fatal("unable to write result: {s}", .{errorDescription(er)});
696	698
697		buf_w.flush() catch \|er\|
	699	file_writer.interface.flush() catch \|er\|
698	700	return d.fatal("unable to write result: {s}", .{errorDescription(er)});
699	701	if (fast_exit) std.process.exit(0); // Not linking, no need for cleanup.
700	702	return;
...	...	@@ -704,10 +706,9 @@ fn processSource(
704	706	defer tree.deinit();
705	707
706	708	if (d.verbose_ast) {
707		const stdout = std.fs.File.stdout();
708		var buf_writer = std.io.bufferedWriter(stdout.deprecatedWriter());
709		tree.dump(d.detectConfig(stdout), buf_writer.writer()) catch {};
710		buf_writer.flush() catch {};
	709	var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
	710	tree.dump(d.detectConfig(.stdout()), &stdout_writer.interface) catch {};
	711	stdout_writer.interface.flush() catch {};
711	712	}
712	713
713	714	const prev_errors = d.comp.diagnostics.errors;
...	...	@@ -734,10 +735,9 @@ fn processSource(
734	735	defer ir.deinit(d.comp.gpa);
735	736
736	737	if (d.verbose_ir) {
737		const stdout = std.fs.File.stdout();
738		var buf_writer = std.io.bufferedWriter(stdout.deprecatedWriter());
739		ir.dump(d.comp.gpa, d.detectConfig(stdout), buf_writer.writer()) catch {};
740		buf_writer.flush() catch {};
	738	var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
	739	ir.dump(d.comp.gpa, d.detectConfig(.stdout()), &stdout_writer.interface) catch {};
	740	stdout_writer.interface.flush() catch {};
741	741	}
742	742
743	743	var render_errors: Ir.Renderer.ErrorList = .{};

lib/compiler/aro/aro/Preprocessor.zig+3-4

...	...	@@ -811,10 +811,9 @@ fn verboseLog(pp: *Preprocessor, raw: RawToken, comptime fmt: []const u8, args:
811	811	const source = pp.comp.getSource(raw.source);
812	812	const line_col = source.lineCol(.{ .id = raw.source, .line = raw.line, .byte_offset = raw.start });
813	813
814		const stderr = std.fs.File.stderr().deprecatedWriter();
815		var buf_writer = std.io.bufferedWriter(stderr);
816		const writer = buf_writer.writer();
817		defer buf_writer.flush() catch {};
	814	var stderr_buffer: [64]u8 = undefined;
	815	var writer = std.debug.lockStderrWriter(&stderr_buffer);
	816	defer std.debug.unlockStderrWriter();
818	817	writer.print("{s}:{d}:{d}: ", .{ source.path, line_col.line_no, line_col.col }) catch return;
819	818	writer.print(fmt, args) catch return;
820	819	writer.writeByte('\n') catch return;

lib/compiler/aro/backend/Object/Elf.zig+4-3

...	...	@@ -171,8 +171,9 @@ pub fn addRelocation(elf: *Elf, name: []const u8, section_kind: Object.Section,
171	171	/// strtab
172	172	/// section headers
173	173	pub fn finish(elf: *Elf, file: std.fs.File) !void {
174		var buf_writer = std.io.bufferedWriter(file.deprecatedWriter());
175		const w = buf_writer.writer();
	174	var file_buffer: [1024]u8 = undefined;
	175	var file_writer = file.writer(&file_buffer);
	176	const w = &file_writer.interface;
176	177
177	178	var num_sections: std.elf.Elf64_Half = additional_sections;
178	179	var relocations_len: std.elf.Elf64_Off = 0;
...	...	@@ -374,5 +375,5 @@ pub fn finish(elf: *Elf, file: std.fs.File) !void {
374	375	name_offset += @as(u32, @intCast(entry.key_ptr.len + ".\x00".len)) + rela_name_offset;
375	376	}
376	377	}
377		try buf_writer.flush();
	378	try w.flush();
378	379	}

lib/compiler/libc.zig+10-9

...	...	@@ -22,6 +22,8 @@ const usage_libc =
22	22	\\
23	23	;
24	24
	25	var stdout_buffer: [4096]u8 = undefined;
	26
25	27	pub fn main() !void {
26	28	var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);
27	29	defer arena_instance.deinit();
...	...	@@ -34,14 +36,16 @@ pub fn main() !void {
34	36	var input_file: ?[]const u8 = null;
35	37	var target_arch_os_abi: []const u8 = "native";
36	38	var print_includes: bool = false;
	39	var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
	40	const stdout = &stdout_writer.interface;
37	41	{
38	42	var i: usize = 2;
39	43	while (i < args.len) : (i += 1) {
40	44	const arg = args[i];
41	45	if (mem.startsWith(u8, arg, "-")) {
42	46	if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {
43		const stdout = std.fs.File.stdout().deprecatedWriter();
44	47	try stdout.writeAll(usage_libc);
	48	try stdout.flush();
45	49	return std.process.cleanExit();
46	50	} else if (mem.eql(u8, arg, "-target")) {
47	51	if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
...	...	@@ -97,13 +101,11 @@ pub fn main() !void {
97	101	fatal("no include dirs detected for target {s}", .{zig_target});
98	102	}
99	103
100		var bw = std.io.bufferedWriter(std.fs.File.stdout().deprecatedWriter());
101		var writer = bw.writer();
102	104	for (libc_dirs.libc_include_dir_list) \|include_dir\| {
103		try writer.writeAll(include_dir);
104		try writer.writeByte('\n');
	105	try stdout.writeAll(include_dir);
	106	try stdout.writeByte('\n');
105	107	}
106		try bw.flush();
	108	try stdout.flush();
107	109	return std.process.cleanExit();
108	110	}
109	111
...	...	@@ -125,9 +127,8 @@ pub fn main() !void {
125	127	};
126	128	defer libc.deinit(gpa);
127	129
128		var bw = std.io.bufferedWriter(std.fs.File.stdout().deprecatedWriter());
129		try libc.render(bw.writer());
130		try bw.flush();
	130	try libc.render(stdout);
	131	try stdout.flush();
131	132	}
132	133	}
133	134

lib/compiler/resinator/compile.zig+17-18

...	...	@@ -1268,12 +1268,8 @@ pub const Compiler = struct {
1268	1268	try header.write(writer, self.errContext(id_token));
1269	1269	}
1270	1270
1271		pub fn writeResourceDataNoPadding(writer: anytype, data_reader: *std.Io.Reader, data_size: u32) !void {
1272		var adapted = writer.adaptToNewApi();
1273		var buffer: [128]u8 = undefined;
1274		adapted.new_interface.buffer = &buffer;
1275		try data_reader.streamExact(&adapted.new_interface, data_size);
1276		try adapted.new_interface.flush();
	1271	pub fn writeResourceDataNoPadding(writer: std.Io.Writer, data_reader: std.Io.Reader, data_size: u32) !void {
	1272	try data_reader.streamExact(writer, data_size);
1277	1273	}
1278	1274
1279	1275	pub fn writeResourceData(writer: anytype, data_reader: *std.Io.Reader, data_size: u32) !void {
...	...	@@ -1281,8 +1277,8 @@ pub const Compiler = struct {
1281	1277	try writeDataPadding(writer, data_size);
1282	1278	}
1283	1279
1284		pub fn writeDataPadding(writer: anytype, data_size: u32) !void {
1285		try writer.writeByteNTimes(0, numPaddingBytesNeeded(data_size));
	1280	pub fn writeDataPadding(writer: *std.Io.Writer, data_size: u32) !void {
	1281	try writer.splatByteAll(0, numPaddingBytesNeeded(data_size));
1286	1282	}
1287	1283
1288	1284	pub fn numPaddingBytesNeeded(data_size: u32) u2 {
...	...	@@ -2100,8 +2096,10 @@ pub const Compiler = struct {
2100	2096	const resource = ResourceType.fromString(type_bytes);
2101	2097	std.debug.assert(resource == .menu or resource == .menuex);
2102	2098
2103		self.writeMenuData(node, data_writer, resource) catch \|err\| switch (err) {
2104		error.NoSpaceLeft => {
	2099	var adapted = data_writer.adaptToNewApi(&.{});
	2100
	2101	self.writeMenuData(node, &adapted.new_interface, resource) catch \|err\| switch (err) {
	2102	error.WriteFailed => {
2105	2103	return self.addErrorDetailsAndFail(.{
2106	2104	.err = .resource_data_size_exceeds_max,
2107	2105	.token = node.id,
...	...	@@ -2129,7 +2127,7 @@ pub const Compiler = struct {
2129	2127
2130	2128	/// Expects `data_writer` to be a LimitedWriter limited to u32, meaning all writes to
2131	2129	/// the writer within this function could return error.NoSpaceLeft
2132		pub fn writeMenuData(self: Compiler, node: Node.Menu, data_writer: anytype, resource: ResourceType) !void {
	2130	pub fn writeMenuData(self: Compiler, node: Node.Menu, data_writer: *std.Io.Writer, resource: ResourceType) !void {
2133	2131	// menu header
2134	2132	const version: u16 = if (resource == .menu) 0 else 1;
2135	2133	try data_writer.writeInt(u16, version, .little);
...	...	@@ -2156,7 +2154,7 @@ pub const Compiler = struct {
2156	2154	}
2157	2155	}
2158	2156
2159		pub fn writeMenuItem(self: Compiler, node: Node, writer: anytype, is_last_of_parent: bool) !void {
	2157	pub fn writeMenuItem(self: Compiler, node: Node, writer: *std.Io.Writer, is_last_of_parent: bool) !void {
2160	2158	switch (node.id) {
2161	2159	.menu_item_separator => {
2162	2160	// This is the 'alternate compability form' of the separator, see
...	...	@@ -2356,8 +2354,9 @@ pub const Compiler = struct {
2356	2354	try fixed_file_info.write(data_writer);
2357	2355
2358	2356	for (node.block_statements) \|statement\| {
2359		self.writeVersionNode(statement, data_writer, &data_buffer) catch \|err\| switch (err) {
2360		error.NoSpaceLeft => {
	2357	var adapted = data_writer.adaptToNewApi(&.{});
	2358	self.writeVersionNode(statement, &adapted.new_interface, &data_buffer) catch \|err\| switch (err) {
	2359	error.WriteFailed => {
2361	2360	try self.addErrorDetails(.{
2362	2361	.err = .version_node_size_exceeds_max,
2363	2362	.token = node.id,
...	...	@@ -2395,7 +2394,7 @@ pub const Compiler = struct {
2395	2394	/// Expects writer to be a LimitedWriter limited to u16, meaning all writes to
2396	2395	/// the writer within this function could return error.NoSpaceLeft, and that buf.items.len
2397	2396	/// will never be able to exceed maxInt(u16).
2398		pub fn writeVersionNode(self: Compiler, node: Node, writer: anytype, buf: *std.ArrayList(u8)) !void {
	2397	pub fn writeVersionNode(self: Compiler, node: Node, writer: std.Io.Writer, buf: std.ArrayList(u8)) !void {
2399	2398	// We can assume that buf.items.len will never be able to exceed the limits of a u16
2400	2399	try writeDataPadding(writer, @as(u16, @intCast(buf.items.len)));
2401	2400
...	...	@@ -2700,12 +2699,12 @@ pub const Compiler = struct {
2700	2699	return self.writeSizeInfo(writer, size_info);
2701	2700	}
2702	2701
2703		pub fn writeSizeInfo(self: ResourceHeader, writer: anytype, size_info: SizeInfo) !void {
	2702	pub fn writeSizeInfo(self: ResourceHeader, writer: *std.Io.Writer, size_info: SizeInfo) !void {
2704	2703	try writer.writeInt(DWORD, self.data_size, .little); // DataSize
2705	2704	try writer.writeInt(DWORD, size_info.bytes, .little); // HeaderSize
2706	2705	try self.type_value.write(writer); // TYPE
2707	2706	try self.name_value.write(writer); // NAME
2708		try writer.writeByteNTimes(0, size_info.padding_after_name);
	2707	try writer.splatByteAll(0, size_info.padding_after_name);
2709	2708
2710	2709	try writer.writeInt(DWORD, self.data_version, .little); // DataVersion
2711	2710	try writer.writeInt(WORD, self.memory_flags.value, .little); // MemoryFlags
...	...	@@ -3120,7 +3119,7 @@ pub const FontDir = struct {
3120	3119	// First, the ID is written, though
3121	3120	try writer.writeInt(u16, font.id, .little);
3122	3121	try writer.writeAll(&font.header_bytes);
3123		try writer.writeByteNTimes(0, 2);
	3122	try writer.splatByteAll(0, 2);
3124	3123	}
3125	3124	try Compiler.writeDataPadding(writer, data_size);
3126	3125	}

lib/compiler/resinator/cvtres.zig+13-13

...	...	@@ -188,7 +188,7 @@ pub const Diagnostics = union {
188	188	overflow_resource: usize,
189	189	};
190	190
191		pub fn writeCoff(allocator: Allocator, writer: anytype, resources: []const Resource, options: CoffOptions, diagnostics: ?*Diagnostics) !void {
	191	pub fn writeCoff(allocator: Allocator, writer: std.Io.Writer, resources: []const Resource, options: CoffOptions, diagnostics: ?Diagnostics) !void {
192	192	var resource_tree = ResourceTree.init(allocator, options);
193	193	defer resource_tree.deinit();
194	194
...	...	@@ -232,7 +232,7 @@ pub fn writeCoff(allocator: Allocator, writer: anytype, resources: []const Resou
232	232	.flags = flags,
233	233	};
234	234
235		try writer.writeStructEndian(coff_header, .little);
	235	try writer.writeStruct(coff_header, .little);
236	236
237	237	const rsrc01_header = std.coff.SectionHeader{
238	238	.name = ".rsrc$01".*,
...	...	@@ -250,7 +250,7 @@ pub fn writeCoff(allocator: Allocator, writer: anytype, resources: []const Resou
250	250	.MEM_READ = 1,
251	251	},
252	252	};
253		try writer.writeStructEndian(rsrc01_header, .little);
	253	try writer.writeStruct(rsrc01_header, .little);
254	254
255	255	const rsrc02_header = std.coff.SectionHeader{
256	256	.name = ".rsrc$02".*,
...	...	@@ -268,7 +268,7 @@ pub fn writeCoff(allocator: Allocator, writer: anytype, resources: []const Resou
268	268	.MEM_READ = 1,
269	269	},
270	270	};
271		try writer.writeStructEndian(rsrc02_header, .little);
	271	try writer.writeStruct(rsrc02_header, .little);
272	272
273	273	// TODO: test surrogate pairs
274	274	try resource_tree.sort();
...	...	@@ -665,13 +665,13 @@ const ResourceTree = struct {
665	665	pub fn writeCoff(
666	666	self: *const ResourceTree,
667	667	allocator: Allocator,
668		w: anytype,
	668	w: *std.Io.Writer,
669	669	resources_in_data_order: []const Resource,
670	670	lengths: Lengths,
671	671	coff_string_table: *StringTable,
672	672	) ![]const std.coff.Symbol {
673	673	if (self.type_to_name_map.count() == 0) {
674		try w.writeByteNTimes(0, 16);
	674	try w.splatByteAll(0, 16);
675	675	return &.{};
676	676	}
677	677
...	...	@@ -710,7 +710,7 @@ const ResourceTree = struct {
710	710	.number_of_id_entries = counts.ids,
711	711	.number_of_name_entries = counts.names,
712	712	};
713		try w.writeStructEndian(table, .little);
	713	try w.writeStruct(table, .little);
714	714
715	715	var it = self.type_to_name_map.iterator();
716	716	while (it.next()) \|entry\| {
...	...	@@ -745,7 +745,7 @@ const ResourceTree = struct {
745	745	.number_of_id_entries = counts.ids,
746	746	.number_of_name_entries = counts.names,
747	747	};
748		try w.writeStructEndian(table, .little);
	748	try w.writeStruct(table, .little);
749	749
750	750	var it = name_to_lang_map.iterator();
751	751	while (it.next()) \|entry\| {
...	...	@@ -786,7 +786,7 @@ const ResourceTree = struct {
786	786	.number_of_id_entries = counts.ids,
787	787	.number_of_name_entries = counts.names,
788	788	};
789		try w.writeStructEndian(table, .little);
	789	try w.writeStruct(table, .little);
790	790
791	791	var it = lang_to_resources_map.iterator();
792	792	while (it.next()) \|entry\| {
...	...	@@ -819,7 +819,7 @@ const ResourceTree = struct {
819	819	.size = @intCast(orig_resource.data.len),
820	820	.codepage = 0,
821	821	};
822		try w.writeStructEndian(data_entry, .little);
	822	try w.writeStruct(data_entry, .little);
823	823	}
824	824
825	825	for (self.rsrc_string_table.keys()) \|v\| {
...	...	@@ -828,7 +828,7 @@ const ResourceTree = struct {
828	828	try w.writeAll(std.mem.sliceAsBytes(str));
829	829	}
830	830
831		try w.writeByteNTimes(0, lengths.padding);
	831	try w.splatByteAll(0, lengths.padding);
832	832
833	833	for (relocations.list.items) \|relocation\| {
834	834	try writeRelocation(w, std.coff.Relocation{
...	...	@@ -842,13 +842,13 @@ const ResourceTree = struct {
842	842	for (self.deduplicated_data.keys()) \|data\| {
843	843	const padding_bytes: u4 = @intCast((8 -% data.len) % 8);
844	844	try w.writeAll(data);
845		try w.writeByteNTimes(0, padding_bytes);
	845	try w.splatByteAll(0, padding_bytes);
846	846	}
847	847	} else {
848	848	for (resources_in_data_order) \|resource\| {
849	849	const padding_bytes: u4 = @intCast((8 -% resource.data.len) % 8);
850	850	try w.writeAll(resource.data);
851		try w.writeByteNTimes(0, padding_bytes);
	851	try w.splatByteAll(0, padding_bytes);
852	852	}
853	853	}
854	854

lib/compiler/resinator/main.zig+8-6

...	...	@@ -248,10 +248,11 @@ pub fn main() !void {
248	248	var diagnostics = Diagnostics.init(allocator);
249	249	defer diagnostics.deinit();
250	250
251		const res_stream_writer = res_stream.source.writer(allocator);
252		var output_buffered_stream = std.io.bufferedWriter(res_stream_writer);
	251	var output_buffer: [4096]u8 = undefined;
	252	var res_stream_writer = res_stream.source.writer(allocator).adaptToNewApi(&output_buffer);
	253	const output_buffered_stream = &res_stream_writer.new_interface;
253	254
254		compile(allocator, final_input, output_buffered_stream.writer(), .{
	255	compile(allocator, final_input, output_buffered_stream, .{
255	256	.cwd = std.fs.cwd(),
256	257	.diagnostics = &diagnostics,
257	258	.source_mappings = &mapping_results.mappings,
...	...	@@ -340,10 +341,11 @@ pub fn main() !void {
340	341	};
341	342	defer coff_stream.deinit(allocator);
342	343
343		var coff_output_buffered_stream = std.io.bufferedWriter(coff_stream.source.writer(allocator));
	344	var coff_output_buffer: [4096]u8 = undefined;
	345	var coff_output_buffered_stream = coff_stream.source.writer(allocator).adaptToNewApi(&coff_output_buffer);
344	346
345	347	var cvtres_diagnostics: cvtres.Diagnostics = .{ .none = {} };
346		cvtres.writeCoff(allocator, coff_output_buffered_stream.writer(), resources.list.items, options.coff_options, &cvtres_diagnostics) catch \|err\| {
	348	cvtres.writeCoff(allocator, &coff_output_buffered_stream.new_interface, resources.list.items, options.coff_options, &cvtres_diagnostics) catch \|err\| {
347	349	switch (err) {
348	350	error.DuplicateResource => {
349	351	const duplicate_resource = resources.list.items[cvtres_diagnostics.duplicate_resource];
...	...	@@ -380,7 +382,7 @@ pub fn main() !void {
380	382	std.process.exit(1);
381	383	};
382	384
383		try coff_output_buffered_stream.flush();
	385	try coff_output_buffered_stream.new_interface.flush();
384	386	}
385	387
386	388	const IoStream = struct {

lib/compiler/std-docs.zig+8-11

...	...	@@ -93,9 +93,12 @@ pub fn main() !void {
93	93	fn accept(context: *Context, connection: std.net.Server.Connection) void {
94	94	defer connection.stream.close();
95	95
96		var read_buffer: [8000]u8 = undefined;
97		var server = std.http.Server.init(connection, &read_buffer);
98		while (server.state == .ready) {
	96	var recv_buffer: [4000]u8 = undefined;
	97	var send_buffer: [4000]u8 = undefined;
	98	var conn_reader = connection.stream.reader(&recv_buffer);
	99	var conn_writer = connection.stream.writer(&send_buffer);
	100	var server = std.http.Server.init(conn_reader.interface(), &conn_writer.interface);
	101	while (server.reader.state == .ready) {
99	102	var request = server.receiveHead() catch \|err\| switch (err) {
100	103	error.HttpConnectionClosing => return,
101	104	else => {
...	...	@@ -175,8 +178,7 @@ fn serveSourcesTar(request: std.http.Server.Request, context: Context) !void {
175	178	const gpa = context.gpa;
176	179
177	180	var send_buffer: [0x4000]u8 = undefined;
178		var response = request.respondStreaming(.{
179		.send_buffer = &send_buffer,
	181	var response = try request.respondStreaming(&send_buffer, .{
180	182	.respond_options = .{
181	183	.extra_headers = &.{
182	184	.{ .name = "content-type", .value = "application/x-tar" },
...	...	@@ -191,11 +193,7 @@ fn serveSourcesTar(request: std.http.Server.Request, context: Context) !void {
191	193	var walker = try std_dir.walk(gpa);
192	194	defer walker.deinit();
193	195
194		var adapter_buffer: [500]u8 = undefined;
195		var response_writer = response.writer().adaptToNewApi();
196		response_writer.new_interface.buffer = &adapter_buffer;
197
198		var archiver: std.tar.Writer = .{ .underlying_writer = &response_writer.new_interface };
	196	var archiver: std.tar.Writer = .{ .underlying_writer = &response.writer };
199	197	archiver.prefix = "std";
200	198
201	199	while (try walker.next()) \|entry\| {
...	...	@@ -229,7 +227,6 @@ fn serveSourcesTar(request: std.http.Server.Request, context: Context) !void {
229	227
230	228	// intentionally omitting the pointless trailer
231	229	//try archiver.finish();
232		try response_writer.new_interface.flush();
233	230	try response.end();
234	231	}
235	232

lib/docs/wasm/markdown.zig+4-3

...	...	@@ -159,9 +159,10 @@ fn mainImpl() !void {
159	159	var doc = try parser.endInput();
160	160	defer doc.deinit(gpa);
161	161
162		var stdout_buf = std.io.bufferedWriter(std.fs.File.stdout().deprecatedWriter());
163		try doc.render(stdout_buf.writer());
164		try stdout_buf.flush();
	162	var stdout_buffer: [1024]u8 = undefined;
	163	var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
	164	try doc.render(&stdout_writer.interface);
	165	try stdout_writer.interface.flush();
165	166	}
166	167
167	168	test "empty document" {

lib/init/src/root.zig+4-5

...	...	@@ -5,14 +5,13 @@ pub fn bufferedPrint() !void {
5	5	// Stdout is for the actual output of your application, for example if you
6	6	// are implementing gzip, then only the compressed bytes should be sent to
7	7	// stdout, not any debugging messages.
8		const stdout_file = std.fs.File.stdout().deprecatedWriter();
9		// Buffering can improve performance significantly in print-heavy programs.
10		var bw = std.io.bufferedWriter(stdout_file);
11		const stdout = bw.writer();
	8	var stdout_buffer: [1024]u8 = undefined;
	9	var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
	10	const stdout = &stdout_writer.interface;
12	11
13	12	try stdout.print("Run `zig build test` to run the tests.\n", .{});
14	13
15		try bw.flush(); // Don't forget to flush!
	14	try stdout.flush(); // Don't forget to flush!
16	15	}
17	16
18	17	pub fn add(a: i32, b: i32) i32 {

lib/std/Io.zig+2-7

...	...	@@ -387,11 +387,11 @@ pub fn GenericWriter(
387	387	}
388	388
389	389	/// Helper for bridging to the new `Writer` API while upgrading.
390		pub fn adaptToNewApi(self: *const Self) Adapter {
	390	pub fn adaptToNewApi(self: *const Self, buffer: []u8) Adapter {
391	391	return .{
392	392	.derp_writer = self.*,
393	393	.new_interface = .{
394		.buffer = &.{},
	394	.buffer = buffer,
395	395	.vtable = &.{ .drain = Adapter.drain },
396	396	},
397	397	};
...	...	@@ -423,10 +423,6 @@ pub fn GenericWriter(
423	423	pub const AnyReader = @import("Io/DeprecatedReader.zig");
424	424	/// Deprecated in favor of `Writer`.
425	425	pub const AnyWriter = @import("Io/DeprecatedWriter.zig");
426		/// Deprecated in favor of `Writer`.
427		pub const BufferedWriter = @import("Io/buffered_writer.zig").BufferedWriter;
428		/// Deprecated in favor of `Writer`.
429		pub const bufferedWriter = @import("Io/buffered_writer.zig").bufferedWriter;
430	426	/// Deprecated in favor of `Reader`.
431	427	pub const FixedBufferStream = @import("Io/fixed_buffer_stream.zig").FixedBufferStream;
432	428	/// Deprecated in favor of `Reader`.
...	...	@@ -912,7 +908,6 @@ pub fn PollFiles(comptime StreamEnum: type) type {
912	908	test {
913	909	_ = Reader;
914	910	_ = Writer;
915		_ = BufferedWriter;
916	911	_ = CountingReader;
917	912	_ = FixedBufferStream;
918	913	_ = tty;

lib/std/Io/DeprecatedWriter.zig+2-2

...	...	@@ -83,11 +83,11 @@ pub fn writeFile(self: Self, file: std.fs.File) anyerror!void {
83	83	}
84	84
85	85	/// Helper for bridging to the new `Writer` API while upgrading.
86		pub fn adaptToNewApi(self: *const Self) Adapter {
	86	pub fn adaptToNewApi(self: *const Self, buffer: []u8) Adapter {
87	87	return .{
88	88	.derp_writer = self.*,
89	89	.new_interface = .{
90		.buffer = &.{},
	90	.buffer = buffer,
91	91	.vtable = &.{ .drain = Adapter.drain },
92	92	},
93	93	};

lib/std/Io/buffered_writer.zig deleted-43

...	...	@@ -1,43 +0,0 @@
1		const std = @import("../std.zig");
2
3		const io = std.io;
4		const mem = std.mem;
5
6		pub fn BufferedWriter(comptime buffer_size: usize, comptime WriterType: type) type {
7		return struct {
8		unbuffered_writer: WriterType,
9		buf: [buffer_size]u8 = undefined,
10		end: usize = 0,
11
12		pub const Error = WriterType.Error;
13		pub const Writer = io.GenericWriter(*Self, Error, write);
14
15		const Self = @This();
16
17		pub fn flush(self: *Self) !void {
18		try self.unbuffered_writer.writeAll(self.buf[0..self.end]);
19		self.end = 0;
20		}
21
22		pub fn writer(self: *Self) Writer {
23		return .{ .context = self };
24		}
25
26		pub fn write(self: *Self, bytes: []const u8) Error!usize {
27		if (self.end + bytes.len > self.buf.len) {
28		try self.flush();
29		if (bytes.len > self.buf.len)
30		return self.unbuffered_writer.write(bytes);
31		}
32
33		const new_end = self.end + bytes.len;
34		@memcpy(self.buf[self.end..new_end], bytes);
35		self.end = new_end;
36		return bytes.len;
37		}
38		};
39		}
40
41		pub fn bufferedWriter(underlying_stream: anytype) BufferedWriter(4096, @TypeOf(underlying_stream)) {
42		return .{ .unbuffered_writer = underlying_stream };
43		}

lib/std/Io/test.zig+4-4

...	...	@@ -24,12 +24,12 @@ test "write a file, read it, then delete it" {
24	24	var file = try tmp.dir.createFile(tmp_file_name, .{});
25	25	defer file.close();
26	26
27		var buf_stream = io.bufferedWriter(file.deprecatedWriter());
28		const st = buf_stream.writer();
	27	var file_writer = file.writer(&.{});
	28	const st = &file_writer.interface;
29	29	try st.print("begin", .{});
30		try st.writeAll(data[0..]);
	30	try st.writeAll(&data);
31	31	try st.print("end", .{});
32		try buf_stream.flush();
	32	try st.flush();
33	33	}
34	34
35	35	{

lib/std/fmt.zig+1-1

...	...	@@ -80,7 +80,7 @@ pub const Number = struct {
80	80
81	81	/// Deprecated in favor of `Writer.print`.
82	82	pub fn format(writer: anytype, comptime fmt: []const u8, args: anytype) !void {
83		var adapter = writer.adaptToNewApi();
	83	var adapter = writer.adaptToNewApi(&.{});
84	84	return adapter.new_interface.print(fmt, args) catch \|err\| switch (err) {
85	85	error.WriteFailed => return adapter.err.?,
86	86	};

lib/std/zig/LibCInstallation.zig+1-1

...	...	@@ -109,7 +109,7 @@ pub fn parse(
109	109	return self;
110	110	}
111	111
112		pub fn render(self: LibCInstallation, out: anytype) !void {
	112	pub fn render(self: LibCInstallation, out: *std.Io.Writer) !void {
113	113	@setEvalBranchQuota(4000);
114	114	const include_dir = self.include_dir orelse "";
115	115	const sys_include_dir = self.sys_include_dir orelse "";

src/Package/Fetch.zig+5-11

...	...	@@ -1631,19 +1631,13 @@ fn computeHash(f: *Fetch, pkg_path: Cache.Path, filter: Filter) RunError!Compute
1631	1631	}
1632	1632
1633	1633	fn dumpHashInfo(all_files: []const *const HashedFile) !void {
1634		const stdout: std.fs.File = .stdout();
1635		var bw = std.io.bufferedWriter(stdout.deprecatedWriter());
1636		const w = bw.writer();
1637
	1634	var stdout_buffer: [1024]u8 = undefined;
	1635	var stdout_writer: fs.File.Writer = .initMode(.stdout(), &stdout_buffer, .streaming);
	1636	const w = &stdout_writer.interface;
1638	1637	for (all_files) \|hashed_file\| {
1639		try w.print("{s}: {x}: {s}\n", .{
1640		@tagName(hashed_file.kind),
1641		&hashed_file.hash,
1642		hashed_file.normalized_path,
1643		});
	1638	try w.print("{t}: {x}: {s}\n", .{ hashed_file.kind, &hashed_file.hash, hashed_file.normalized_path });
1644	1639	}
1645
1646		try bw.flush();
	1640	try w.flush();
1647	1641	}
1648	1642
1649	1643	fn workerHashFile(dir: fs.Dir, hashed_file: *HashedFile) void {

src/link/Lld.zig+4-3

...	...	@@ -1662,8 +1662,9 @@ fn spawnLld(
1662	1662	log.warn("failed to delete response file {s}: {s}", .{ rsp_path, @errorName(err) });
1663	1663	{
1664	1664	defer rsp_file.close();
1665		var rsp_buf = std.io.bufferedWriter(rsp_file.deprecatedWriter());
1666		const rsp_writer = rsp_buf.writer();
	1665	var rsp_file_buffer: [1024]u8 = undefined;
	1666	var rsp_file_writer = rsp_file.writer(&rsp_file_buffer);
	1667	const rsp_writer = &rsp_file_writer.interface;
1667	1668	for (argv[2..]) \|arg\| {
1668	1669	try rsp_writer.writeByte('"');
1669	1670	for (arg) \|c\| {
...	...	@@ -1676,7 +1677,7 @@ fn spawnLld(
1676	1677	try rsp_writer.writeByte('"');
1677	1678	try rsp_writer.writeByte('\n');
1678	1679	}
1679		try rsp_buf.flush();
	1680	try rsp_writer.flush();
1680	1681	}
1681	1682
1682	1683	var rsp_child = std.process.Child.init(&.{ argv[0], argv[1], try std.fmt.allocPrint(

tools/docgen.zig+4-4

...	...	@@ -70,19 +70,19 @@ pub fn main() !void {
70	70
71	71	var out_file = try fs.cwd().createFile(output_path, .{});
72	72	defer out_file.close();
	73	var out_file_buffer: [4096]u8 = undefined;
	74	var out_file_writer = out_file.writer(&out_file_buffer);
73	75
74	76	var code_dir = try fs.cwd().openDir(code_dir_path, .{});
75	77	defer code_dir.close();
76	78
77	79	const input_file_bytes = try in_file.deprecatedReader().readAllAlloc(arena, max_doc_file_size);
78	80
79		var buffered_writer = io.bufferedWriter(out_file.deprecatedWriter());
80
81	81	var tokenizer = Tokenizer.init(input_path, input_file_bytes);
82	82	var toc = try genToc(arena, &tokenizer);
83	83
84		try genHtml(arena, &tokenizer, &toc, code_dir, buffered_writer.writer());
85		try buffered_writer.flush();
	84	try genHtml(arena, &tokenizer, &toc, code_dir, &out_file_writer.interface);
	85	try out_file_writer.end();
86	86	}
87	87
88	88	const Token = struct {

tools/doctest.zig+4-3

...	...	@@ -84,9 +84,10 @@ pub fn main() !void {
84	84
85	85	var out_file = try fs.cwd().createFile(output_path, .{});
86	86	defer out_file.close();
	87	var out_file_buffer: [4096]u8 = undefined;
	88	var out_file_writer = out_file.writer(&out_file_buffer);
87	89
88		var bw = std.io.bufferedWriter(out_file.deprecatedWriter());
89		const out = bw.writer();
	90	const out = &out_file_writer.interface;
90	91
91	92	try printSourceBlock(arena, out, source, fs.path.basename(input_path));
92	93	try printOutput(
...	...	@@ -102,7 +103,7 @@ pub fn main() !void {
102	103	null,
103	104	);
104	105
105		try bw.flush();
	106	try out_file_writer.end();
106	107	}
107	108
108	109	fn printOutput(

tools/gen_spirv_spec.zig+1-1

...	...	@@ -84,7 +84,7 @@ pub fn main() !void {
84	84
85	85	const output_buf = try allocator.alloc(u8, 1024 * 1024);
86	86	var fbs = std.io.fixedBufferStream(output_buf);
87		var adapter = fbs.writer().adaptToNewApi();
	87	var adapter = fbs.writer().adaptToNewApi(&.{});
88	88	const w = &adapter.new_interface;
89	89	try render(w, core_spec, exts.items);
90	90	var output: [:0]u8 = @ptrCast(fbs.getWritten());

tools/migrate_langref.zig+4-4

...	...	@@ -23,19 +23,19 @@ pub fn main() !void {
23	23
24	24	var out_file = try fs.cwd().createFile(output_file, .{});
25	25	defer out_file.close();
	26	var out_file_buffer: [4096]u8 = undefined;
	27	var out_file_writer = out_file.writer(&out_file_buffer);
26	28
27	29	var out_dir = try fs.cwd().openDir(fs.path.dirname(output_file).?, .{});
28	30	defer out_dir.close();
29	31
30	32	const input_file_bytes = try in_file.deprecatedReader().readAllAlloc(arena, std.math.maxInt(u32));
31	33
32		var buffered_writer = io.bufferedWriter(out_file.deprecatedWriter());
33
34	34	var tokenizer = Tokenizer.init(input_file, input_file_bytes);
35	35
36		try walk(arena, &tokenizer, out_dir, buffered_writer.writer());
	36	try walk(arena, &tokenizer, out_dir, &out_file_writer.interface);
37	37
38		try buffered_writer.flush();
	38	try out_file_writer.end();
39	39	}
40	40
41	41	const Token = struct {

tools/update_cpu_features.zig+4-3

...	...	@@ -1906,8 +1906,9 @@ fn processOneTarget(job: Job) void {
1906	1906	var zig_code_file = try target_dir.createFile(zig_code_basename, .{});
1907	1907	defer zig_code_file.close();
1908	1908
1909		var bw = std.io.bufferedWriter(zig_code_file.deprecatedWriter());
1910		const w = bw.writer();
	1909	var zig_code_file_buffer: [4096]u8 = undefined;
	1910	var zig_code_file_writer = zig_code_file.writer(&zig_code_file_buffer);
	1911	const w = &zig_code_file_writer.interface;
1911	1912
1912	1913	try w.writeAll(
1913	1914	\\//! This file is auto-generated by tools/update_cpu_features.zig.
...	...	@@ -2076,7 +2077,7 @@ fn processOneTarget(job: Job) void {
2076	2077	\\};
2077	2078	\\
2078	2079	);
2079		try bw.flush();
	2080	try w.flush();
2080	2081
2081	2082	render_progress.end();
2082	2083	}

tools/update_crc_catalog.zig+9-8

...	...	@@ -29,10 +29,9 @@ pub fn main() anyerror!void {
29	29
30	30	var zig_code_file = try hash_target_dir.createFile("crc.zig", .{});
31	31	defer zig_code_file.close();
32
33		var cbw = std.io.bufferedWriter(zig_code_file.deprecatedWriter());
34		defer cbw.flush() catch unreachable;
35		const code_writer = cbw.writer();
	32	var zig_code_file_buffer: [4096]u8 = undefined;
	33	var zig_code_file_writer = zig_code_file.writer(&zig_code_file_buffer);
	34	const code_writer = &zig_code_file_writer.interface;
36	35
37	36	try code_writer.writeAll(
38	37	\\//! This file is auto-generated by tools/update_crc_catalog.zig.
...	...	@@ -54,10 +53,9 @@ pub fn main() anyerror!void {
54	53
55	54	var zig_test_file = try crc_target_dir.createFile("test.zig", .{});
56	55	defer zig_test_file.close();
57
58		var tbw = std.io.bufferedWriter(zig_test_file.deprecatedWriter());
59		defer tbw.flush() catch unreachable;
60		const test_writer = tbw.writer();
	56	var zig_test_file_buffer: [4096]u8 = undefined;
	57	var zig_test_file_writer = zig_test_file.writer(&zig_test_file_buffer);
	58	const test_writer = &zig_test_file_writer.interface;
61	59
62	60	try test_writer.writeAll(
63	61	\\//! This file is auto-generated by tools/update_crc_catalog.zig.
...	...	@@ -187,6 +185,9 @@ pub fn main() anyerror!void {
187	185	\\
188	186	, .{ name, camelcase, width, check }));
189	187	}
	188
	189	try code_writer.flush();
	190	try test_writer.flush();
190	191	}
191	192
192	193	fn printUsageAndExit(arg0: []const u8) noreturn {

author	Andrew Kelley <andrew@ziglang.org> 2025-08-09 16:28:19-07:00
committer	GitHub <noreply@github.com> 2025-08-09 16:28:19-07:00
log	0a1a738320219961c0809a92ac7607a5525aa33e
tree	9d3e2bf0948d131628f12a1fa6a5f2242ef2f334
parent	14f11377cbcc4ff2da75e3dee9bb1d9e06013de1
parent	045bb1489767961857085d89645de6bd1d17847d
signature	Signed by PGP key B5690EEEBB952194

Merge pull request #24743 from ziglang/BufferedWriter