authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2026-01-02 17:57:54-08:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2026-01-04 00:27:08-08:00
logbf74827ddb34e36906c5f7615f8b488d90e16be4
treee00a03395bbffa6359640093c976c2dde8f775dd
parent1b56686012c49b34f395c82741b03587633aaa31

test-standalone: update more cases to new main API

41 files changed, 346 insertions(+), 416 deletions(-)

lib/compiler/aro/aro/Compilation.zig+11-10
......@@ -74,9 +74,7 @@ pub const Environment = struct {
7474 pub const default: @This() = .{ .provided = 0 };
7575 };
7676
77 /// Load all of the environment variables using the std.process API. Do not use if using Aro as a shared library on Linux without libc
78 /// See https://github.com/ziglang/zig/issues/4524
79 pub fn loadAll(allocator: std.mem.Allocator) !Environment {
77 pub fn loadAll(allocator: std.mem.Allocator, environ_map: *const std.process.Environ.Map) !Environment {
8078 var env: Environment = .{};
8179 errdefer env.deinit(allocator);
8280
......@@ -85,11 +83,7 @@ pub const Environment = struct {
8583
8684 var env_var_buf: [field.name.len]u8 = undefined;
8785 const env_var_name = std.ascii.upperString(&env_var_buf, field.name);
88 const val: ?[]const u8 = std.process.getEnvVarOwned(allocator, env_var_name) catch |err| switch (err) {
89 error.OutOfMemory => |e| return e,
90 error.EnvironmentVariableNotFound => null,
91 error.InvalidWtf8 => null,
92 };
86 const val: ?[]const u8 = if (environ_map.get(env_var_name)) |v| try allocator.dupe(u8, v) else null;
9387 @field(env, field.name) = val;
9488 }
9589 return env;
......@@ -193,13 +187,20 @@ pub fn init(gpa: Allocator, arena: Allocator, io: Io, diagnostics: *Diagnostics,
193187
194188/// Initialize Compilation with default environment,
195189/// pragma handlers and emulation mode set to target.
196pub fn initDefault(gpa: Allocator, arena: Allocator, io: Io, diagnostics: *Diagnostics, cwd: Io.Dir) !Compilation {
190pub fn initDefault(
191 gpa: Allocator,
192 arena: Allocator,
193 io: Io,
194 diagnostics: *Diagnostics,
195 cwd: Io.Dir,
196 env_map: *const std.process.Environ.Map,
197) !Compilation {
197198 var comp: Compilation = .{
198199 .gpa = gpa,
199200 .arena = arena,
200201 .io = io,
201202 .diagnostics = diagnostics,
202 .environment = try Environment.loadAll(gpa),
203 .environment = try Environment.loadAll(gpa, env_map),
203204 .cwd = cwd,
204205 };
205206 errdefer comp.deinit();
lib/compiler/aro/aro/Driver.zig+24-16
......@@ -1250,21 +1250,25 @@ fn getOutFileName(d: *Driver, source: Source, buf: *[std.fs.max_name_bytes]u8) !
12501250}
12511251
12521252fn invokeAssembler(d: *Driver, tc: *Toolchain, input_path: []const u8, output_path: []const u8) !void {
1253 const io = d.comp.io;
12531254 var assembler_path_buf: [std.fs.max_path_bytes]u8 = undefined;
12541255 const assembler_path = try tc.getAssemblerPath(&assembler_path_buf);
12551256 const argv = [_][]const u8{ assembler_path, input_path, "-o", output_path };
12561257
1257 var child = std.process.Child.init(&argv, d.comp.gpa);
1258 // TODO handle better
1259 child.stdin_behavior = .inherit;
1260 child.stdout_behavior = .inherit;
1261 child.stderr_behavior = .inherit;
1262
1263 const term = child.spawnAndWait() catch |er| {
1258 var child = std.process.spawn(io, .{
1259 .argv = &argv,
1260 // TODO handle better
1261 .stdin = .inherit,
1262 .stdout = .inherit,
1263 .stderr = .inherit,
1264 }) catch |er| {
12641265 return d.fatal("unable to spawn linker: {s}", .{errorDescription(er)});
12651266 };
1267 const term = child.wait(io) catch |er| {
1268 return d.fatal("unable to wait linker: {s}", .{errorDescription(er)});
1269 };
12661270 switch (term) {
1267 .Exited => |code| if (code != 0) {
1271 .exited => |code| if (code != 0) {
12681272 const e = d.fatal("assembler exited with an error code", .{});
12691273 return e;
12701274 },
......@@ -1490,6 +1494,7 @@ fn dumpLinkerArgs(w: *std.Io.Writer, items: []const []const u8) !void {
14901494/// **MAY call `exit` if `fast_exit` is set.**
14911495pub fn invokeLinker(d: *Driver, tc: *Toolchain, comptime fast_exit: bool) Compilation.Error!void {
14921496 const gpa = d.comp.gpa;
1497 const io = d.comp.io;
14931498 var argv: std.ArrayList([]const u8) = .empty;
14941499 defer argv.deinit(gpa);
14951500
......@@ -1506,17 +1511,20 @@ pub fn invokeLinker(d: *Driver, tc: *Toolchain, comptime fast_exit: bool) Compil
15061511 return d.fatal("unable to dump linker args: {s}", .{errorDescription(stdout.err.?)});
15071512 };
15081513 }
1509 var child = std.process.Child.init(argv.items, d.comp.gpa);
1510 // TODO handle better
1511 child.stdin_behavior = .inherit;
1512 child.stdout_behavior = .inherit;
1513 child.stderr_behavior = .inherit;
1514
1515 const term = child.spawnAndWait() catch |er| {
1514 var child = std.process.spawn(io, .{
1515 .argv = argv.items,
1516 // TODO handle better
1517 .stdin = .inherit,
1518 .stdout = .inherit,
1519 .stderr = .inherit,
1520 }) catch |er| {
15161521 return d.fatal("unable to spawn linker: {s}", .{errorDescription(er)});
15171522 };
1523 const term = child.wait(io) catch |er| {
1524 return d.fatal("unable to wait linker: {s}", .{errorDescription(er)});
1525 };
15181526 switch (term) {
1519 .Exited => |code| if (code != 0) {
1527 .exited => |code| if (code != 0) {
15201528 const e = d.fatal("linker exited with an error code", .{});
15211529 if (fast_exit) d.exitWithCleanup(code);
15221530 return e;
lib/compiler/resinator/compile.zig+2-3
......@@ -80,7 +80,7 @@ pub const Dependencies = struct {
8080 }
8181};
8282
83pub fn compile(allocator: Allocator, io: Io, source: []const u8, writer: *std.Io.Writer, options: CompileOptions) !void {
83pub fn compile(allocator: Allocator, io: Io, source: []const u8, writer: *std.Io.Writer, options: CompileOptions, env_map: *const std.process.Environ.Map) !void {
8484 var lexer = lex.Lexer.init(source, .{
8585 .default_code_page = options.default_code_page,
8686 .source_mappings = options.source_mappings,
......@@ -148,8 +148,7 @@ pub fn compile(allocator: Allocator, io: Io, source: []const u8, writer: *std.Io
148148 try search_dirs.append(allocator, .{ .dir = dir, .path = try allocator.dupe(u8, system_include_path) });
149149 }
150150 if (!options.ignore_include_env_var) {
151 const INCLUDE = std.process.getEnvVarOwned(allocator, "INCLUDE") catch "";
152 defer allocator.free(INCLUDE);
151 const INCLUDE = env_map.get("INCLUDE") orelse "";
153152
154153 // The only precedence here is llvm-rc which also uses the platform-specific
155154 // delimiter. There's no precedence set by `rc.exe` since it's Windows-only.
lib/compiler/resinator/main.zig+7-4
......@@ -24,6 +24,9 @@ pub fn main(init: std.process.Init.Minimal) !void {
2424 defer std.debug.assert(debug_allocator.deinit() == .ok);
2525 const gpa = debug_allocator.allocator();
2626
27 var env_map = try init.environ.createMap(gpa);
28 defer env_map.deinit();
29
2730 var threaded: std.Io.Threaded = .init(gpa, .{
2831 .environ = init.environ,
2932 .argv0 = .init(init.args),
......@@ -148,8 +151,8 @@ pub fn main(init: std.process.Init.Minimal) !void {
148151 defer argv.deinit(aro_arena);
149152
150153 try argv.append(aro_arena, "arocc"); // dummy command name
151 const resolved_include_paths = try include_paths.get(&error_handler);
152 try preprocess.appendAroArgs(aro_arena, &argv, options, resolved_include_paths);
154 const resolved_include_paths = try include_paths.get(&error_handler, &env_map);
155 try preprocess.appendAroArgs(aro_arena, &argv, options, resolved_include_paths, &env_map);
153156 try argv.append(aro_arena, switch (options.input_source) {
154157 .stdio => "-",
155158 .filename => |filename| filename,
......@@ -283,7 +286,7 @@ pub fn main(init: std.process.Init.Minimal) !void {
283286 .dependencies = maybe_dependencies,
284287 .ignore_include_env_var = options.ignore_include_env_var,
285288 .extra_include_paths = options.extra_include_paths.items,
286 .system_include_paths = try include_paths.get(&error_handler),
289 .system_include_paths = try include_paths.get(&error_handler, &env_map),
287290 .default_language_id = options.default_language_id,
288291 .default_code_page = default_code_page,
289292 .disjoint_code_page = has_disjoint_code_page,
......@@ -292,7 +295,7 @@ pub fn main(init: std.process.Init.Minimal) !void {
292295 .max_string_literal_codepoints = options.max_string_literal_codepoints,
293296 .silent_duplicate_control_ids = options.silent_duplicate_control_ids,
294297 .warn_instead_of_error_on_invalid_code_page = options.warn_instead_of_error_on_invalid_code_page,
295 }) catch |err| switch (err) {
298 }, &env_map) catch |err| switch (err) {
296299 error.ParseError, error.CompileError => {
297300 try error_handler.emitDiagnostics(gpa, Io.Dir.cwd(), final_input, &diagnostics, mapping_results.mappings);
298301 // Delete the output file on error
lib/compiler/resinator/preprocess.zig+2-2
......@@ -86,7 +86,7 @@ fn hasAnyErrors(comp: *aro.Compilation) bool {
8686
8787/// `arena` is used for temporary -D argument strings and the INCLUDE environment variable.
8888/// The arena should be kept alive at least as long as `argv`.
89pub fn appendAroArgs(arena: Allocator, argv: *std.ArrayList([]const u8), options: cli.Options, system_include_paths: []const []const u8) !void {
89pub fn appendAroArgs(arena: Allocator, argv: *std.ArrayList([]const u8), options: cli.Options, system_include_paths: []const []const u8, env_map: *const std.process.Environ.Map) !void {
9090 try argv.appendSlice(arena, &.{
9191 "-E",
9292 "--comments",
......@@ -109,7 +109,7 @@ pub fn appendAroArgs(arena: Allocator, argv: *std.ArrayList([]const u8), options
109109 }
110110
111111 if (!options.ignore_include_env_var) {
112 const INCLUDE = std.process.getEnvVarOwned(arena, "INCLUDE") catch "";
112 const INCLUDE = env_map.get("INCLUDE") orelse "";
113113
114114 // The only precedence here is llvm-rc which also uses the platform-specific
115115 // delimiter. There's no precedence set by `rc.exe` since it's Windows-only.
lib/compiler/translate-c/main.zig+29-30
......@@ -13,6 +13,7 @@ pub fn main(init: std.process.Init) u8 {
1313 const gpa = init.gpa;
1414 const arena = init.arena.allocator();
1515 const io = init.io;
16 const env_map = init.env_map;
1617
1718 const args = init.minimal.args.toSlice(arena) catch {
1819 std.debug.print("ran out of memory allocating arguments\n", .{});
......@@ -25,8 +26,8 @@ pub fn main(init: std.process.Init) u8 {
2526 zig_integration = true;
2627 }
2728
28 const NO_COLOR = std.zig.EnvVar.NO_COLOR.isSet(init.env_map);
29 const CLICOLOR_FORCE = std.zig.EnvVar.CLICOLOR_FORCE.isSet(init.env_map);
29 const NO_COLOR = std.zig.EnvVar.NO_COLOR.isSet(env_map);
30 const CLICOLOR_FORCE = std.zig.EnvVar.CLICOLOR_FORCE.isSet(env_map);
3031
3132 var stderr_buf: [1024]u8 = undefined;
3233 var stderr = Io.File.stderr().writer(io, &stderr_buf);
......@@ -41,7 +42,7 @@ pub fn main(init: std.process.Init) u8 {
4142 };
4243 defer diagnostics.deinit();
4344
44 var comp = aro.Compilation.initDefault(gpa, arena, io, &diagnostics, Io.Dir.cwd()) catch |err| switch (err) {
45 var comp = aro.Compilation.initDefault(gpa, arena, io, &diagnostics, .cwd(), env_map) catch |err| switch (err) {
4546 error.OutOfMemory => {
4647 std.debug.print("ran out of memory initializing C compilation\n", .{});
4748 if (fast_exit) process.exit(1);
......@@ -114,43 +115,41 @@ pub const usage =
114115 \\
115116;
116117
117fn translate(d: *aro.Driver, tc: *aro.Toolchain, args: [][:0]u8, zig_integration: bool) !void {
118fn translate(d: *aro.Driver, tc: *aro.Toolchain, args: []const [:0]const u8, zig_integration: bool) !void {
118119 const gpa = d.comp.gpa;
119120 const io = d.comp.io;
120121
121 const aro_args = args: {
122 var i: usize = 0;
123 for (args) |arg| {
124 args[i] = arg;
125 if (mem.eql(u8, arg, "--help")) {
126 var stdout_buf: [512]u8 = undefined;
127 var stdout = Io.File.stdout().writer(io, &stdout_buf);
128 try stdout.interface.print(usage, .{args[0]});
129 try stdout.interface.flush();
130 return;
131 } else if (mem.eql(u8, arg, "--version")) {
132 var stdout_buf: [512]u8 = undefined;
133 var stdout = Io.File.stdout().writer(io, &stdout_buf);
134 // TODO add version
135 try stdout.interface.writeAll("0.0.0-dev\n");
136 try stdout.interface.flush();
137 return;
138 } else if (mem.eql(u8, arg, "--zig-integration")) {
139 if (i != 1 or !zig_integration)
140 return d.fatal("--zig-integration must be the first argument", .{});
141 } else {
142 i += 1;
143 }
122 var aro_args: std.ArrayList([:0]const u8) = .empty;
123 defer aro_args.deinit(gpa);
124
125 for (args, 0..) |arg, i| {
126 if (mem.eql(u8, arg, "--help")) {
127 var stdout_buf: [512]u8 = undefined;
128 var stdout = Io.File.stdout().writer(io, &stdout_buf);
129 try stdout.interface.print(usage, .{args[0]});
130 try stdout.interface.flush();
131 return;
132 } else if (mem.eql(u8, arg, "--version")) {
133 var stdout_buf: [512]u8 = undefined;
134 var stdout = Io.File.stdout().writer(io, &stdout_buf);
135 // TODO add version
136 try stdout.interface.writeAll("0.0.0-dev\n");
137 try stdout.interface.flush();
138 return;
139 } else if (mem.eql(u8, arg, "--zig-integration")) {
140 if (i != 1 or !zig_integration)
141 return d.fatal("--zig-integration must be the first argument", .{});
142 } else {
143 try aro_args.append(gpa, arg);
144144 }
145 break :args args[0..i];
146 };
145 }
147146 const user_macros = macros: {
148147 var macro_buf: std.ArrayList(u8) = .empty;
149148 defer macro_buf.deinit(gpa);
150149
151150 var discard_buf: [256]u8 = undefined;
152151 var discarding: std.Io.Writer.Discarding = .init(&discard_buf);
153 assert(!try d.parseArgs(&discarding.writer, &macro_buf, aro_args));
152 assert(!try d.parseArgs(&discarding.writer, &macro_buf, aro_args.items));
154153 if (macro_buf.items.len > std.math.maxInt(u32)) {
155154 return d.fatal("user provided macro source exceeded max size", .{});
156155 }
test/standalone/child_process/main.zig+10-8
......@@ -9,7 +9,7 @@ pub fn main(init: std.process.Init.Minimal) !void {
99 };
1010 const gpa = gpa_state.allocator();
1111
12 var it = try init.iterateAllocator(gpa);
12 var it = try init.args.iterateAllocator(gpa);
1313 defer it.deinit();
1414 _ = it.next() orelse unreachable; // skip binary name
1515 const child_path, const needs_free = child_path: {
......@@ -28,11 +28,13 @@ pub fn main(init: std.process.Init.Minimal) !void {
2828 defer threaded.deinit();
2929 const io = threaded.io();
3030
31 var child = std.process.Child.init(&.{ child_path, "hello arg" }, gpa);
32 child.stdin_behavior = .pipe;
33 child.stdout_behavior = .pipe;
34 child.stderr_behavior = .inherit;
35 try child.spawn(io);
31 var child = try std.process.spawn(.{
32 .argv = &.{ child_path, "hello arg" },
33 .stdin = .pipe,
34 .stdout = .pipe,
35 .stderr = .inherit,
36 });
37
3638 const child_stdin = child.stdin.?;
3739 try child_stdin.writeStreamingAll(io, "hello from stdin"); // verified in child
3840 child_stdin.close(io);
......@@ -47,7 +49,7 @@ pub fn main(init: std.process.Init.Minimal) !void {
4749 }
4850
4951 switch (try child.wait(io)) {
50 .Exited => |code| {
52 .exited => |code| {
5153 const child_ok_code = 42; // set by child if no test errors
5254 if (code != child_ok_code) {
5355 testError(io, "child exit code: {d}; want {d}", .{ code, child_ok_code });
......@@ -60,7 +62,7 @@ pub fn main(init: std.process.Init.Minimal) !void {
6062 // Check that FileNotFound is consistent across platforms when trying to spawn an executable that doesn't exist
6163 const missing_child_path = try std.mem.concat(gpa, u8, &.{ child_path, "_intentionally_missing" });
6264 defer gpa.free(missing_child_path);
63 try std.testing.expectError(error.FileNotFound, std.process.Child.run(gpa, io, .{ .argv = &.{missing_child_path} }));
65 try std.testing.expectError(error.FileNotFound, std.process.run(gpa, io, .{ .argv = &.{missing_child_path} }));
6466}
6567
6668var parent_test_error = false;
test/standalone/cmakedefine/check.zig+4-8
......@@ -1,16 +1,12 @@
1pub fn main() !void {
2 var arena_state: std.heap.ArenaAllocator = .init(std.heap.page_allocator);
3 defer arena_state.deinit();
4 const arena = arena_state.allocator();
5
6 const args = try std.process.argsAlloc(arena);
1pub fn main(init: std.process.Init) !void {
2 const arena = init.arena.allocator();
3 const io = init.io;
4 const args = try init.minimal.args.toSlice(arena);
75
86 if (args.len != 3) return error.BadUsage;
97 const actual_path = args[1];
108 const expected_path = args[2];
119
12 const io = std.Io.Threaded.global_single_threaded.ioBasic();
13
1410 const actual = try std.Io.Dir.cwd().readFileAlloc(io, actual_path, arena, .limited(1024 * 1024));
1511 const expected = try std.Io.Dir.cwd().readFileAlloc(io, expected_path, arena, .limited(1024 * 1024));
1612
test/standalone/empty_env/main.zig+2-5
......@@ -1,8 +1,5 @@
11const std = @import("std");
22
3pub fn main() !void {
4 var gpa: std.heap.GeneralPurposeAllocator(.{}) = .init;
5 defer _ = gpa.deinit();
6 const env_map = std.process.getEnvMap(gpa.allocator()) catch @panic("unable to get env map");
7 try std.testing.expect(env_map.count() == 0);
3pub fn main(init: std.process.Init) !void {
4 try std.testing.expect(init.env_map.count() == 0);
85}
test/standalone/entry_point/check_differ.zig+6-8
......@@ -1,12 +1,11 @@
1pub fn main() !void {
2 var arena_state: std.heap.ArenaAllocator = .init(std.heap.page_allocator);
3 defer arena_state.deinit();
4 const arena = arena_state.allocator();
1const std = @import("std");
52
6 const args = try std.process.argsAlloc(arena);
7 if (args.len != 3) return error.BadUsage; // usage: 'check_differ <path a> <path b>'
3pub fn main(init: std.process.Init) !void {
4 const arena = init.arena.allocator();
5 const io = init.io;
6 const args = try init.minimal.args.toSlice(arena);
87
9 const io = std.Io.Threaded.global_single_threaded.ioBasic();
8 if (args.len != 3) return error.BadUsage; // usage: 'check_differ <path a> <path b>'
109
1110 const contents_1 = try std.Io.Dir.cwd().readFileAlloc(io, args[1], arena, .limited(1024 * 1024 * 64)); // 64 MiB ought to be plenty
1211 const contents_2 = try std.Io.Dir.cwd().readFileAlloc(io, args[2], arena, .limited(1024 * 1024 * 64)); // 64 MiB ought to be plenty
......@@ -16,4 +15,3 @@ pub fn main() !void {
1615 }
1716 // success, files differ
1817}
19const std = @import("std");
test/standalone/env_vars/main.zig+73-92
......@@ -7,145 +7,126 @@ pub fn main(init: std.process.Init) !void {
77
88 const allocator = init.gpa;
99 const arena = init.arena.allocator();
10 const environ = init.minimal.environ;
1011
11 // hasNonEmptyEnvVar
12 // containsUnempty
1213 {
13 try std.testing.expect(try std.process.hasNonEmptyEnvVar(allocator, "FOO"));
14 try std.testing.expect(!(try std.process.hasNonEmptyEnvVar(allocator, "FOO=")));
15 try std.testing.expect(!(try std.process.hasNonEmptyEnvVar(allocator, "FO")));
16 try std.testing.expect(!(try std.process.hasNonEmptyEnvVar(allocator, "FOOO")));
14 try std.testing.expect(try environ.containsUnempty(allocator, "FOO"));
15 try std.testing.expect(!(try environ.containsUnempty(allocator, "FOO=")));
16 try std.testing.expect(!(try environ.containsUnempty(allocator, "FO")));
17 try std.testing.expect(!(try environ.containsUnempty(allocator, "FOOO")));
1718 if (builtin.os.tag == .windows) {
18 try std.testing.expect(try std.process.hasNonEmptyEnvVar(allocator, "foo"));
19 try std.testing.expect(try environ.containsUnempty(allocator, "foo"));
1920 }
20 try std.testing.expect(try std.process.hasNonEmptyEnvVar(allocator, "EQUALS"));
21 try std.testing.expect(!(try std.process.hasNonEmptyEnvVar(allocator, "EQUALS=ABC")));
22 try std.testing.expect(try std.process.hasNonEmptyEnvVar(allocator, "КИРиллИЦА"));
21 try std.testing.expect(try environ.containsUnempty(allocator, "EQUALS"));
22 try std.testing.expect(!(try environ.containsUnempty(allocator, "EQUALS=ABC")));
23 try std.testing.expect(try environ.containsUnempty(allocator, "КИРиллИЦА"));
2324 if (builtin.os.tag == .windows) {
24 try std.testing.expect(try std.process.hasNonEmptyEnvVar(allocator, "кирИЛЛица"));
25 try std.testing.expect(try environ.containsUnempty(allocator, "кирИЛЛица"));
2526 }
26 try std.testing.expect(!(try std.process.hasNonEmptyEnvVar(allocator, "NO_VALUE")));
27 try std.testing.expect(!(try std.process.hasNonEmptyEnvVar(allocator, "NOT_SET")));
27 try std.testing.expect(!(try environ.containsUnempty(allocator, "NO_VALUE")));
28 try std.testing.expect(!(try environ.containsUnempty(allocator, "NOT_SET")));
2829 if (builtin.os.tag == .windows) {
29 try std.testing.expect(try std.process.hasNonEmptyEnvVar(allocator, "=HIDDEN"));
30 try std.testing.expect(try std.process.hasNonEmptyEnvVar(allocator, "INVALID_UTF16_\xed\xa0\x80"));
30 try std.testing.expect(try environ.containsUnempty(allocator, "=HIDDEN"));
31 try std.testing.expect(try environ.containsUnempty(allocator, "INVALID_UTF16_\xed\xa0\x80"));
3132 }
3233 }
3334
34 // hasNonEmptyEnvVarContstant
35 // containsUnemptyConstant
3536 {
36 try std.testing.expect(std.process.hasNonEmptyEnvVarConstant("FOO"));
37 try std.testing.expect(!std.process.hasNonEmptyEnvVarConstant("FOO="));
38 try std.testing.expect(!std.process.hasNonEmptyEnvVarConstant("FO"));
39 try std.testing.expect(!std.process.hasNonEmptyEnvVarConstant("FOOO"));
37 try std.testing.expect(environ.containsUnemptyConstant("FOO"));
38 try std.testing.expect(!environ.containsUnemptyConstant("FOO="));
39 try std.testing.expect(!environ.containsUnemptyConstant("FO"));
40 try std.testing.expect(!environ.containsUnemptyConstant("FOOO"));
4041 if (builtin.os.tag == .windows) {
41 try std.testing.expect(std.process.hasNonEmptyEnvVarConstant("foo"));
42 try std.testing.expect(environ.containsUnemptyConstant("foo"));
4243 }
43 try std.testing.expect(std.process.hasNonEmptyEnvVarConstant("EQUALS"));
44 try std.testing.expect(!std.process.hasNonEmptyEnvVarConstant("EQUALS=ABC"));
45 try std.testing.expect(std.process.hasNonEmptyEnvVarConstant("КИРиллИЦА"));
44 try std.testing.expect(environ.containsUnemptyConstant("EQUALS"));
45 try std.testing.expect(!environ.containsUnemptyConstant("EQUALS=ABC"));
46 try std.testing.expect(environ.containsUnemptyConstant("КИРиллИЦА"));
4647 if (builtin.os.tag == .windows) {
47 try std.testing.expect(std.process.hasNonEmptyEnvVarConstant("кирИЛЛица"));
48 try std.testing.expect(environ.containsUnemptyConstant("кирИЛЛица"));
4849 }
49 try std.testing.expect(!(std.process.hasNonEmptyEnvVarConstant("NO_VALUE")));
50 try std.testing.expect(!(std.process.hasNonEmptyEnvVarConstant("NOT_SET")));
50 try std.testing.expect(!(environ.containsUnemptyConstant("NO_VALUE")));
51 try std.testing.expect(!(environ.containsUnemptyConstant("NOT_SET")));
5152 if (builtin.os.tag == .windows) {
52 try std.testing.expect(std.process.hasNonEmptyEnvVarConstant("=HIDDEN"));
53 try std.testing.expect(std.process.hasNonEmptyEnvVarConstant("INVALID_UTF16_\xed\xa0\x80"));
53 try std.testing.expect(environ.containsUnemptyConstant("=HIDDEN"));
54 try std.testing.expect(environ.containsUnemptyConstant("INVALID_UTF16_\xed\xa0\x80"));
5455 }
5556 }
5657
57 // hasEnvVar
58 // contains
5859 {
59 try std.testing.expect(try std.process.hasEnvVar(allocator, "FOO"));
60 try std.testing.expect(!(try std.process.hasEnvVar(allocator, "FOO=")));
61 try std.testing.expect(!(try std.process.hasEnvVar(allocator, "FO")));
62 try std.testing.expect(!(try std.process.hasEnvVar(allocator, "FOOO")));
60 try std.testing.expect(try environ.contains(allocator, "FOO"));
61 try std.testing.expect(!(try environ.contains(allocator, "FOO=")));
62 try std.testing.expect(!(try environ.contains(allocator, "FO")));
63 try std.testing.expect(!(try environ.contains(allocator, "FOOO")));
6364 if (builtin.os.tag == .windows) {
64 try std.testing.expect(try std.process.hasEnvVar(allocator, "foo"));
65 try std.testing.expect(try environ.contains(allocator, "foo"));
6566 }
66 try std.testing.expect(try std.process.hasEnvVar(allocator, "EQUALS"));
67 try std.testing.expect(!(try std.process.hasEnvVar(allocator, "EQUALS=ABC")));
68 try std.testing.expect(try std.process.hasEnvVar(allocator, "КИРиллИЦА"));
67 try std.testing.expect(try environ.contains(allocator, "EQUALS"));
68 try std.testing.expect(!(try environ.contains(allocator, "EQUALS=ABC")));
69 try std.testing.expect(try environ.contains(allocator, "КИРиллИЦА"));
6970 if (builtin.os.tag == .windows) {
70 try std.testing.expect(try std.process.hasEnvVar(allocator, "кирИЛЛица"));
71 try std.testing.expect(try environ.contains(allocator, "кирИЛЛица"));
7172 }
72 try std.testing.expect(try std.process.hasEnvVar(allocator, "NO_VALUE"));
73 try std.testing.expect(!(try std.process.hasEnvVar(allocator, "NOT_SET")));
73 try std.testing.expect(try environ.contains(allocator, "NO_VALUE"));
74 try std.testing.expect(!(try environ.contains(allocator, "NOT_SET")));
7475 if (builtin.os.tag == .windows) {
75 try std.testing.expect(try std.process.hasEnvVar(allocator, "=HIDDEN"));
76 try std.testing.expect(try std.process.hasEnvVar(allocator, "INVALID_UTF16_\xed\xa0\x80"));
76 try std.testing.expect(try environ.contains(allocator, "=HIDDEN"));
77 try std.testing.expect(try environ.contains(allocator, "INVALID_UTF16_\xed\xa0\x80"));
7778 }
7879 }
7980
80 // hasEnvVarConstant
81 // containsConstant
8182 {
82 try std.testing.expect(std.process.hasEnvVarConstant("FOO"));
83 try std.testing.expect(!std.process.hasEnvVarConstant("FOO="));
84 try std.testing.expect(!std.process.hasEnvVarConstant("FO"));
85 try std.testing.expect(!std.process.hasEnvVarConstant("FOOO"));
83 try std.testing.expect(environ.containsConstant("FOO"));
84 try std.testing.expect(!environ.containsConstant("FOO="));
85 try std.testing.expect(!environ.containsConstant("FO"));
86 try std.testing.expect(!environ.containsConstant("FOOO"));
8687 if (builtin.os.tag == .windows) {
87 try std.testing.expect(std.process.hasEnvVarConstant("foo"));
88 try std.testing.expect(environ.containsConstant("foo"));
8889 }
89 try std.testing.expect(std.process.hasEnvVarConstant("EQUALS"));
90 try std.testing.expect(!std.process.hasEnvVarConstant("EQUALS=ABC"));
91 try std.testing.expect(std.process.hasEnvVarConstant("КИРиллИЦА"));
90 try std.testing.expect(environ.containsConstant("EQUALS"));
91 try std.testing.expect(!environ.containsConstant("EQUALS=ABC"));
92 try std.testing.expect(environ.containsConstant("КИРиллИЦА"));
9293 if (builtin.os.tag == .windows) {
93 try std.testing.expect(std.process.hasEnvVarConstant("кирИЛЛица"));
94 try std.testing.expect(environ.containsConstant("кирИЛЛица"));
9495 }
95 try std.testing.expect(std.process.hasEnvVarConstant("NO_VALUE"));
96 try std.testing.expect(!(std.process.hasEnvVarConstant("NOT_SET")));
96 try std.testing.expect(environ.containsConstant("NO_VALUE"));
97 try std.testing.expect(!(environ.containsConstant("NOT_SET")));
9798 if (builtin.os.tag == .windows) {
98 try std.testing.expect(std.process.hasEnvVarConstant("=HIDDEN"));
99 try std.testing.expect(std.process.hasEnvVarConstant("INVALID_UTF16_\xed\xa0\x80"));
99 try std.testing.expect(environ.containsConstant("=HIDDEN"));
100 try std.testing.expect(environ.containsConstant("INVALID_UTF16_\xed\xa0\x80"));
100101 }
101102 }
102103
103 // getEnvVarOwned
104 // getAlloc
104105 {
105 try std.testing.expectEqualSlices(u8, "123", try std.process.getEnvVarOwned(arena, "FOO"));
106 try std.testing.expectError(error.EnvironmentVariableNotFound, std.process.getEnvVarOwned(arena, "FOO="));
107 try std.testing.expectError(error.EnvironmentVariableNotFound, std.process.getEnvVarOwned(arena, "FO"));
108 try std.testing.expectError(error.EnvironmentVariableNotFound, std.process.getEnvVarOwned(arena, "FOOO"));
106 try std.testing.expectEqualSlices(u8, "123", try environ.getAlloc(arena, "FOO"));
107 try std.testing.expectError(error.EnvironmentVariableNotFound, environ.getAlloc(arena, "FOO="));
108 try std.testing.expectError(error.EnvironmentVariableNotFound, environ.getAlloc(arena, "FO"));
109 try std.testing.expectError(error.EnvironmentVariableNotFound, environ.getAlloc(arena, "FOOO"));
109110 if (builtin.os.tag == .windows) {
110 try std.testing.expectEqualSlices(u8, "123", try std.process.getEnvVarOwned(arena, "foo"));
111 try std.testing.expectEqualSlices(u8, "123", try environ.getAlloc(arena, "foo"));
111112 }
112 try std.testing.expectEqualSlices(u8, "ABC=123", try std.process.getEnvVarOwned(arena, "EQUALS"));
113 try std.testing.expectError(error.EnvironmentVariableNotFound, std.process.getEnvVarOwned(arena, "EQUALS=ABC"));
114 try std.testing.expectEqualSlices(u8, "non-ascii አማርኛ \u{10FFFF}", try std.process.getEnvVarOwned(arena, "КИРиллИЦА"));
113 try std.testing.expectEqualSlices(u8, "ABC=123", try environ.getAlloc(arena, "EQUALS"));
114 try std.testing.expectError(error.EnvironmentVariableNotFound, environ.getAlloc(arena, "EQUALS=ABC"));
115 try std.testing.expectEqualSlices(u8, "non-ascii አማርኛ \u{10FFFF}", try environ.getAlloc(arena, "КИРиллИЦА"));
115116 if (builtin.os.tag == .windows) {
116 try std.testing.expectEqualSlices(u8, "non-ascii አማርኛ \u{10FFFF}", try std.process.getEnvVarOwned(arena, "кирИЛЛица"));
117 try std.testing.expectEqualSlices(u8, "non-ascii አማርኛ \u{10FFFF}", try environ.getAlloc(arena, "кирИЛЛица"));
117118 }
118 try std.testing.expectEqualSlices(u8, "", try std.process.getEnvVarOwned(arena, "NO_VALUE"));
119 try std.testing.expectError(error.EnvironmentVariableNotFound, std.process.getEnvVarOwned(arena, "NOT_SET"));
119 try std.testing.expectEqualSlices(u8, "", try environ.getAlloc(arena, "NO_VALUE"));
120 try std.testing.expectError(error.EnvironmentVariableNotFound, environ.getAlloc(arena, "NOT_SET"));
120121 if (builtin.os.tag == .windows) {
121 try std.testing.expectEqualSlices(u8, "hi", try std.process.getEnvVarOwned(arena, "=HIDDEN"));
122 try std.testing.expectEqualSlices(u8, "\xed\xa0\x80", try std.process.getEnvVarOwned(arena, "INVALID_UTF16_\xed\xa0\x80"));
122 try std.testing.expectEqualSlices(u8, "hi", try environ.getAlloc(arena, "=HIDDEN"));
123 try std.testing.expectEqualSlices(u8, "\xed\xa0\x80", try environ.getAlloc(arena, "INVALID_UTF16_\xed\xa0\x80"));
123124 }
124125 }
125126
126 // parseEnvVarInt
127 // Environ.Map
127128 {
128 try std.testing.expectEqual(123, try std.process.parseEnvVarInt("FOO", u32, 10));
129 try std.testing.expectError(error.EnvironmentVariableNotFound, std.process.parseEnvVarInt("FO", u32, 10));
130 try std.testing.expectError(error.EnvironmentVariableNotFound, std.process.parseEnvVarInt("FOOO", u32, 10));
131 try std.testing.expectEqual(0x123, try std.process.parseEnvVarInt("FOO", u32, 16));
132 if (builtin.os.tag == .windows) {
133 try std.testing.expectEqual(123, try std.process.parseEnvVarInt("foo", u32, 10));
134 }
135 try std.testing.expectError(error.InvalidCharacter, std.process.parseEnvVarInt("EQUALS", u32, 10));
136 try std.testing.expectError(error.EnvironmentVariableNotFound, std.process.parseEnvVarInt("EQUALS=ABC", u32, 10));
137 try std.testing.expectError(error.InvalidCharacter, std.process.parseEnvVarInt("КИРиллИЦА", u32, 10));
138 try std.testing.expectError(error.InvalidCharacter, std.process.parseEnvVarInt("NO_VALUE", u32, 10));
139 try std.testing.expectError(error.EnvironmentVariableNotFound, std.process.parseEnvVarInt("NOT_SET", u32, 10));
140 if (builtin.os.tag == .windows) {
141 try std.testing.expectError(error.InvalidCharacter, std.process.parseEnvVarInt("=HIDDEN", u32, 10));
142 try std.testing.expectError(error.InvalidCharacter, std.process.parseEnvVarInt("INVALID_UTF16_\xed\xa0\x80", u32, 10));
143 }
144 }
145
146 // EnvMap
147 {
148 var env_map = try std.process.getEnvMap(allocator);
129 var env_map = try environ.createMap(allocator);
149130 defer env_map.deinit();
150131
151132 try std.testing.expectEqualSlices(u8, "123", env_map.get("FOO").?);
test/standalone/posix/getenv.zig+11-10
......@@ -1,9 +1,9 @@
1// test getting environment variables
1//! test getting environment variables
22
33const std = @import("std");
44const builtin = @import("builtin");
55
6pub fn main() !void {
6pub fn main(init: std.process.Init.Minimal) !void {
77 if (builtin.target.os.tag == .windows) {
88 return; // Windows env strings are WTF-16, so not supported by Zig's std.posix.getenv()
99 }
......@@ -12,21 +12,22 @@ pub fn main() !void {
1212 return; // std.posix.getenv is not supported on WASI due to the need of allocation
1313 }
1414
15 // Test some unset env vars:
15 const environ = init.environ;
1616
17 try std.testing.expectEqual(std.posix.getenv(""), null);
18 try std.testing.expectEqual(std.posix.getenv("BOGUSDOESNOTEXISTENVVAR"), null);
19 try std.testing.expectEqual(std.posix.getenvZ("BOGUSDOESNOTEXISTENVVAR"), null);
17 // Test some unset env vars:
18 try std.testing.expectEqual(environ.getPosix(""), null);
19 try std.testing.expectEqual(environ.getPosix("BOGUSDOESNOTEXISTENVVAR"), null);
20 try std.testing.expectEqual(environ.getPosix("BOGUSDOESNOTEXISTENVVAR"), null);
2021
2122 if (builtin.link_libc) {
2223 // Test if USER matches what C library sees
2324 const expected = std.mem.span(std.c.getenv("USER") orelse "");
24 const actual = std.posix.getenv("USER") orelse "";
25 const actual = environ.getPosix("USER") orelse "";
2526 try std.testing.expectEqualStrings(expected, actual);
2627 }
2728
2829 // env vars set by our build.zig run step:
29 try std.testing.expectEqualStrings("", std.posix.getenv("ZIG_TEST_POSIX_EMPTY") orelse "invalid");
30 try std.testing.expectEqualStrings("test=variable", std.posix.getenv("ZIG_TEST_POSIX_1EQ") orelse "invalid");
31 try std.testing.expectEqualStrings("=test=variable=", std.posix.getenv("ZIG_TEST_POSIX_3EQ") orelse "invalid");
30 try std.testing.expectEqualStrings("", environ.getPosix("ZIG_TEST_POSIX_EMPTY") orelse "invalid");
31 try std.testing.expectEqualStrings("test=variable", environ.getPosix("ZIG_TEST_POSIX_1EQ") orelse "invalid");
32 try std.testing.expectEqualStrings("=test=variable=", environ.getPosix("ZIG_TEST_POSIX_3EQ") orelse "invalid");
3233}
test/standalone/run_output_caching/main.zig+1-1
......@@ -2,7 +2,7 @@ const std = @import("std");
22
33pub fn main(init: std.process.Init) !void {
44 const io = init.io;
5 var args = try init.minimal.argsAllocator(init.arena.allocator());
5 var args = try init.minimal.args.iterateAllocator(init.arena.allocator());
66 _ = args.skip();
77 const filename = args.next().?;
88 const file = try std.Io.Dir.cwd().createFile(io, filename, .{});
test/standalone/run_output_paths/create_file.zig+1-1
......@@ -2,7 +2,7 @@ const std = @import("std");
22
33pub fn main(init: std.process.Init) !void {
44 const io = init.io;
5 var args = try init.args.iterateAllocator(init.arena.allocator());
5 var args = try init.minimal.args.iterateAllocator(init.arena.allocator());
66 _ = args.skip();
77 const dir_name = args.next().?;
88 const dir = try std.Io.Dir.cwd().openDir(io, if (std.mem.startsWith(u8, dir_name, "--dir="))
test/standalone/self_exe_symlink/create-symlink.zig+4-2
......@@ -3,14 +3,16 @@ const std = @import("std");
33pub fn main(init: std.process.Init) !void {
44 const io = init.io;
55 const gpa = init.gpa;
6 var it = try init.args.iterateAllocator(gpa);
6 var it = try init.minimal.args.iterateAllocator(gpa);
77 defer it.deinit();
88 _ = it.next() orelse unreachable; // skip binary name
99 const exe_path = it.next() orelse unreachable;
1010 const symlink_path = it.next() orelse unreachable;
1111
12 const cwd = std.process.getCwdAlloc(init.arena.allocator());
13
1214 // If `exe_path` is relative to our cwd, we need to convert it to be relative to the dirname of `symlink_path`.
13 const exe_rel_path = try std.fs.path.relative(gpa, std.fs.path.dirname(symlink_path) orelse ".", exe_path);
15 const exe_rel_path = try std.fs.path.relative(gpa, cwd, init.env_map, std.fs.path.dirname(symlink_path) orelse ".", exe_path);
1416 defer gpa.free(exe_rel_path);
1517
1618 try std.Io.Dir.cwd().symLink(io, exe_rel_path, symlink_path, .{});
test/standalone/self_exe_symlink/main.zig+3-8
......@@ -1,13 +1,8 @@
11const std = @import("std");
22
3pub fn main() !void {
4 var debug_allocator: std.heap.DebugAllocator(.{}) = .init;
5 defer if (debug_allocator.deinit() == .leak) @panic("found memory leaks");
6 const gpa = debug_allocator.allocator();
7
8 var threaded: std.Io.Threaded = .init(gpa, .{});
9 defer threaded.deinit();
10 const io = threaded.io();
3pub fn main(init: std.process.Init) !void {
4 const gpa = init.gpa;
5 const io = init.io;
116
127 const self_path = try std.process.executablePathAlloc(io, gpa);
138 defer gpa.free(self_path);
test/standalone/simple/cat/main.zig+1-1
......@@ -7,7 +7,7 @@ const fatal = std.process.fatal;
77pub fn main(init: std.process.Init) !void {
88 const arena = init.arena.allocator();
99 const io = init.io;
10 const args = try init.args.toSlice(arena);
10 const args = try init.minimal.args.toSlice(arena);
1111
1212 const exe = args[0];
1313 var catted_anything = false;
test/standalone/simple/guess_number/main.zig+3-14
......@@ -1,22 +1,11 @@
1const builtin = @import("builtin");
21const std = @import("std");
32
4// See https://github.com/ziglang/zig/issues/24510
5// for the plan to simplify this code.
6pub fn main() !void {
7 var debug_allocator: std.heap.DebugAllocator(.{}) = .init;
8 defer _ = debug_allocator.deinit();
9 const gpa = debug_allocator.allocator();
10
11 var threaded: std.Io.Threaded = .init(gpa, .{});
12 defer threaded.deinit();
13 const io = threaded.io();
14
15 var stdout_writer = std.Io.File.stdout().writerStreaming(io, &.{});
3pub fn main(init: std.process.Init) !void {
4 var stdout_writer = std.Io.File.stdout().writerStreaming(init.io, &.{});
165 const out = &stdout_writer.interface;
176
187 var line_buffer: [20]u8 = undefined;
19 var stdin_reader: std.Io.File.Reader = .init(.stdin(), io, &line_buffer);
8 var stdin_reader: std.Io.File.Reader = .init(.stdin(), init.io, &line_buffer);
209 const in = &stdin_reader.interface;
2110
2211 try out.writeAll("Welcome to the Guess Number Game in Zig.\n");
test/standalone/windows_bat_args/fuzz.zig+1-1
......@@ -93,7 +93,7 @@ fn testExecBat(gpa: Allocator, io: Io, bat: []const u8, args: []const []const u8
9393
9494 const can_have_trailing_empty_args = std.mem.eql(u8, bat, "args3.bat");
9595
96 const result = try std.process.Child.run(gpa, io, .{
96 const result = try std.process.run(gpa, io, .{
9797 .env_map = env,
9898 .argv = argv,
9999 });
test/standalone/windows_bat_args/test.zig+1-1
......@@ -140,7 +140,7 @@ fn testExecBat(gpa: Allocator, io: Io, bat: []const u8, args: []const []const u8
140140
141141 const can_have_trailing_empty_args = std.mem.eql(u8, bat, "args3.bat");
142142
143 const result = try std.process.Child.run(gpa, io, .{
143 const result = try std.process.run(gpa, io, .{
144144 .env_map = env,
145145 .argv = argv,
146146 });
test/standalone/windows_paths/test.zig+1-1
......@@ -98,7 +98,7 @@ fn checkRelative(
9898 cwd: ?[]const u8,
9999 env_map: ?*const std.process.Environ.Map,
100100) !void {
101 const result = try std.process.Child.run(allocator, io, .{
101 const result = try std.process.run(allocator, io, .{
102102 .argv = argv,
103103 .cwd = cwd,
104104 .env_map = env_map,
test/standalone/windows_spawn/main.zig+1-1
......@@ -207,7 +207,7 @@ fn testExec(gpa: Allocator, io: Io, command: []const u8, expected_stdout: []cons
207207}
208208
209209fn testExecWithCwd(gpa: Allocator, io: Io, command: []const u8, cwd: ?[]const u8, expected_stdout: []const u8) !void {
210 const result = try std.process.Child.run(gpa, io, .{
210 const result = try std.process.run(gpa, io, .{
211211 .argv = &[_][]const u8{command},
212212 .cwd = cwd,
213213 });
tools/doctest.zig+14-14
......@@ -193,14 +193,14 @@ fn printOutput(
193193 try shell_out.print("\n", .{});
194194
195195 if (expected_outcome == .build_fail) {
196 const result = try process.Child.run(arena, io, .{
196 const result = try process.run(arena, io, .{
197197 .argv = build_args.items,
198198 .cwd = tmp_dir_path,
199199 .env_map = &env_map,
200200 .max_output_bytes = max_doc_file_size,
201201 });
202202 switch (result.term) {
203 .Exited => |exit_code| {
203 .exited => |exit_code| {
204204 if (exit_code == 0) {
205205 print("{s}\nThe following command incorrectly succeeded:\n", .{result.stderr});
206206 dumpArgs(build_args.items);
......@@ -249,21 +249,21 @@ fn printOutput(
249249 var exited_with_signal = false;
250250
251251 const result = if (expected_outcome == .fail) blk: {
252 const result = try process.Child.run(arena, io, .{
252 const result = try process.run(arena, io, .{
253253 .argv = run_args,
254254 .env_map = &env_map,
255255 .cwd = tmp_dir_path,
256256 .max_output_bytes = max_doc_file_size,
257257 });
258258 switch (result.term) {
259 .Exited => |exit_code| {
259 .exited => |exit_code| {
260260 if (exit_code == 0) {
261261 print("{s}\nThe following command incorrectly succeeded:\n", .{result.stderr});
262262 dumpArgs(run_args);
263263 fatal("example incorrectly compiled", .{});
264264 }
265265 },
266 .Signal => exited_with_signal = true,
266 .signal => exited_with_signal = true,
267267 else => {},
268268 }
269269 break :blk result;
......@@ -368,14 +368,14 @@ fn printOutput(
368368 try test_args.append("-lc");
369369 try shell_out.print("-lc ", .{});
370370 }
371 const result = try process.Child.run(arena, io, .{
371 const result = try process.run(arena, io, .{
372372 .argv = test_args.items,
373373 .env_map = &env_map,
374374 .cwd = tmp_dir_path,
375375 .max_output_bytes = max_doc_file_size,
376376 });
377377 switch (result.term) {
378 .Exited => |exit_code| {
378 .exited => |exit_code| {
379379 if (exit_code == 0) {
380380 print("{s}\nThe following command incorrectly succeeded:\n", .{result.stderr});
381381 dumpArgs(test_args.items);
......@@ -424,14 +424,14 @@ fn printOutput(
424424 },
425425 }
426426
427 const result = try process.Child.run(arena, io, .{
427 const result = try process.run(arena, io, .{
428428 .argv = test_args.items,
429429 .env_map = &env_map,
430430 .cwd = tmp_dir_path,
431431 .max_output_bytes = max_doc_file_size,
432432 });
433433 switch (result.term) {
434 .Exited => |exit_code| {
434 .exited => |exit_code| {
435435 if (exit_code == 0) {
436436 print("{s}\nThe following command incorrectly succeeded:\n", .{result.stderr});
437437 dumpArgs(test_args.items);
......@@ -500,14 +500,14 @@ fn printOutput(
500500 }
501501
502502 if (maybe_error_match) |error_match| {
503 const result = try process.Child.run(arena, io, .{
503 const result = try process.run(arena, io, .{
504504 .argv = build_args.items,
505505 .env_map = &env_map,
506506 .cwd = tmp_dir_path,
507507 .max_output_bytes = max_doc_file_size,
508508 });
509509 switch (result.term) {
510 .Exited => |exit_code| {
510 .exited => |exit_code| {
511511 if (exit_code == 0) {
512512 print("{s}\nThe following command incorrectly succeeded:\n", .{result.stderr});
513513 dumpArgs(build_args.items);
......@@ -1123,15 +1123,15 @@ fn run(
11231123 env_map: *process.Environ.Map,
11241124 cwd: []const u8,
11251125 args: []const []const u8,
1126) !process.Child.RunResult {
1127 const result = try process.Child.run(allocator, io, .{
1126) !process.RunResult {
1127 const result = try process.run(allocator, io, .{
11281128 .argv = args,
11291129 .env_map = env_map,
11301130 .cwd = cwd,
11311131 .max_output_bytes = max_doc_file_size,
11321132 });
11331133 switch (result.term) {
1134 .Exited => |exit_code| {
1134 .exited => |exit_code| {
11351135 if (exit_code != 0) {
11361136 std.debug.print("{s}\nThe following command exited with code {}:\n", .{ result.stderr, exit_code });
11371137 dumpArgs(args);
tools/dump-cov.zig+2-2
......@@ -10,9 +10,9 @@ const SeenPcsHeader = std.Build.abi.fuzz.SeenPcsHeader;
1010
1111pub fn main(init: std.process.Init) !void {
1212 const gpa = init.gpa;
13 const arena = init.arena;
13 const arena = init.arena.allocator();
1414 const io = init.io;
15 const args = try init.args.toSlice(arena);
15 const args = try init.minimal.args.toSlice(arena);
1616
1717 const target_query_str = switch (args.len) {
1818 3 => "native",
tools/fetch_them_macos_headers.zig+2-2
......@@ -68,7 +68,7 @@ const usage =
6868
6969pub fn main(init: std.process.Init) !void {
7070 const allocator = init.arena;
71 const args = try init.args.toSlice(allocator);
71 const args = try init.minimal.args.toSlice(allocator);
7272
7373 var argv = std.array_list.Managed([]const u8).init(allocator);
7474 var sysroot: ?[]const u8 = null;
......@@ -161,7 +161,7 @@ fn fetchTarget(
161161 });
162162 try cc_argv.appendSlice(args);
163163
164 const res = try std.process.Child.run(arena, io, .{ .argv = cc_argv.items });
164 const res = try std.process.run(arena, io, .{ .argv = cc_argv.items });
165165
166166 if (res.stderr.len != 0) {
167167 std.log.err("{s}", .{res.stderr});
tools/gen_macos_headers_c.zig+1-1
......@@ -16,8 +16,8 @@ const usage =
1616pub fn main(init: std.process.Init) !void {
1717 const arena = init.arena;
1818 const io = init.io;
19 const args = try init.minimal.args.toSlice(arena);
1920
20 const args = try init.args.toSlice(arena);
2121 if (args.len == 1) fatal("no command or option specified", .{});
2222
2323 var positionals = std.array_list.Managed([]const u8).init(arena);
tools/gen_outline_atomics.zig+1-1
......@@ -12,7 +12,7 @@ const AtomicOp = enum {
1212};
1313
1414pub fn main(init: std.process.Init) !void {
15 const arena = init.arena;
15 const arena = init.arena.allocator();
1616 const io = init.io;
1717
1818 //const args = try std.process.argsAlloc(arena);
tools/gen_spirv_spec.zig+49-49
......@@ -1,6 +1,7 @@
11const std = @import("std");
22const Io = std.Io;
33const Allocator = std.mem.Allocator;
4const assert = std.debug.assert;
45
56const g = @import("spirv/grammar.zig");
67const CoreRegistry = g.CoreRegistry;
......@@ -54,28 +55,22 @@ const set_names = std.StaticStringMap(struct { []const u8, []const u8 }).initCom
5455 .{ "zig", .{ "zig", "Zig" } },
5556});
5657
57var arena = std.heap.ArenaAllocator.init(std.heap.smp_allocator);
58const allocator = arena.allocator();
59
60pub fn main() !void {
61 defer arena.deinit();
62
63 const args = try std.process.argsAlloc(allocator);
58pub fn main(init: std.process.Init) !void {
59 const arena = init.arena.allocator();
60 const args = try init.minimal.args.toSlice(arena);
6461 if (args.len != 3) {
6562 usageAndExit(args[0], 1);
6663 }
6764
68 var threaded: std.Io.Threaded = .init(allocator, .{});
69 defer threaded.deinit();
70 const io = threaded.io();
65 const io = init.io;
7166
72 const json_path = try Io.Dir.path.join(allocator, &.{ args[1], "include/spirv/unified1/" });
67 const json_path = try Io.Dir.path.join(arena, &.{ args[1], "include/spirv/unified1/" });
7368 const dir = try Io.Dir.cwd().openDir(io, json_path, .{ .iterate = true });
7469
75 const core_spec = try readRegistry(io, CoreRegistry, dir, "spirv.core.grammar.json");
70 const core_spec = try readRegistry(io, arena, CoreRegistry, dir, "spirv.core.grammar.json");
7671 std.mem.sortUnstable(Instruction, core_spec.instructions, CmpInst{}, CmpInst.lt);
7772
78 var exts = std.array_list.Managed(Extension).init(allocator);
73 var exts = std.array_list.Managed(Extension).init(arena);
7974
8075 var it = dir.iterate();
8176 while (try it.next(io)) |entry| {
......@@ -83,48 +78,48 @@ pub fn main() !void {
8378 continue;
8479 }
8580
86 try readExtRegistry(io, &exts, dir, entry.name);
81 try readExtRegistry(io, arena, &exts, dir, entry.name);
8782 }
8883
89 try readExtRegistry(io, &exts, Io.Dir.cwd(), args[2]);
84 try readExtRegistry(io, arena, &exts, Io.Dir.cwd(), args[2]);
9085
91 var allocating: std.Io.Writer.Allocating = .init(allocator);
86 var allocating: std.Io.Writer.Allocating = .init(arena);
9287 defer allocating.deinit();
93 try render(&allocating.writer, core_spec, exts.items);
88 try render(arena, &allocating.writer, core_spec, exts.items);
9489 try allocating.writer.writeByte(0);
9590 const output = allocating.written()[0 .. allocating.written().len - 1 :0];
9691
97 var tree = try std.zig.Ast.parse(allocator, output, .zig);
92 var tree = try std.zig.Ast.parse(arena, output, .zig);
9893
9994 if (tree.errors.len != 0) {
100 try std.zig.printAstErrorsToStderr(allocator, io, tree, "", .auto);
95 try std.zig.printAstErrorsToStderr(arena, io, tree, "", .auto);
10196 return;
10297 }
10398
104 var zir = try std.zig.AstGen.generate(allocator, tree);
99 var zir = try std.zig.AstGen.generate(arena, tree);
105100 if (zir.hasCompileErrors()) {
106101 var wip_errors: std.zig.ErrorBundle.Wip = undefined;
107 try wip_errors.init(allocator);
102 try wip_errors.init(arena);
108103 defer wip_errors.deinit();
109104 try wip_errors.addZirErrorMessages(zir, tree, output, "");
110105 var error_bundle = try wip_errors.toOwnedBundle("");
111 defer error_bundle.deinit(allocator);
106 defer error_bundle.deinit(arena);
112107 try error_bundle.renderToStderr(io, .{}, .auto);
113108 }
114109
115 const formatted_output = try tree.renderAlloc(allocator);
110 const formatted_output = try tree.renderAlloc(arena);
116111 try Io.File.stdout().writeStreamingAll(io, formatted_output);
117112}
118113
119fn readExtRegistry(io: Io, exts: *std.array_list.Managed(Extension), dir: Io.Dir, sub_path: []const u8) !void {
114fn readExtRegistry(io: Io, arena: Allocator, exts: *std.array_list.Managed(Extension), dir: Io.Dir, sub_path: []const u8) !void {
120115 const filename = Io.Dir.path.basename(sub_path);
121116 if (!std.mem.startsWith(u8, filename, "extinst.")) {
122117 return;
123118 }
124119
125 std.debug.assert(std.mem.endsWith(u8, filename, ".grammar.json"));
120 assert(std.mem.endsWith(u8, filename, ".grammar.json"));
126121 const name = filename["extinst.".len .. filename.len - ".grammar.json".len];
127 const spec = try readRegistry(io, ExtensionRegistry, dir, sub_path);
122 const spec = try readRegistry(io, arena, ExtensionRegistry, dir, sub_path);
128123
129124 const set_name = set_names.get(name) orelse {
130125 std.log.info("ignored instruction set '{s}'", .{name});
......@@ -140,16 +135,16 @@ fn readExtRegistry(io: Io, exts: *std.array_list.Managed(Extension), dir: Io.Dir
140135 });
141136}
142137
143fn readRegistry(io: Io, comptime RegistryType: type, dir: Io.Dir, path: []const u8) !RegistryType {
144 const spec = try dir.readFileAlloc(io, path, allocator, .unlimited);
138fn readRegistry(io: Io, arena: Allocator, comptime RegistryType: type, dir: Io.Dir, path: []const u8) !RegistryType {
139 const spec = try dir.readFileAlloc(io, path, arena, .unlimited);
145140 // Required for json parsing.
146141 // TODO: ALI
147142 @setEvalBranchQuota(10000);
148143
149 var scanner = std.json.Scanner.initCompleteInput(allocator, spec);
144 var scanner = std.json.Scanner.initCompleteInput(arena, spec);
150145 var diagnostics = std.json.Diagnostics{};
151146 scanner.enableDiagnostics(&diagnostics);
152 const parsed = std.json.parseFromTokenSource(RegistryType, allocator, &scanner, .{}) catch |err| {
147 const parsed = std.json.parseFromTokenSource(RegistryType, arena, &scanner, .{}) catch |err| {
153148 std.debug.print("{s}:{}:{}:\n", .{ path, diagnostics.getLine(), diagnostics.getColumn() });
154149 return err;
155150 };
......@@ -158,8 +153,8 @@ fn readRegistry(io: Io, comptime RegistryType: type, dir: Io.Dir, path: []const
158153
159154/// Returns a set with types that require an extra struct for the `Instruction` interface
160155/// to the spir-v spec, or whether the original type can be used.
161fn extendedStructs(kinds: []const OperandKind) !ExtendedStructSet {
162 var map = ExtendedStructSet.init(allocator);
156fn extendedStructs(arena: Allocator, kinds: []const OperandKind) !ExtendedStructSet {
157 var map = ExtendedStructSet.init(arena);
163158 try map.ensureTotalCapacity(@as(u32, @intCast(kinds.len)));
164159
165160 for (kinds) |kind| {
......@@ -194,6 +189,7 @@ fn tagPriorityScore(tag: []const u8) usize {
194189}
195190
196191fn render(
192 arena: Allocator,
197193 writer: *std.Io.Writer,
198194 registry: CoreRegistry,
199195 extensions: []const Extension,
......@@ -299,7 +295,7 @@ fn render(
299295 );
300296
301297 // Merge the operand kinds from all extensions together.
302 var all_operand_kinds = OperandKindMap.init(allocator);
298 var all_operand_kinds = OperandKindMap.init(arena);
303299 for (registry.operand_kinds) |kind| {
304300 try all_operand_kinds.putNoClobber(.{ "core", kind.kind }, kind);
305301 }
......@@ -312,22 +308,22 @@ fn render(
312308 try all_operand_kinds.ensureUnusedCapacity(ext.spec.operand_kinds.len);
313309 for (ext.spec.operand_kinds) |kind| {
314310 var new_kind = kind;
315 new_kind.kind = try std.mem.join(allocator, ".", &.{ ext.name, kind.kind });
311 new_kind.kind = try std.mem.join(arena, ".", &.{ ext.name, kind.kind });
316312 try all_operand_kinds.putNoClobber(.{ ext.name, kind.kind }, new_kind);
317313 }
318314 }
319315
320 const extended_structs = try extendedStructs(all_operand_kinds.values());
316 const extended_structs = try extendedStructs(arena, all_operand_kinds.values());
321317 // Note: extensions don't seem to have class.
322 try renderClass(writer, registry.instructions);
318 try renderClass(arena, writer, registry.instructions);
323319 try renderOperandKind(writer, all_operand_kinds.values());
324320
325 try renderOpcodes(writer, "Opcode", true, registry.instructions, extended_structs);
321 try renderOpcodes(arena, writer, "Opcode", true, registry.instructions, extended_structs);
326322 for (extensions) |ext| {
327 try renderOpcodes(writer, ext.opcode_name, false, ext.spec.instructions, extended_structs);
323 try renderOpcodes(arena, writer, ext.opcode_name, false, ext.spec.instructions, extended_structs);
328324 }
329325
330 try renderOperandKinds(writer, all_operand_kinds.values(), extended_structs);
326 try renderOperandKinds(arena, writer, all_operand_kinds.values(), extended_structs);
331327 try renderInstructionSet(writer, registry, extensions, all_operand_kinds);
332328}
333329
......@@ -414,8 +410,8 @@ fn renderInstructionsCase(
414410 );
415411}
416412
417fn renderClass(writer: *std.Io.Writer, instructions: []const Instruction) !void {
418 var class_map = std.StringArrayHashMap(void).init(allocator);
413fn renderClass(arena: Allocator, writer: *std.Io.Writer, instructions: []const Instruction) !void {
414 var class_map = std.StringArrayHashMap(void).init(arena);
419415
420416 for (instructions) |inst| {
421417 if (std.mem.eql(u8, inst.class.?, "@exclude")) continue;
......@@ -535,16 +531,17 @@ fn renderEnumerant(writer: *std.Io.Writer, enumerant: Enumerant) !void {
535531}
536532
537533fn renderOpcodes(
534 arena: Allocator,
538535 writer: *std.Io.Writer,
539536 opcode_type_name: []const u8,
540537 want_operands: bool,
541538 instructions: []const Instruction,
542539 extended_structs: ExtendedStructSet,
543540) !void {
544 var inst_map = std.AutoArrayHashMap(u32, usize).init(allocator);
541 var inst_map = std.AutoArrayHashMap(u32, usize).init(arena);
545542 try inst_map.ensureTotalCapacity(instructions.len);
546543
547 var aliases = std.array_list.Managed(struct { inst: usize, alias: usize }).init(allocator);
544 var aliases = std.array_list.Managed(struct { inst: usize, alias: usize }).init(arena);
548545 try aliases.ensureTotalCapacity(instructions.len);
549546
550547 for (instructions, 0..) |inst, i| {
......@@ -634,30 +631,32 @@ fn renderOpcodes(
634631}
635632
636633fn renderOperandKinds(
634 arena: Allocator,
637635 writer: *std.Io.Writer,
638636 kinds: []const OperandKind,
639637 extended_structs: ExtendedStructSet,
640638) !void {
641639 for (kinds) |kind| {
642640 switch (kind.category) {
643 .ValueEnum => try renderValueEnum(writer, kind, extended_structs),
644 .BitEnum => try renderBitEnum(writer, kind, extended_structs),
641 .ValueEnum => try renderValueEnum(arena, writer, kind, extended_structs),
642 .BitEnum => try renderBitEnum(arena, writer, kind, extended_structs),
645643 else => {},
646644 }
647645 }
648646}
649647
650648fn renderValueEnum(
649 arena: Allocator,
651650 writer: *std.Io.Writer,
652651 enumeration: OperandKind,
653652 extended_structs: ExtendedStructSet,
654653) !void {
655654 const enumerants = enumeration.enumerants orelse return error.InvalidRegistry;
656655
657 var enum_map = std.AutoArrayHashMap(u32, usize).init(allocator);
656 var enum_map = std.AutoArrayHashMap(u32, usize).init(arena);
658657 try enum_map.ensureTotalCapacity(enumerants.len);
659658
660 var aliases = std.array_list.Managed(struct { enumerant: usize, alias: usize }).init(allocator);
659 var aliases = std.array_list.Managed(struct { enumerant: usize, alias: usize }).init(arena);
661660 try aliases.ensureTotalCapacity(enumerants.len);
662661
663662 for (enumerants, 0..) |enumerant, i| {
......@@ -726,6 +725,7 @@ fn renderValueEnum(
726725}
727726
728727fn renderBitEnum(
728 arena: Allocator,
729729 writer: *std.Io.Writer,
730730 enumeration: OperandKind,
731731 extended_structs: ExtendedStructSet,
......@@ -735,7 +735,7 @@ fn renderBitEnum(
735735 var flags_by_bitpos = [_]?usize{null} ** 32;
736736 const enumerants = enumeration.enumerants orelse return error.InvalidRegistry;
737737
738 var aliases = std.array_list.Managed(struct { flag: usize, alias: u5 }).init(allocator);
738 var aliases = std.array_list.Managed(struct { flag: usize, alias: u5 }).init(arena);
739739 try aliases.ensureTotalCapacity(enumerants.len);
740740
741741 for (enumerants, 0..) |enumerant, i| {
......@@ -749,7 +749,7 @@ fn renderBitEnum(
749749 continue;
750750 }
751751
752 std.debug.assert(@popCount(value) == 1);
752 assert(@popCount(value) == 1);
753753
754754 const bitpos = std.math.log2_int(u32, value);
755755 if (flags_by_bitpos[bitpos]) |*existing| {
tools/gen_stubs.zig+4-10
......@@ -281,16 +281,10 @@ const Parse = struct {
281281 arch: Arch,
282282};
283283
284pub fn main() !void {
285 var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);
286 defer arena_instance.deinit();
287 const arena = arena_instance.allocator();
288
289 var threaded: std.Io.Threaded = .init(arena, .{});
290 defer threaded.deinit();
291 const io = threaded.io();
292
293 const args = try std.process.argsAlloc(arena);
284pub fn main(init: std.process.Init) !void {
285 const arena = init.arena.allocator();
286 const io = init.io;
287 const args = try init.minimal.args.toSlice(arena);
294288 const build_all_path = args[1];
295289
296290 var build_all_dir = try Io.Dir.cwd().openDir(io, build_all_path, .{});
tools/generate_c_size_and_align_checks.zig+1-1
......@@ -29,7 +29,7 @@ fn cName(ty: std.Target.CType) []const u8 {
2929var general_purpose_allocator: std.heap.GeneralPurposeAllocator(.{}) = .init;
3030
3131pub fn main(init: std.process.Init) !void {
32 const args = try init.args.toSlice(init.arena);
32 const args = try init.minimal.args.toSlice(init.arena.allocator());
3333 const io = init.io;
3434
3535 if (args.len != 2) {
tools/generate_linux_syscalls.zig+1-1
......@@ -174,7 +174,7 @@ pub fn main(init: std.process.Init) !void {
174174 const gpa = init.gpa;
175175 const io = init.io;
176176
177 const args = try std.process.argsAlloc(gpa);
177 const args = try init.minimal.args.toSlice(init.arena.allocator());
178178 if (args.len < 2 or mem.eql(u8, args[1], "--help")) {
179179 const stderr = std.debug.lockStderr(&.{});
180180 const w = &stderr.file_writer.interface;
tools/incr-check.zig+24-22
......@@ -171,14 +171,6 @@ pub fn main(init: std.process.Init) !void {
171171 const zig_prog_node = target_prog_node.start("zig build-exe", 0);
172172 defer zig_prog_node.end();
173173
174 var child = std.process.Child.init(child_args.items, arena);
175 child.stdin_behavior = .Pipe;
176 child.stdout_behavior = .Pipe;
177 child.stderr_behavior = .Pipe;
178 child.progress_node = zig_prog_node;
179 child.cwd_dir = tmp_dir;
180 child.cwd = tmp_dir_path;
181
182174 var cc_child_args: std.ArrayList([]const u8) = .empty;
183175 if (target.backend == .cbe) {
184176 const resolved_cc_zig_exe = if (opt_cc_zig) |cc_zig_exe|
......@@ -201,6 +193,17 @@ pub fn main(init: std.process.Init) !void {
201193 try cc_child_args.append(arena, "-o");
202194 }
203195
196 var child = std.process.spawn(io, .{
197 .argv = child_args.items,
198 .stdin = .pipe,
199 .stdout = .pipe,
200 .stderr = .pipe,
201 .progress_node = zig_prog_node,
202 .cwd_dir = tmp_dir,
203 .cwd = tmp_dir_path,
204 });
205 defer child.kill(io);
206
204207 var eval: Eval = .{
205208 .arena = arena,
206209 .io = io,
......@@ -219,11 +222,6 @@ pub fn main(init: std.process.Init) !void {
219222 .enable_darling = enable_darling,
220223 };
221224
222 try child.spawn(io);
223 errdefer {
224 _ = child.kill(io) catch {};
225 }
226
227225 var poller = Io.poll(arena, Eval.StreamEnum, .{
228226 .stdout = child.stdout.?,
229227 .stderr = child.stderr.?,
......@@ -528,7 +526,7 @@ const Eval = struct {
528526 const run_prog_node = prog_node.start("run generated executable", 0);
529527 defer run_prog_node.end();
530528
531 const result = std.process.Child.run(eval.arena, io, .{
529 const result = std.process.run(eval.arena, io, .{
532530 .argv = argv,
533531 .cwd_dir = eval.tmp_dir,
534532 .cwd = eval.tmp_dir_path,
......@@ -556,7 +554,7 @@ const Eval = struct {
556554 }
557555
558556 switch (result.term) {
559 .Exited => |code| switch (update.outcome) {
557 .exited => |code| switch (update.outcome) {
560558 .unknown, .compile_errors => unreachable,
561559 .stdout => |expected_stdout| {
562560 if (code != 0) {
......@@ -564,9 +562,12 @@ const Eval = struct {
564562 }
565563 try std.testing.expectEqualStrings(expected_stdout, result.stdout);
566564 },
567 .exit_code => |expected_code| try std.testing.expectEqual(expected_code, result.term.Exited),
565 .exit_code => |expected_code| try std.testing.expectEqual(expected_code, code),
566 },
567 .signal => |sig| {
568 eval.fatal("generated executable '{s}' terminated with signal {t}", .{ binary_path, sig });
568569 },
569 .Signal, .Stopped, .Unknown => {
570 .stopped, .unknown => {
570571 eval.fatal("generated executable '{s}' terminated unexpectedly", .{binary_path});
571572 },
572573 }
......@@ -614,7 +615,7 @@ const Eval = struct {
614615 try eval.cc_child_args.appendSlice(eval.arena, &.{ out_path, c_path });
615616 defer eval.cc_child_args.items.len -= 2;
616617
617 const result = std.process.Child.run(eval.arena, eval.io, .{
618 const result = std.process.run(eval.arena, eval.io, .{
618619 .argv = eval.cc_child_args.items,
619620 .cwd_dir = eval.tmp_dir,
620621 .cwd = eval.tmp_dir_path,
......@@ -623,13 +624,13 @@ const Eval = struct {
623624 eval.fatal("failed to spawn zig cc for '{s}': {t}", .{ c_path, err });
624625 };
625626 switch (result.term) {
626 .Exited => |code| if (code != 0) {
627 .exited => |code| if (code != 0) {
627628 if (result.stderr.len != 0) {
628629 std.log.err("zig cc stderr:\n{s}", .{result.stderr});
629630 }
630631 eval.fatal("zig cc for '{s}' failed with code {d}", .{ c_path, code });
631632 },
632 .Signal, .Stopped, .Unknown => {
633 .signal, .stopped, .unknown => {
633634 if (result.stderr.len != 0) {
634635 std.log.err("zig cc stderr:\n{s}", .{result.stderr});
635636 }
......@@ -909,8 +910,9 @@ fn waitChild(child: *std.process.Child, eval: *Eval) void {
909910 requestExit(child, eval);
910911 const term = child.wait(io) catch |err| eval.fatal("child process failed: {t}", .{err});
911912 switch (term) {
912 .Exited => |code| if (code != 0) eval.fatal("compiler failed with code {d}", .{code}),
913 .Signal, .Stopped, .Unknown => eval.fatal("compiler terminated unexpectedly", .{}),
913 .exited => |code| if (code != 0) eval.fatal("compiler failed with code {d}", .{code}),
914 .signal => |sig| eval.fatal("compiler terminated with signal {t}", .{sig}),
915 .stopped, .unknown => eval.fatal("compiler terminated unexpectedly", .{}),
914916 }
915917}
916918
tools/migrate_langref.zig+4-11
......@@ -11,21 +11,14 @@ const fatal = std.process.fatal;
1111
1212const max_doc_file_size = 10 * 1024 * 1024;
1313
14pub fn main() !void {
15 var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);
16 defer arena_instance.deinit();
17 const arena = arena_instance.allocator();
14pub fn main(init: std.process.Init) !void {
15 const arena = init.arena.allocator();
16 const io = init.io;
17 const args = try init.minimal.args.toSlice(arena);
1818
19 const gpa = arena;
20
21 const args = try std.process.argsAlloc(arena);
2219 const input_file = args[1];
2320 const output_file = args[2];
2421
25 var threaded: std.Io.Threaded = .init(gpa, .{});
26 defer threaded.deinit();
27 const io = threaded.io();
28
2922 var in_file = try Dir.cwd().openFile(io, input_file, .{ .mode = .read_only });
3023 defer in_file.close(io);
3124
tools/update-linux-headers.zig+7-9
......@@ -141,15 +141,13 @@ const HashToContents = std.StringHashMap(Contents);
141141const TargetToHash = std.ArrayHashMap(DestTarget, []const u8, DestTarget.HashContext, true);
142142const PathTable = std.StringHashMap(*TargetToHash);
143143
144pub fn main() !void {
145 var arena_state = std.heap.ArenaAllocator.init(std.heap.page_allocator);
146 const arena = arena_state.allocator();
144pub fn main(init: std.process.Init) !void {
145 const arena = init.arena.allocator();
146 const io = init.io;
147 const args = try init.minimal.args.toSlice(arena);
148 const env_map = init.env_map;
149 const cwd = try std.process.getCwdAlloc(arena);
147150
148 var threaded: Io.Threaded = .init(arena, .{});
149 defer threaded.deinit();
150 const io = threaded.io();
151
152 const args = try std.process.argsAlloc(arena);
153151 var search_paths = std.array_list.Managed([]const u8).init(arena);
154152 var opt_out_dir: ?[]const u8 = null;
155153
......@@ -211,7 +209,7 @@ pub fn main() !void {
211209 switch (entry.kind) {
212210 .directory => try dir_stack.append(full_path),
213211 .file => {
214 const rel_path = try Dir.path.relative(arena, target_include_dir, full_path);
212 const rel_path = try Dir.path.relative(arena, cwd, env_map, target_include_dir, full_path);
215213 const max_size = 2 * 1024 * 1024 * 1024;
216214 const raw_bytes = try Dir.cwd().readFileAlloc(io, full_path, arena, .limited(max_size));
217215 const trimmed = std.mem.trim(u8, raw_bytes, " \r\n\t");
tools/update_clang_options.zig+12-18
......@@ -627,16 +627,10 @@ const cpu_targets = struct {
627627 pub const xtensa = std.Target.xtensa;
628628};
629629
630pub fn main() anyerror!void {
631 var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
632 defer arena.deinit();
633
634 const allocator = arena.allocator();
635 const args = try std.process.argsAlloc(allocator);
636
637 var threaded: std.Io.Threaded = .init(allocator, .{});
638 defer threaded.deinit();
639 const io = threaded.io();
630pub fn main(init: std.process.Init) !void {
631 const arena = init.arena.allocator();
632 const args = try init.minimal.args.toSlice(arena);
633 const io = init.io;
640634
641635 var stdout_buffer: [4000]u8 = undefined;
642636 var stdout_writer = Io.File.stdout().writerStreaming(io, &stdout_buffer);
......@@ -658,7 +652,7 @@ pub fn main() anyerror!void {
658652 const llvm_src_root = args[2];
659653 if (std.mem.startsWith(u8, llvm_src_root, "-")) printUsageAndExit(args[0]);
660654
661 var llvm_to_zig_cpu_features = std.StringHashMap([]const u8).init(allocator);
655 var llvm_to_zig_cpu_features = std.StringHashMap([]const u8).init(arena);
662656
663657 inline for (@typeInfo(cpu_targets).@"struct".decls) |decl| {
664658 const Feature = @field(cpu_targets, decl.name).Feature;
......@@ -675,12 +669,12 @@ pub fn main() anyerror!void {
675669 const child_args = [_][]const u8{
676670 llvm_tblgen_exe,
677671 "--dump-json",
678 try std.fmt.allocPrint(allocator, "{s}/clang/include/clang/Driver/Options.td", .{llvm_src_root}),
679 try std.fmt.allocPrint(allocator, "-I={s}/llvm/include", .{llvm_src_root}),
680 try std.fmt.allocPrint(allocator, "-I={s}/clang/include/clang/Driver", .{llvm_src_root}),
672 try std.fmt.allocPrint(arena, "{s}/clang/include/clang/Driver/Options.td", .{llvm_src_root}),
673 try std.fmt.allocPrint(arena, "-I={s}/llvm/include", .{llvm_src_root}),
674 try std.fmt.allocPrint(arena, "-I={s}/clang/include/clang/Driver", .{llvm_src_root}),
681675 };
682676
683 const child_result = try std.process.Child.run(allocator, io, .{
677 const child_result = try std.process.run(arena, io, .{
684678 .argv = &child_args,
685679 .max_output_bytes = 100 * 1024 * 1024,
686680 });
......@@ -688,7 +682,7 @@ pub fn main() anyerror!void {
688682 std.debug.print("{s}\n", .{child_result.stderr});
689683
690684 const json_text = switch (child_result.term) {
691 .Exited => |code| if (code == 0) child_result.stdout else {
685 .exited => |code| if (code == 0) child_result.stdout else {
692686 std.debug.print("llvm-tblgen exited with code {d}\n", .{code});
693687 std.process.exit(1);
694688 },
......@@ -698,11 +692,11 @@ pub fn main() anyerror!void {
698692 },
699693 };
700694
701 const parsed = try json.parseFromSlice(json.Value, allocator, json_text, .{});
695 const parsed = try json.parseFromSlice(json.Value, arena, json_text, .{});
702696 defer parsed.deinit();
703697 const root_map = &parsed.value.object;
704698
705 var all_objects = std.array_list.Managed(*json.ObjectMap).init(allocator);
699 var all_objects = std.array_list.Managed(*json.ObjectMap).init(arena);
706700 {
707701 var it = root_map.iterator();
708702 it_map: while (it.next()) |kv| {
tools/update_cpu_features.zig+3-3
......@@ -1884,7 +1884,7 @@ const targets = [_]ArchTarget{
18841884};
18851885
18861886pub fn main(init: std.process.Init) !void {
1887 const arena = init.arena_allocator.allocator();
1887 const arena = init.arena.allocator();
18881888 const io = init.io;
18891889
18901890 var args = try init.minimal.args.iterateAllocator(arena);
......@@ -1985,7 +1985,7 @@ fn processOneTarget(io: Io, job: Job) void {
19851985 }),
19861986 };
19871987
1988 const child_result = try std.process.Child.run(arena, io, .{
1988 const child_result = try std.process.run(arena, io, .{
19891989 .argv = &child_args,
19901990 .max_output_bytes = 500 * 1024 * 1024,
19911991 });
......@@ -1995,7 +1995,7 @@ fn processOneTarget(io: Io, job: Job) void {
19951995 }
19961996
19971997 const json_text = switch (child_result.term) {
1998 .Exited => |code| if (code == 0) child_result.stdout else {
1998 .exited => |code| if (code == 0) child_result.stdout else {
19991999 std.debug.print("llvm-tblgen exited with code {d}\n", .{code});
20002000 std.process.exit(1);
20012001 },
tools/update_crc_catalog.zig+7-9
......@@ -6,16 +6,14 @@ const ascii = std.ascii;
66
77const catalog_txt = @embedFile("crc/catalog.txt");
88
9pub fn main() anyerror!void {
10 var arena_state = std.heap.ArenaAllocator.init(std.heap.page_allocator);
11 defer arena_state.deinit();
12 const arena = arena_state.allocator();
13
14 var threaded: Io.Threaded = .init(arena, .{});
15 defer threaded.deinit();
16 const io = threaded.io();
9pub fn main(init: std.process.Init) !void {
10 const arena = init.arena.allocator();
11 const io = init.io;
12 const args = try init.minimal.args.toSlice(arena);
13 return @"i like cheese"(arena, io, args);
14}
1715
18 const args = try std.process.argsAlloc(arena);
16fn @"i like cheese"(arena: std.mem.Allocator, io: Io, args: []const []const u8) !void {
1917 if (args.len <= 1) printUsageAndExit(args[0]);
2018
2119 const zig_src_root = args[1];
tools/update_freebsd_libc.zig+4-9
......@@ -12,16 +12,11 @@ const exempt_files = [_][]const u8{
1212 "abilists",
1313};
1414
15pub fn main() !void {
16 var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);
17 defer arena_instance.deinit();
18 const arena = arena_instance.allocator();
15pub fn main(init: std.process.Init) !void {
16 const arena = init.arena.allocator();
17 const io = init.io;
18 const args = try init.minimal.args.toSlice(arena);
1919
20 var threaded: Io.Threaded = .init(arena, .{});
21 defer threaded.deinit();
22 const io = threaded.io();
23
24 const args = try std.process.argsAlloc(arena);
2520 const freebsd_src_path = args[1];
2621 const zig_src_path = args[2];
2722
tools/update_glibc.zig+4-9
......@@ -38,16 +38,11 @@ const exempt_extensions = [_][]const u8{
3838 "-2.33.c",
3939};
4040
41pub fn main() !void {
42 var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);
43 defer arena_instance.deinit();
44 const arena = arena_instance.allocator();
41pub fn main(init: std.process.Init) !void {
42 const arena = init.arena.allocator();
43 const io = init.io;
44 const args = try init.minimal.args.toSlice(arena);
4545
46 var threaded: Io.Threaded = .init(arena, .{});
47 defer threaded.deinit();
48 const io = threaded.io();
49
50 const args = try std.process.argsAlloc(arena);
5146 const glibc_src_path = args[1];
5247 const zig_src_path = args[2];
5348
tools/update_mingw.zig+4-9
......@@ -2,16 +2,11 @@ const std = @import("std");
22const Io = std.Io;
33const Dir = std.Io.Dir;
44
5pub fn main() !void {
6 var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);
7 defer arena_instance.deinit();
8 const arena = arena_instance.allocator();
5pub fn main(init: std.process.Init) !void {
6 const arena = init.arena.allocator();
7 const io = init.io;
8 const args = try init.minimal.args.toSlice(arena);
99
10 var threaded: Io.Threaded = .init(arena, .{});
11 defer threaded.deinit();
12 const io = threaded.io();
13
14 const args = try std.process.argsAlloc(arena);
1510 const zig_src_lib_path = args[1];
1611 const mingw_src_path = args[2];
1712
tools/update_netbsd_libc.zig+4-9
......@@ -12,16 +12,11 @@ const exempt_files = [_][]const u8{
1212 "abilists",
1313};
1414
15pub fn main() !void {
16 var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);
17 defer arena_instance.deinit();
18 const arena = arena_instance.allocator();
15pub fn main(init: std.process.Init) !void {
16 const arena = init.arena.allocator();
17 const io = init.io;
18 const args = try init.minimal.args.toSlice(arena);
1919
20 var threaded: Io.Threaded = .init(arena, .{});
21 defer threaded.deinit();
22 const io = threaded.io();
23
24 const args = try std.process.argsAlloc(arena);
2520 const netbsd_src_path = args[1];
2621 const zig_src_path = args[2];
2722