authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-12-22 15:52:05-08:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-12-23 22:15:12-08:00
log9aee45be97020e65a3eaca67f7a343823a3439f5
tree8d1aa37ebd73843d5d8698ccb4956f9954eeb995
parent9158d3b2819b9fd3d93922f2522162a0ece53f5a

fix "zig std" compilation errors

1 files changed, 36 insertions(+), 36 deletions(-)

lib/compiler/std-docs.zig+36-36
......@@ -7,8 +7,8 @@ const Allocator = std.mem.Allocator;
77const assert = std.debug.assert;
88const Cache = std.Build.Cache;
99
10fn usage() noreturn {
11 std.Io.File.stdout().writeAll(
10fn usage(io: Io) noreturn {
11 Io.File.stdout().writeStreamingAll(io,
1212 \\Usage: zig std [options]
1313 \\
1414 \\Options:
......@@ -29,7 +29,7 @@ pub fn main() !void {
2929 var general_purpose_allocator: std.heap.GeneralPurposeAllocator(.{}) = .init;
3030 const gpa = general_purpose_allocator.allocator();
3131
32 var threaded: std.Io.Threaded = .init(gpa);
32 var threaded: Io.Threaded = .init(gpa, .{});
3333 defer threaded.deinit();
3434 const io = threaded.io();
3535
......@@ -47,11 +47,11 @@ pub fn main() !void {
4747 var force_open_browser: ?bool = null;
4848 while (argv.next()) |arg| {
4949 if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {
50 usage();
50 usage(io);
5151 } else if (mem.eql(u8, arg, "-p") or mem.eql(u8, arg, "--port")) {
52 listen_port = std.fmt.parseInt(u16, argv.next() orelse usage(), 10) catch |err| {
52 listen_port = std.fmt.parseInt(u16, argv.next() orelse usage(io), 10) catch |err| {
5353 std.log.err("expected port number: {}", .{err});
54 usage();
54 usage(io);
5555 };
5656 } else if (mem.eql(u8, arg, "--open-browser")) {
5757 force_open_browser = true;
......@@ -59,18 +59,18 @@ pub fn main() !void {
5959 force_open_browser = false;
6060 } else {
6161 std.log.err("unrecognized argument: {s}", .{arg});
62 usage();
62 usage(io);
6363 }
6464 }
6565 const should_open_browser = force_open_browser orelse (listen_port == 0);
6666
67 const address = std.net.Address.parseIp("127.0.0.1", listen_port) catch unreachable;
68 var http_server = try address.listen(.{
67 const address = Io.net.IpAddress.parse("127.0.0.1", listen_port) catch unreachable;
68 var http_server = try address.listen(io, .{
6969 .reuse_address = true,
7070 });
71 const port = http_server.listen_address.in.getPort();
71 const port = http_server.socket.address.getPort();
7272 const url_with_newline = try std.fmt.allocPrint(arena, "http://127.0.0.1:{d}/\n", .{port});
73 std.Io.File.stdout().writeAll(url_with_newline) catch {};
73 Io.File.stdout().writeStreamingAll(io, url_with_newline) catch {};
7474 if (should_open_browser) {
7575 openBrowserTab(gpa, io, url_with_newline[0 .. url_with_newline.len - 1 :'\n']) catch |err| {
7676 std.log.err("unable to open browser: {t}", .{err});
......@@ -86,44 +86,43 @@ pub fn main() !void {
8686 .zig_lib_directory = zig_lib_directory,
8787 };
8888
89 var group: Io.Group = .init;
90 defer group.cancel(io);
91
8992 while (true) {
90 const connection = try http_server.accept();
91 _ = std.Thread.spawn(.{}, accept, .{ &context, connection }) catch |err| {
92 std.log.err("unable to accept connection: {t}", .{err});
93 connection.stream.close(io);
94 continue;
95 };
93 const stream = try http_server.accept(io);
94 group.async(io, accept, .{ &context, stream });
9695 }
9796}
9897
99fn accept(context: *Context, connection: std.net.Server.Connection) void {
98fn accept(context: *Context, stream: Io.net.Stream) void {
10099 const io = context.io;
101 defer connection.stream.close(io);
100 defer stream.close(io);
102101
103102 var recv_buffer: [4000]u8 = undefined;
104103 var send_buffer: [4000]u8 = undefined;
105 var conn_reader = connection.stream.reader(&recv_buffer);
106 var conn_writer = connection.stream.writer(&send_buffer);
107 var server = std.http.Server.init(conn_reader.interface(), &conn_writer.interface);
104 var conn_reader = stream.reader(io, &recv_buffer);
105 var conn_writer = stream.writer(io, &send_buffer);
106 var server = std.http.Server.init(&conn_reader.interface, &conn_writer.interface);
108107 while (server.reader.state == .ready) {
109108 var request = server.receiveHead() catch |err| switch (err) {
110109 error.HttpConnectionClosing => return,
111110 else => {
112 std.log.err("closing http connection: {s}", .{@errorName(err)});
111 std.log.err("closing http connection: {t}", .{err});
113112 return;
114113 },
115114 };
116115 serveRequest(&request, context) catch |err| switch (err) {
117116 error.WriteFailed => {
118117 if (conn_writer.err) |e| {
119 std.log.err("unable to serve {s}: {s}", .{ request.head.target, @errorName(e) });
118 std.log.err("unable to serve {s}: {t}", .{ request.head.target, e });
120119 } else {
121 std.log.err("unable to serve {s}: {s}", .{ request.head.target, @errorName(err) });
120 std.log.err("unable to serve {s}: {t}", .{ request.head.target, err });
122121 }
123122 return;
124123 },
125124 else => {
126 std.log.err("unable to serve {s}: {s}", .{ request.head.target, @errorName(err) });
125 std.log.err("unable to serve {s}: {t}", .{ request.head.target, err });
127126 return;
128127 },
129128 };
......@@ -216,7 +215,7 @@ fn serveSourcesTar(request: *std.http.Server.Request, context: *Context) !void {
216215 var archiver: std.tar.Writer = .{ .underlying_writer = &response.writer };
217216 archiver.prefix = "std";
218217
219 while (try walker.next()) |entry| {
218 while (try walker.next(io)) |entry| {
220219 switch (entry.kind) {
221220 .file => {
222221 if (!std.mem.endsWith(u8, entry.basename, ".zig"))
......@@ -229,12 +228,13 @@ fn serveSourcesTar(request: *std.http.Server.Request, context: *Context) !void {
229228 var file = try entry.dir.openFile(io, entry.basename, .{});
230229 defer file.close(io);
231230 const stat = try file.stat(io);
232 var file_reader: std.Io.File.Reader = .{
231 var file_reader: Io.File.Reader = .{
232 .io = io,
233233 .file = file,
234 .interface = std.Io.File.Reader.initInterface(&.{}),
234 .interface = Io.File.Reader.initInterface(&.{}),
235235 .size = stat.size,
236236 };
237 try archiver.writeFile(io, entry.path, &file_reader, stat.mtime);
237 try archiver.writeFileTimestamp(entry.path, &file_reader, stat.mtime);
238238 }
239239
240240 {
......@@ -267,7 +267,7 @@ fn serveWasm(
267267 const wasm_base_path = try buildWasmBinary(arena, context, optimize_mode);
268268 const bin_name = try std.zig.binNameAlloc(arena, .{
269269 .root_name = autodoc_root_name,
270 .target = &(std.zig.system.resolveTargetQuery(std.Build.parseTargetQuery(.{
270 .target = &(std.zig.system.resolveTargetQuery(io, std.Build.parseTargetQuery(.{
271271 .arch_os_abi = autodoc_arch_os_abi,
272272 .cpu_features = autodoc_cpu_features,
273273 }) catch unreachable) catch unreachable),
......@@ -330,7 +330,7 @@ fn buildWasmBinary(
330330 child.stderr_behavior = .Pipe;
331331 try child.spawn(io);
332332
333 var poller = std.Io.poll(gpa, enum { stdout, stderr }, .{
333 var poller = Io.poll(gpa, enum { stdout, stderr }, .{
334334 .stdout = child.stdout.?,
335335 .stderr = child.stderr.?,
336336 });
......@@ -361,7 +361,7 @@ fn buildWasmBinary(
361361 result_error_bundle = try std.zig.Server.allocErrorBundle(arena, body);
362362 },
363363 .emit_digest => {
364 var r: std.Io.Reader = .fixed(body);
364 var r: Io.Reader = .fixed(body);
365365 const emit_digest = r.takeStruct(std.zig.Server.Message.EmitDigest, .little) catch unreachable;
366366 if (!emit_digest.flags.cache_hit) {
367367 std.log.info("source changes detected; rebuilt wasm component", .{});
......@@ -387,7 +387,7 @@ fn buildWasmBinary(
387387 child.stdin.?.close(io);
388388 child.stdin = null;
389389
390 switch (try child.wait()) {
390 switch (try child.wait(io)) {
391391 .Exited => |code| {
392392 if (code != 0) {
393393 std.log.err(
......@@ -407,7 +407,7 @@ fn buildWasmBinary(
407407 }
408408
409409 if (result_error_bundle.errorMessageCount() > 0) {
410 result_error_bundle.renderToStderr(io, .{}, true);
410 try result_error_bundle.renderToStderr(io, .{}, .auto);
411411 std.log.err("the following command failed with {d} compilation errors:\n{s}", .{
412412 result_error_bundle.errorMessageCount(),
413413 try std.Build.Step.allocPrintCmd(arena, null, argv.items),
......@@ -423,7 +423,7 @@ fn buildWasmBinary(
423423 };
424424}
425425
426fn sendMessage(io: Io, file: std.Io.File, tag: std.zig.Client.Message.Tag) !void {
426fn sendMessage(io: Io, file: Io.File, tag: std.zig.Client.Message.Tag) !void {
427427 const header: std.zig.Client.Message.Header = .{
428428 .tag = tag,
429429 .bytes_len = 0,