mirrors/zig
1
0
Fork 0
mirror of https://codeberg.org/ziglang/zig.git synced 2025-12-06 13:54:21 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Merge pull request #24743 from ziglang/BufferedWriter

Browse source 
std.Io: delete BufferedWriter
This commit is contained in:
Andrew Kelley 2025-08-09 16:28:19 -07:00 • committed by GitHub
commit 0a1a738320
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
24 changed files with 128 additions and 179 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

24
lib/compiler/aro/aro/Driver.zig vendored
View file

@ -585,6 +585,8 @@ pub fn errorDescription(e: anyerror) []const u8 {
}; };
} }
var stdout_buffer: [4096]u8 = undefined;
/// The entry point of the Aro compiler. /// The entry point of the Aro compiler.
/// **MAY call `exit` if `fast_exit` is set.** /// **MAY call `exit` if `fast_exit` is set.**
pub fn main(d: *Driver, tc: *Toolchain, args: []const []const u8, comptime fast_exit: bool) !void { pub fn main(d: *Driver, tc: *Toolchain, args: []const []const u8, comptime fast_exit: bool) !void {
@ -688,13 +690,13 @@ fn processSource(
else else
std.fs.File.stdout(); std.fs.File.stdout();
defer if (d.output_name != null) file.close(); defer if (d.output_name != null) file.close();
var file_buffer: [1024]u8 = undefined;
var file_writer = file.writer(&file_buffer);
var buf_w = std.io.bufferedWriter(file.deprecatedWriter()); pp.prettyPrintTokens(&file_writer.interface, dump_mode) catch |er|
pp.prettyPrintTokens(buf_w.writer(), dump_mode) catch |er|
return d.fatal("unable to write result: {s}", .{errorDescription(er)}); return d.fatal("unable to write result: {s}", .{errorDescription(er)});
buf_w.flush() catch |er| file_writer.interface.flush() catch |er|
return d.fatal("unable to write result: {s}", .{errorDescription(er)}); return d.fatal("unable to write result: {s}", .{errorDescription(er)});
if (fast_exit) std.process.exit(0); // Not linking, no need for cleanup. if (fast_exit) std.process.exit(0); // Not linking, no need for cleanup.
return; return;
@ -704,10 +706,9 @@ fn processSource(
defer tree.deinit(); defer tree.deinit();
if (d.verbose_ast) { if (d.verbose_ast) {
const stdout = std.fs.File.stdout(); var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
var buf_writer = std.io.bufferedWriter(stdout.deprecatedWriter()); tree.dump(d.detectConfig(.stdout()), &stdout_writer.interface) catch {};
tree.dump(d.detectConfig(stdout), buf_writer.writer()) catch {}; stdout_writer.interface.flush() catch {};
buf_writer.flush() catch {};
} }
const prev_errors = d.comp.diagnostics.errors; const prev_errors = d.comp.diagnostics.errors;
@ -734,10 +735,9 @@ fn processSource(
defer ir.deinit(d.comp.gpa); defer ir.deinit(d.comp.gpa);
if (d.verbose_ir) { if (d.verbose_ir) {
const stdout = std.fs.File.stdout(); var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
var buf_writer = std.io.bufferedWriter(stdout.deprecatedWriter()); ir.dump(d.comp.gpa, d.detectConfig(.stdout()), &stdout_writer.interface) catch {};
ir.dump(d.comp.gpa, d.detectConfig(stdout), buf_writer.writer()) catch {}; stdout_writer.interface.flush() catch {};
buf_writer.flush() catch {};
} }
var render_errors: Ir.Renderer.ErrorList = .{}; var render_errors: Ir.Renderer.ErrorList = .{};

7
lib/compiler/aro/aro/Preprocessor.zig vendored
View file

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

7
lib/compiler/aro/backend/Object/Elf.zig vendored
View file

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

19
lib/compiler/libc.zig
View file

@ -22,6 +22,8 @@ const usage_libc =
\\ \\
; ;
var stdout_buffer: [4096]u8 = undefined;
pub fn main() !void { pub fn main() !void {
var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator); var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena_instance.deinit(); defer arena_instance.deinit();
@ -34,14 +36,16 @@ pub fn main() !void {
var input_file: ?[]const u8 = null; var input_file: ?[]const u8 = null;
var target_arch_os_abi: []const u8 = "native"; var target_arch_os_abi: []const u8 = "native";
var print_includes: bool = false; var print_includes: bool = false;
var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
const stdout = &stdout_writer.interface;
{ {
var i: usize = 2; var i: usize = 2;
while (i < args.len) : (i += 1) { while (i < args.len) : (i += 1) {
const arg = args[i]; const arg = args[i];
if (mem.startsWith(u8, arg, "-")) { if (mem.startsWith(u8, arg, "-")) {
if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) { if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {
const stdout = std.fs.File.stdout().deprecatedWriter();
try stdout.writeAll(usage_libc); try stdout.writeAll(usage_libc);
try stdout.flush();
return std.process.cleanExit(); return std.process.cleanExit();
} else if (mem.eql(u8, arg, "-target")) { } else if (mem.eql(u8, arg, "-target")) {
if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg}); if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
@ -97,13 +101,11 @@ pub fn main() !void {
fatal("no include dirs detected for target {s}", .{zig_target}); fatal("no include dirs detected for target {s}", .{zig_target});
} }
var bw = std.io.bufferedWriter(std.fs.File.stdout().deprecatedWriter());
var writer = bw.writer();
for (libc_dirs.libc_include_dir_list) |include_dir| { for (libc_dirs.libc_include_dir_list) |include_dir| {
try writer.writeAll(include_dir); try stdout.writeAll(include_dir);
try writer.writeByte('\n'); try stdout.writeByte('\n');
} }
try bw.flush(); try stdout.flush();
return std.process.cleanExit(); return std.process.cleanExit();
} }
@ -125,9 +127,8 @@ pub fn main() !void {
}; };
defer libc.deinit(gpa); defer libc.deinit(gpa);
var bw = std.io.bufferedWriter(std.fs.File.stdout().deprecatedWriter()); try libc.render(stdout);
try libc.render(bw.writer()); try stdout.flush();
try bw.flush();
} }
} }

35
lib/compiler/resinator/compile.zig
View file

@ -1268,12 +1268,8 @@ pub const Compiler = struct {
try header.write(writer, self.errContext(id_token)); try header.write(writer, self.errContext(id_token));
} }
pub fn writeResourceDataNoPadding(writer: anytype, data_reader: *std.Io.Reader, data_size: u32) !void { pub fn writeResourceDataNoPadding(writer: *std.Io.Writer, data_reader: *std.Io.Reader, data_size: u32) !void {
var adapted = writer.adaptToNewApi(); try data_reader.streamExact(writer, data_size);
var buffer: [128]u8 = undefined;
adapted.new_interface.buffer = &buffer;
try data_reader.streamExact(&adapted.new_interface, data_size);
try adapted.new_interface.flush();
} }
pub fn writeResourceData(writer: anytype, data_reader: *std.Io.Reader, data_size: u32) !void { pub fn writeResourceData(writer: anytype, data_reader: *std.Io.Reader, data_size: u32) !void {
@ -1281,8 +1277,8 @@ pub const Compiler = struct {
try writeDataPadding(writer, data_size); try writeDataPadding(writer, data_size);
} }
pub fn writeDataPadding(writer: anytype, data_size: u32) !void { pub fn writeDataPadding(writer: *std.Io.Writer, data_size: u32) !void {
try writer.writeByteNTimes(0, numPaddingBytesNeeded(data_size)); try writer.splatByteAll(0, numPaddingBytesNeeded(data_size));
} }
pub fn numPaddingBytesNeeded(data_size: u32) u2 { pub fn numPaddingBytesNeeded(data_size: u32) u2 {
@ -2100,8 +2096,10 @@ pub const Compiler = struct {
const resource = ResourceType.fromString(type_bytes); const resource = ResourceType.fromString(type_bytes);
std.debug.assert(resource == .menu or resource == .menuex); std.debug.assert(resource == .menu or resource == .menuex);
self.writeMenuData(node, data_writer, resource) catch |err| switch (err) { var adapted = data_writer.adaptToNewApi(&.{});
error.NoSpaceLeft => {
self.writeMenuData(node, &adapted.new_interface, resource) catch |err| switch (err) {
error.WriteFailed => {
return self.addErrorDetailsAndFail(.{ return self.addErrorDetailsAndFail(.{
.err = .resource_data_size_exceeds_max, .err = .resource_data_size_exceeds_max,
.token = node.id, .token = node.id,
@ -2129,7 +2127,7 @@ pub const Compiler = struct {
/// Expects `data_writer` to be a LimitedWriter limited to u32, meaning all writes to /// Expects `data_writer` to be a LimitedWriter limited to u32, meaning all writes to
/// the writer within this function could return error.NoSpaceLeft /// the writer within this function could return error.NoSpaceLeft
pub fn writeMenuData(self: *Compiler, node: *Node.Menu, data_writer: anytype, resource: ResourceType) !void { pub fn writeMenuData(self: *Compiler, node: *Node.Menu, data_writer: *std.Io.Writer, resource: ResourceType) !void {
// menu header // menu header
const version: u16 = if (resource == .menu) 0 else 1; const version: u16 = if (resource == .menu) 0 else 1;
try data_writer.writeInt(u16, version, .little); try data_writer.writeInt(u16, version, .little);
@ -2156,7 +2154,7 @@ pub const Compiler = struct {
} }
} }
pub fn writeMenuItem(self: *Compiler, node: *Node, writer: anytype, is_last_of_parent: bool) !void { pub fn writeMenuItem(self: *Compiler, node: *Node, writer: *std.Io.Writer, is_last_of_parent: bool) !void {
switch (node.id) { switch (node.id) {
.menu_item_separator => { .menu_item_separator => {
// This is the 'alternate compability form' of the separator, see // This is the 'alternate compability form' of the separator, see
@ -2356,8 +2354,9 @@ pub const Compiler = struct {
try fixed_file_info.write(data_writer); try fixed_file_info.write(data_writer);
for (node.block_statements) |statement| { for (node.block_statements) |statement| {
self.writeVersionNode(statement, data_writer, &data_buffer) catch |err| switch (err) { var adapted = data_writer.adaptToNewApi(&.{});
error.NoSpaceLeft => { self.writeVersionNode(statement, &adapted.new_interface, &data_buffer) catch |err| switch (err) {
error.WriteFailed => {
try self.addErrorDetails(.{ try self.addErrorDetails(.{
.err = .version_node_size_exceeds_max, .err = .version_node_size_exceeds_max,
.token = node.id, .token = node.id,
@ -2395,7 +2394,7 @@ pub const Compiler = struct {
/// Expects writer to be a LimitedWriter limited to u16, meaning all writes to /// Expects writer to be a LimitedWriter limited to u16, meaning all writes to
/// the writer within this function could return error.NoSpaceLeft, and that buf.items.len /// the writer within this function could return error.NoSpaceLeft, and that buf.items.len
/// will never be able to exceed maxInt(u16). /// will never be able to exceed maxInt(u16).
pub fn writeVersionNode(self: *Compiler, node: *Node, writer: anytype, buf: *std.ArrayList(u8)) !void { pub fn writeVersionNode(self: *Compiler, node: *Node, writer: *std.Io.Writer, buf: *std.ArrayList(u8)) !void {
// We can assume that buf.items.len will never be able to exceed the limits of a u16 // We can assume that buf.items.len will never be able to exceed the limits of a u16
try writeDataPadding(writer, @as(u16, @intCast(buf.items.len))); try writeDataPadding(writer, @as(u16, @intCast(buf.items.len)));
@ -2700,12 +2699,12 @@ pub const Compiler = struct {
return self.writeSizeInfo(writer, size_info); return self.writeSizeInfo(writer, size_info);
} }
pub fn writeSizeInfo(self: ResourceHeader, writer: anytype, size_info: SizeInfo) !void { pub fn writeSizeInfo(self: ResourceHeader, writer: *std.Io.Writer, size_info: SizeInfo) !void {
try writer.writeInt(DWORD, self.data_size, .little); // DataSize try writer.writeInt(DWORD, self.data_size, .little); // DataSize
try writer.writeInt(DWORD, size_info.bytes, .little); // HeaderSize try writer.writeInt(DWORD, size_info.bytes, .little); // HeaderSize
try self.type_value.write(writer); // TYPE try self.type_value.write(writer); // TYPE
try self.name_value.write(writer); // NAME try self.name_value.write(writer); // NAME
try writer.writeByteNTimes(0, size_info.padding_after_name); try writer.splatByteAll(0, size_info.padding_after_name);
try writer.writeInt(DWORD, self.data_version, .little); // DataVersion try writer.writeInt(DWORD, self.data_version, .little); // DataVersion
try writer.writeInt(WORD, self.memory_flags.value, .little); // MemoryFlags try writer.writeInt(WORD, self.memory_flags.value, .little); // MemoryFlags
@ -3120,7 +3119,7 @@ pub const FontDir = struct {
// First, the ID is written, though // First, the ID is written, though
try writer.writeInt(u16, font.id, .little); try writer.writeInt(u16, font.id, .little);
try writer.writeAll(&font.header_bytes); try writer.writeAll(&font.header_bytes);
try writer.writeByteNTimes(0, 2); try writer.splatByteAll(0, 2);
} }
try Compiler.writeDataPadding(writer, data_size); try Compiler.writeDataPadding(writer, data_size);
} }

26
lib/compiler/resinator/cvtres.zig
View file

@ -188,7 +188,7 @@ pub const Diagnostics = union {
overflow_resource: usize, overflow_resource: usize,
}; };
pub fn writeCoff(allocator: Allocator, writer: anytype, resources: []const Resource, options: CoffOptions, diagnostics: ?*Diagnostics) !void { pub fn writeCoff(allocator: Allocator, writer: *std.Io.Writer, resources: []const Resource, options: CoffOptions, diagnostics: ?*Diagnostics) !void {
var resource_tree = ResourceTree.init(allocator, options); var resource_tree = ResourceTree.init(allocator, options);
defer resource_tree.deinit(); defer resource_tree.deinit();
@ -232,7 +232,7 @@ pub fn writeCoff(allocator: Allocator, writer: anytype, resources: []const Resou
.flags = flags, .flags = flags,
}; };
try writer.writeStructEndian(coff_header, .little); try writer.writeStruct(coff_header, .little);
const rsrc01_header = std.coff.SectionHeader{ const rsrc01_header = std.coff.SectionHeader{
.name = ".rsrc$01".*, .name = ".rsrc$01".*,
@ -250,7 +250,7 @@ pub fn writeCoff(allocator: Allocator, writer: anytype, resources: []const Resou
.MEM_READ = 1, .MEM_READ = 1,
}, },
}; };
try writer.writeStructEndian(rsrc01_header, .little); try writer.writeStruct(rsrc01_header, .little);
const rsrc02_header = std.coff.SectionHeader{ const rsrc02_header = std.coff.SectionHeader{
.name = ".rsrc$02".*, .name = ".rsrc$02".*,
@ -268,7 +268,7 @@ pub fn writeCoff(allocator: Allocator, writer: anytype, resources: []const Resou
.MEM_READ = 1, .MEM_READ = 1,
}, },
}; };
try writer.writeStructEndian(rsrc02_header, .little); try writer.writeStruct(rsrc02_header, .little);
// TODO: test surrogate pairs // TODO: test surrogate pairs
try resource_tree.sort(); try resource_tree.sort();
@ -665,13 +665,13 @@ const ResourceTree = struct {
pub fn writeCoff( pub fn writeCoff(
self: *const ResourceTree, self: *const ResourceTree,
allocator: Allocator, allocator: Allocator,
w: anytype, w: *std.Io.Writer,
resources_in_data_order: []const Resource, resources_in_data_order: []const Resource,
lengths: Lengths, lengths: Lengths,
coff_string_table: *StringTable, coff_string_table: *StringTable,
) ![]const std.coff.Symbol { ) ![]const std.coff.Symbol {
if (self.type_to_name_map.count() == 0) { if (self.type_to_name_map.count() == 0) {
try w.writeByteNTimes(0, 16); try w.splatByteAll(0, 16);
return &.{}; return &.{};
} }
@ -710,7 +710,7 @@ const ResourceTree = struct {
.number_of_id_entries = counts.ids, .number_of_id_entries = counts.ids,
.number_of_name_entries = counts.names, .number_of_name_entries = counts.names,
}; };
try w.writeStructEndian(table, .little); try w.writeStruct(table, .little);
var it = self.type_to_name_map.iterator(); var it = self.type_to_name_map.iterator();
while (it.next()) |entry| { while (it.next()) |entry| {
@ -745,7 +745,7 @@ const ResourceTree = struct {
.number_of_id_entries = counts.ids, .number_of_id_entries = counts.ids,
.number_of_name_entries = counts.names, .number_of_name_entries = counts.names,
}; };
try w.writeStructEndian(table, .little); try w.writeStruct(table, .little);
var it = name_to_lang_map.iterator(); var it = name_to_lang_map.iterator();
while (it.next()) |entry| { while (it.next()) |entry| {
@ -786,7 +786,7 @@ const ResourceTree = struct {
.number_of_id_entries = counts.ids, .number_of_id_entries = counts.ids,
.number_of_name_entries = counts.names, .number_of_name_entries = counts.names,
}; };
try w.writeStructEndian(table, .little); try w.writeStruct(table, .little);
var it = lang_to_resources_map.iterator(); var it = lang_to_resources_map.iterator();
while (it.next()) |entry| { while (it.next()) |entry| {
@ -819,7 +819,7 @@ const ResourceTree = struct {
.size = @intCast(orig_resource.data.len), .size = @intCast(orig_resource.data.len),
.codepage = 0, .codepage = 0,
}; };
try w.writeStructEndian(data_entry, .little); try w.writeStruct(data_entry, .little);
} }
for (self.rsrc_string_table.keys()) |v| { for (self.rsrc_string_table.keys()) |v| {
@ -828,7 +828,7 @@ const ResourceTree = struct {
try w.writeAll(std.mem.sliceAsBytes(str)); try w.writeAll(std.mem.sliceAsBytes(str));
} }
try w.writeByteNTimes(0, lengths.padding); try w.splatByteAll(0, lengths.padding);
for (relocations.list.items) |relocation| { for (relocations.list.items) |relocation| {
try writeRelocation(w, std.coff.Relocation{ try writeRelocation(w, std.coff.Relocation{
@ -842,13 +842,13 @@ const ResourceTree = struct {
for (self.deduplicated_data.keys()) |data| { for (self.deduplicated_data.keys()) |data| {
const padding_bytes: u4 = @intCast((8 -% data.len) % 8); const padding_bytes: u4 = @intCast((8 -% data.len) % 8);
try w.writeAll(data); try w.writeAll(data);
try w.writeByteNTimes(0, padding_bytes); try w.splatByteAll(0, padding_bytes);
} }
} else { } else {
for (resources_in_data_order) |resource| { for (resources_in_data_order) |resource| {
const padding_bytes: u4 = @intCast((8 -% resource.data.len) % 8); const padding_bytes: u4 = @intCast((8 -% resource.data.len) % 8);
try w.writeAll(resource.data); try w.writeAll(resource.data);
try w.writeByteNTimes(0, padding_bytes); try w.splatByteAll(0, padding_bytes);
} }
} }

14
lib/compiler/resinator/main.zig
View file

@ -248,10 +248,11 @@ pub fn main() !void {
var diagnostics = Diagnostics.init(allocator); var diagnostics = Diagnostics.init(allocator);
defer diagnostics.deinit(); defer diagnostics.deinit();
const res_stream_writer = res_stream.source.writer(allocator); var output_buffer: [4096]u8 = undefined;
var output_buffered_stream = std.io.bufferedWriter(res_stream_writer); var res_stream_writer = res_stream.source.writer(allocator).adaptToNewApi(&output_buffer);
const output_buffered_stream = &res_stream_writer.new_interface;
compile(allocator, final_input, output_buffered_stream.writer(), .{ compile(allocator, final_input, output_buffered_stream, .{
.cwd = std.fs.cwd(), .cwd = std.fs.cwd(),
.diagnostics = &diagnostics, .diagnostics = &diagnostics,
.source_mappings = &mapping_results.mappings, .source_mappings = &mapping_results.mappings,
@ -340,10 +341,11 @@ pub fn main() !void {
}; };
defer coff_stream.deinit(allocator); defer coff_stream.deinit(allocator);
var coff_output_buffered_stream = std.io.bufferedWriter(coff_stream.source.writer(allocator)); var coff_output_buffer: [4096]u8 = undefined;
var coff_output_buffered_stream = coff_stream.source.writer(allocator).adaptToNewApi(&coff_output_buffer);
var cvtres_diagnostics: cvtres.Diagnostics = .{ .none = {} }; var cvtres_diagnostics: cvtres.Diagnostics = .{ .none = {} };
cvtres.writeCoff(allocator, coff_output_buffered_stream.writer(), resources.list.items, options.coff_options, &cvtres_diagnostics) catch |err| { cvtres.writeCoff(allocator, &coff_output_buffered_stream.new_interface, resources.list.items, options.coff_options, &cvtres_diagnostics) catch |err| {
switch (err) { switch (err) {
error.DuplicateResource => { error.DuplicateResource => {
const duplicate_resource = resources.list.items[cvtres_diagnostics.duplicate_resource]; const duplicate_resource = resources.list.items[cvtres_diagnostics.duplicate_resource];
@ -380,7 +382,7 @@ pub fn main() !void {
std.process.exit(1); std.process.exit(1);
}; };
try coff_output_buffered_stream.flush(); try coff_output_buffered_stream.new_interface.flush();
} }
const IoStream = struct { const IoStream = struct {

19
lib/compiler/std-docs.zig
View file

@ -93,9 +93,12 @@ pub fn main() !void {
fn accept(context: *Context, connection: std.net.Server.Connection) void { fn accept(context: *Context, connection: std.net.Server.Connection) void {
defer connection.stream.close(); defer connection.stream.close();
var read_buffer: [8000]u8 = undefined; var recv_buffer: [4000]u8 = undefined;
var server = std.http.Server.init(connection, &read_buffer); var send_buffer: [4000]u8 = undefined;
while (server.state == .ready) { var conn_reader = connection.stream.reader(&recv_buffer);
var conn_writer = connection.stream.writer(&send_buffer);
var server = std.http.Server.init(conn_reader.interface(), &conn_writer.interface);
while (server.reader.state == .ready) {
var request = server.receiveHead() catch |err| switch (err) { var request = server.receiveHead() catch |err| switch (err) {
error.HttpConnectionClosing => return, error.HttpConnectionClosing => return,
else => { else => {
@ -175,8 +178,7 @@ fn serveSourcesTar(request: *std.http.Server.Request, context: *Context) !void {
const gpa = context.gpa; const gpa = context.gpa;
var send_buffer: [0x4000]u8 = undefined; var send_buffer: [0x4000]u8 = undefined;
var response = request.respondStreaming(.{ var response = try request.respondStreaming(&send_buffer, .{
.send_buffer = &send_buffer,
.respond_options = .{ .respond_options = .{
.extra_headers = &.{ .extra_headers = &.{
.{ .name = "content-type", .value = "application/x-tar" }, .{ .name = "content-type", .value = "application/x-tar" },
@ -191,11 +193,7 @@ fn serveSourcesTar(request: *std.http.Server.Request, context: *Context) !void {
var walker = try std_dir.walk(gpa); var walker = try std_dir.walk(gpa);
defer walker.deinit(); defer walker.deinit();
var adapter_buffer: [500]u8 = undefined; var archiver: std.tar.Writer = .{ .underlying_writer = &response.writer };
var response_writer = response.writer().adaptToNewApi();
response_writer.new_interface.buffer = &adapter_buffer;
var archiver: std.tar.Writer = .{ .underlying_writer = &response_writer.new_interface };
archiver.prefix = "std"; archiver.prefix = "std";
while (try walker.next()) |entry| { while (try walker.next()) |entry| {
@ -229,7 +227,6 @@ fn serveSourcesTar(request: *std.http.Server.Request, context: *Context) !void {
// intentionally omitting the pointless trailer // intentionally omitting the pointless trailer
//try archiver.finish(); //try archiver.finish();
try response_writer.new_interface.flush();
try response.end(); try response.end();
} }

7
lib/docs/wasm/markdown.zig
View file

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

9
lib/init/src/root.zig
View file

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

9
lib/std/Io.zig
View file

@ -387,11 +387,11 @@ pub fn GenericWriter(
} }
/// Helper for bridging to the new `Writer` API while upgrading. /// Helper for bridging to the new `Writer` API while upgrading.
pub fn adaptToNewApi(self: *const Self) Adapter { pub fn adaptToNewApi(self: *const Self, buffer: []u8) Adapter {
return .{ return .{
.derp_writer = self.*, .derp_writer = self.*,
.new_interface = .{ .new_interface = .{
.buffer = &.{}, .buffer = buffer,
.vtable = &.{ .drain = Adapter.drain }, .vtable = &.{ .drain = Adapter.drain },
}, },
}; };
@ -423,10 +423,6 @@ pub fn GenericWriter(
pub const AnyReader = @import("Io/DeprecatedReader.zig"); pub const AnyReader = @import("Io/DeprecatedReader.zig");
/// Deprecated in favor of `Writer`. /// Deprecated in favor of `Writer`.
pub const AnyWriter = @import("Io/DeprecatedWriter.zig"); pub const AnyWriter = @import("Io/DeprecatedWriter.zig");
/// Deprecated in favor of `Writer`.
pub const BufferedWriter = @import("Io/buffered_writer.zig").BufferedWriter;
/// Deprecated in favor of `Writer`.
pub const bufferedWriter = @import("Io/buffered_writer.zig").bufferedWriter;
/// Deprecated in favor of `Reader`. /// Deprecated in favor of `Reader`.
pub const FixedBufferStream = @import("Io/fixed_buffer_stream.zig").FixedBufferStream; pub const FixedBufferStream = @import("Io/fixed_buffer_stream.zig").FixedBufferStream;
/// Deprecated in favor of `Reader`. /// Deprecated in favor of `Reader`.
@ -912,7 +908,6 @@ pub fn PollFiles(comptime StreamEnum: type) type {
test { test {
_ = Reader; _ = Reader;
_ = Writer; _ = Writer;
_ = BufferedWriter;
_ = CountingReader; _ = CountingReader;
_ = FixedBufferStream; _ = FixedBufferStream;
_ = tty; _ = tty;

4
lib/std/Io/DeprecatedWriter.zig
View file

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

43
lib/std/Io/buffered_writer.zig
View file

@ -1,43 +0,0 @@
const std = @import("../std.zig");
const io = std.io;
const mem = std.mem;
pub fn BufferedWriter(comptime buffer_size: usize, comptime WriterType: type) type {
return struct {
unbuffered_writer: WriterType,
buf: [buffer_size]u8 = undefined,
end: usize = 0,
pub const Error = WriterType.Error;
pub const Writer = io.GenericWriter(*Self, Error, write);
const Self = @This();
pub fn flush(self: *Self) !void {
try self.unbuffered_writer.writeAll(self.buf[0..self.end]);
self.end = 0;
}
pub fn writer(self: *Self) Writer {
return .{ .context = self };
}
pub fn write(self: *Self, bytes: []const u8) Error!usize {
if (self.end + bytes.len > self.buf.len) {
try self.flush();
if (bytes.len > self.buf.len)
return self.unbuffered_writer.write(bytes);
}
const new_end = self.end + bytes.len;
@memcpy(self.buf[self.end..new_end], bytes);
self.end = new_end;
return bytes.len;
}
};
}
pub fn bufferedWriter(underlying_stream: anytype) BufferedWriter(4096, @TypeOf(underlying_stream)) {
return .{ .unbuffered_writer = underlying_stream };
}

8
lib/std/Io/test.zig
View file

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

2
lib/std/fmt.zig
View file

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

2
lib/std/zig/LibCInstallation.zig
View file

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

16
src/Package/Fetch.zig
View file

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

7
src/link/Lld.zig
View file

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

8
tools/docgen.zig
View file

@ -70,19 +70,19 @@ pub fn main() !void {
var out_file = try fs.cwd().createFile(output_path, .{}); var out_file = try fs.cwd().createFile(output_path, .{});
defer out_file.close(); defer out_file.close();
var out_file_buffer: [4096]u8 = undefined;
var out_file_writer = out_file.writer(&out_file_buffer);
var code_dir = try fs.cwd().openDir(code_dir_path, .{}); var code_dir = try fs.cwd().openDir(code_dir_path, .{});
defer code_dir.close(); defer code_dir.close();
const input_file_bytes = try in_file.deprecatedReader().readAllAlloc(arena, max_doc_file_size); const input_file_bytes = try in_file.deprecatedReader().readAllAlloc(arena, max_doc_file_size);
var buffered_writer = io.bufferedWriter(out_file.deprecatedWriter());
var tokenizer = Tokenizer.init(input_path, input_file_bytes); var tokenizer = Tokenizer.init(input_path, input_file_bytes);
var toc = try genToc(arena, &tokenizer); var toc = try genToc(arena, &tokenizer);
try genHtml(arena, &tokenizer, &toc, code_dir, buffered_writer.writer()); try genHtml(arena, &tokenizer, &toc, code_dir, &out_file_writer.interface);
try buffered_writer.flush(); try out_file_writer.end();
} }
const Token = struct { const Token = struct {

7
tools/doctest.zig
View file

@ -84,9 +84,10 @@ pub fn main() !void {
var out_file = try fs.cwd().createFile(output_path, .{}); var out_file = try fs.cwd().createFile(output_path, .{});
defer out_file.close(); defer out_file.close();
var out_file_buffer: [4096]u8 = undefined;
var out_file_writer = out_file.writer(&out_file_buffer);
var bw = std.io.bufferedWriter(out_file.deprecatedWriter()); const out = &out_file_writer.interface;
const out = bw.writer();
try printSourceBlock(arena, out, source, fs.path.basename(input_path)); try printSourceBlock(arena, out, source, fs.path.basename(input_path));
try printOutput( try printOutput(
@ -102,7 +103,7 @@ pub fn main() !void {
null, null,
); );
try bw.flush(); try out_file_writer.end();
} }
fn printOutput( fn printOutput(

2
tools/gen_spirv_spec.zig
View file

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

8
tools/migrate_langref.zig
View file

@ -23,19 +23,19 @@ pub fn main() !void {
var out_file = try fs.cwd().createFile(output_file, .{}); var out_file = try fs.cwd().createFile(output_file, .{});
defer out_file.close(); defer out_file.close();
var out_file_buffer: [4096]u8 = undefined;
var out_file_writer = out_file.writer(&out_file_buffer);
var out_dir = try fs.cwd().openDir(fs.path.dirname(output_file).?, .{}); var out_dir = try fs.cwd().openDir(fs.path.dirname(output_file).?, .{});
defer out_dir.close(); defer out_dir.close();
const input_file_bytes = try in_file.deprecatedReader().readAllAlloc(arena, std.math.maxInt(u32)); const input_file_bytes = try in_file.deprecatedReader().readAllAlloc(arena, std.math.maxInt(u32));
var buffered_writer = io.bufferedWriter(out_file.deprecatedWriter());
var tokenizer = Tokenizer.init(input_file, input_file_bytes); var tokenizer = Tokenizer.init(input_file, input_file_bytes);
try walk(arena, &tokenizer, out_dir, buffered_writer.writer()); try walk(arena, &tokenizer, out_dir, &out_file_writer.interface);
try buffered_writer.flush(); try out_file_writer.end();
} }
const Token = struct { const Token = struct {

7
tools/update_cpu_features.zig
View file

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

17
tools/update_crc_catalog.zig
View file

@ -29,10 +29,9 @@ pub fn main() anyerror!void {
var zig_code_file = try hash_target_dir.createFile("crc.zig", .{}); var zig_code_file = try hash_target_dir.createFile("crc.zig", .{});
defer zig_code_file.close(); defer zig_code_file.close();
var zig_code_file_buffer: [4096]u8 = undefined;
var cbw = std.io.bufferedWriter(zig_code_file.deprecatedWriter()); var zig_code_file_writer = zig_code_file.writer(&zig_code_file_buffer);
defer cbw.flush() catch unreachable; const code_writer = &zig_code_file_writer.interface;
const code_writer = cbw.writer();
try code_writer.writeAll( try code_writer.writeAll(
\\//! This file is auto-generated by tools/update_crc_catalog.zig. \\//! This file is auto-generated by tools/update_crc_catalog.zig.
@ -54,10 +53,9 @@ pub fn main() anyerror!void {
var zig_test_file = try crc_target_dir.createFile("test.zig", .{}); var zig_test_file = try crc_target_dir.createFile("test.zig", .{});
defer zig_test_file.close(); defer zig_test_file.close();
var zig_test_file_buffer: [4096]u8 = undefined;
var tbw = std.io.bufferedWriter(zig_test_file.deprecatedWriter()); var zig_test_file_writer = zig_test_file.writer(&zig_test_file_buffer);
defer tbw.flush() catch unreachable; const test_writer = &zig_test_file_writer.interface;
const test_writer = tbw.writer();
try test_writer.writeAll( try test_writer.writeAll(
\\//! This file is auto-generated by tools/update_crc_catalog.zig. \\//! This file is auto-generated by tools/update_crc_catalog.zig.
@ -187,6 +185,9 @@ pub fn main() anyerror!void {
\\ \\
, .{ name, camelcase, width, check })); , .{ name, camelcase, width, check }));
} }
try code_writer.flush();
try test_writer.flush();
} }
fn printUsageAndExit(arg0: []const u8) noreturn { fn printUsageAndExit(arg0: []const u8) noreturn {