Mirrors/zig
1
0
Fork 0
mirror of https://codeberg.org/ziglang/zig.git synced 2026-04-26 13:01:34 +03:00
Code Issues Packages Projects Releases Wiki Activity

test-standalone: update more cases to new main API

Browse Source
This commit is contained in:
Andrew Kelley
2026-01-02 17:57:54 -08:00
parent 1b56686012
commit bf74827ddb
41 changed files with 346 additions and 416 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tools/doctest.zig
+14 -14
View File
@@ -193,14 +193,14 @@ fn printOutput(
try shell_out.print("\n", .{});
if (expected_outcome == .build_fail) {
const result = try process.Child.run(arena, io, .{
const result = try process.run(arena, io, .{
.argv = build_args.items,
.cwd = tmp_dir_path,
.env_map = &env_map,
.max_output_bytes = max_doc_file_size,
});
switch (result.term) {
.Exited => |exit_code| {
.exited => |exit_code| {
if (exit_code == 0) {
print("{s}\nThe following command incorrectly succeeded:\n", .{result.stderr});
dumpArgs(build_args.items);
@@ -249,21 +249,21 @@ fn printOutput(
var exited_with_signal = false;
const result = if (expected_outcome == .fail) blk: {
const result = try process.Child.run(arena, io, .{
const result = try process.run(arena, io, .{
.argv = run_args,
.env_map = &env_map,
.cwd = tmp_dir_path,
.max_output_bytes = max_doc_file_size,
});
switch (result.term) {
.Exited => |exit_code| {
.exited => |exit_code| {
if (exit_code == 0) {
print("{s}\nThe following command incorrectly succeeded:\n", .{result.stderr});
dumpArgs(run_args);
fatal("example incorrectly compiled", .{});
}
},
.Signal => exited_with_signal = true,
.signal => exited_with_signal = true,
else => {},
}
break :blk result;
@@ -368,14 +368,14 @@ fn printOutput(
try test_args.append("-lc");
try shell_out.print("-lc ", .{});
}
const result = try process.Child.run(arena, io, .{
const result = try process.run(arena, io, .{
.argv = test_args.items,
.env_map = &env_map,
.cwd = tmp_dir_path,
.max_output_bytes = max_doc_file_size,
});
switch (result.term) {
.Exited => |exit_code| {
.exited => |exit_code| {
if (exit_code == 0) {
print("{s}\nThe following command incorrectly succeeded:\n", .{result.stderr});
dumpArgs(test_args.items);
@@ -424,14 +424,14 @@ fn printOutput(
},
}
const result = try process.Child.run(arena, io, .{
const result = try process.run(arena, io, .{
.argv = test_args.items,
.env_map = &env_map,
.cwd = tmp_dir_path,
.max_output_bytes = max_doc_file_size,
});
switch (result.term) {
.Exited => |exit_code| {
.exited => |exit_code| {
if (exit_code == 0) {
print("{s}\nThe following command incorrectly succeeded:\n", .{result.stderr});
dumpArgs(test_args.items);
@@ -500,14 +500,14 @@ fn printOutput(
}
if (maybe_error_match) |error_match| {
const result = try process.Child.run(arena, io, .{
const result = try process.run(arena, io, .{
.argv = build_args.items,
.env_map = &env_map,
.cwd = tmp_dir_path,
.max_output_bytes = max_doc_file_size,
});
switch (result.term) {
.Exited => |exit_code| {
.exited => |exit_code| {
if (exit_code == 0) {
print("{s}\nThe following command incorrectly succeeded:\n", .{result.stderr});
dumpArgs(build_args.items);
@@ -1123,15 +1123,15 @@ fn run(
env_map: *process.Environ.Map,
cwd: []const u8,
args: []const []const u8,
) !process.Child.RunResult {
const result = try process.Child.run(allocator, io, .{
) !process.RunResult {
const result = try process.run(allocator, io, .{
.argv = args,
.env_map = env_map,
.cwd = cwd,
.max_output_bytes = max_doc_file_size,
});
switch (result.term) {
.Exited => |exit_code| {
.exited => |exit_code| {
if (exit_code != 0) {
std.debug.print("{s}\nThe following command exited with code {}:\n", .{ result.stderr, exit_code });
dumpArgs(args);
tools/dump-cov.zig
+2 -2
View File
@@ -10,9 +10,9 @@ const SeenPcsHeader = std.Build.abi.fuzz.SeenPcsHeader;
pub fn main(init: std.process.Init) !void {
const gpa = init.gpa;
const arena = init.arena;
const arena = init.arena.allocator();
const io = init.io;
const args = try init.args.toSlice(arena);
const args = try init.minimal.args.toSlice(arena);
const target_query_str = switch (args.len) {
3 => "native",
tools/fetch_them_macos_headers.zig
+2 -2
View File
@@ -68,7 +68,7 @@ const usage =
pub fn main(init: std.process.Init) !void {
const allocator = init.arena;
const args = try init.args.toSlice(allocator);
const args = try init.minimal.args.toSlice(allocator);
var argv = std.array_list.Managed([]const u8).init(allocator);
var sysroot: ?[]const u8 = null;
@@ -161,7 +161,7 @@ fn fetchTarget(
});
try cc_argv.appendSlice(args);
const res = try std.process.Child.run(arena, io, .{ .argv = cc_argv.items });
const res = try std.process.run(arena, io, .{ .argv = cc_argv.items });
if (res.stderr.len != 0) {
std.log.err("{s}", .{res.stderr});
tools/gen_macos_headers_c.zig
+1 -1
View File
@@ -16,8 +16,8 @@ const usage =
pub fn main(init: std.process.Init) !void {
const arena = init.arena;
const io = init.io;
const args = try init.minimal.args.toSlice(arena);
const args = try init.args.toSlice(arena);
if (args.len == 1) fatal("no command or option specified", .{});
var positionals = std.array_list.Managed([]const u8).init(arena);
tools/gen_outline_atomics.zig
+1 -1
View File
@@ -12,7 +12,7 @@ const AtomicOp = enum {
};
pub fn main(init: std.process.Init) !void {
const arena = init.arena;
const arena = init.arena.allocator();
const io = init.io;
//const args = try std.process.argsAlloc(arena);
tools/gen_spirv_spec.zig
+49 -49
View File
@@ -1,6 +1,7 @@
const std = @import("std");
const Io = std.Io;
const Allocator = std.mem.Allocator;
const assert = std.debug.assert;
const g = @import("spirv/grammar.zig");
const CoreRegistry = g.CoreRegistry;
@@ -54,28 +55,22 @@ const set_names = std.StaticStringMap(struct { []const u8, []const u8 }).initCom
.{ "zig", .{ "zig", "Zig" } },
});
var arena = std.heap.ArenaAllocator.init(std.heap.smp_allocator);
const allocator = arena.allocator();
pub fn main() !void {
defer arena.deinit();
const args = try std.process.argsAlloc(allocator);
pub fn main(init: std.process.Init) !void {
const arena = init.arena.allocator();
const args = try init.minimal.args.toSlice(arena);
if (args.len != 3) {
usageAndExit(args[0], 1);
}
var threaded: std.Io.Threaded = .init(allocator, .{});
defer threaded.deinit();
const io = threaded.io();
const io = init.io;
const json_path = try Io.Dir.path.join(allocator, &.{ args[1], "include/spirv/unified1/" });
const json_path = try Io.Dir.path.join(arena, &.{ args[1], "include/spirv/unified1/" });
const dir = try Io.Dir.cwd().openDir(io, json_path, .{ .iterate = true });
const core_spec = try readRegistry(io, CoreRegistry, dir, "spirv.core.grammar.json");
const core_spec = try readRegistry(io, arena, CoreRegistry, dir, "spirv.core.grammar.json");
std.mem.sortUnstable(Instruction, core_spec.instructions, CmpInst{}, CmpInst.lt);
var exts = std.array_list.Managed(Extension).init(allocator);
var exts = std.array_list.Managed(Extension).init(arena);
var it = dir.iterate();
while (try it.next(io)) |entry| {
@@ -83,48 +78,48 @@ pub fn main() !void {
continue;
}
try readExtRegistry(io, &exts, dir, entry.name);
try readExtRegistry(io, arena, &exts, dir, entry.name);
}
try readExtRegistry(io, &exts, Io.Dir.cwd(), args[2]);
try readExtRegistry(io, arena, &exts, Io.Dir.cwd(), args[2]);
var allocating: std.Io.Writer.Allocating = .init(allocator);
var allocating: std.Io.Writer.Allocating = .init(arena);
defer allocating.deinit();
try render(&allocating.writer, core_spec, exts.items);
try render(arena, &allocating.writer, core_spec, exts.items);
try allocating.writer.writeByte(0);
const output = allocating.written()[0 .. allocating.written().len - 1 :0];
var tree = try std.zig.Ast.parse(allocator, output, .zig);
var tree = try std.zig.Ast.parse(arena, output, .zig);
if (tree.errors.len != 0) {
try std.zig.printAstErrorsToStderr(allocator, io, tree, "", .auto);
try std.zig.printAstErrorsToStderr(arena, io, tree, "", .auto);
return;
}
var zir = try std.zig.AstGen.generate(allocator, tree);
var zir = try std.zig.AstGen.generate(arena, tree);
if (zir.hasCompileErrors()) {
var wip_errors: std.zig.ErrorBundle.Wip = undefined;
try wip_errors.init(allocator);
try wip_errors.init(arena);
defer wip_errors.deinit();
try wip_errors.addZirErrorMessages(zir, tree, output, "");
var error_bundle = try wip_errors.toOwnedBundle("");
defer error_bundle.deinit(allocator);
defer error_bundle.deinit(arena);
try error_bundle.renderToStderr(io, .{}, .auto);
}
const formatted_output = try tree.renderAlloc(allocator);
const formatted_output = try tree.renderAlloc(arena);
try Io.File.stdout().writeStreamingAll(io, formatted_output);
}
fn readExtRegistry(io: Io, exts: *std.array_list.Managed(Extension), dir: Io.Dir, sub_path: []const u8) !void {
fn readExtRegistry(io: Io, arena: Allocator, exts: *std.array_list.Managed(Extension), dir: Io.Dir, sub_path: []const u8) !void {
const filename = Io.Dir.path.basename(sub_path);
if (!std.mem.startsWith(u8, filename, "extinst.")) {
return;
}
std.debug.assert(std.mem.endsWith(u8, filename, ".grammar.json"));
assert(std.mem.endsWith(u8, filename, ".grammar.json"));
const name = filename["extinst.".len .. filename.len - ".grammar.json".len];
const spec = try readRegistry(io, ExtensionRegistry, dir, sub_path);
const spec = try readRegistry(io, arena, ExtensionRegistry, dir, sub_path);
const set_name = set_names.get(name) orelse {
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
});
}
fn readRegistry(io: Io, comptime RegistryType: type, dir: Io.Dir, path: []const u8) !RegistryType {
const spec = try dir.readFileAlloc(io, path, allocator, .unlimited);
fn readRegistry(io: Io, arena: Allocator, comptime RegistryType: type, dir: Io.Dir, path: []const u8) !RegistryType {
const spec = try dir.readFileAlloc(io, path, arena, .unlimited);
// Required for json parsing.
// TODO: ALI
@setEvalBranchQuota(10000);
var scanner = std.json.Scanner.initCompleteInput(allocator, spec);
var scanner = std.json.Scanner.initCompleteInput(arena, spec);
var diagnostics = std.json.Diagnostics{};
scanner.enableDiagnostics(&diagnostics);
const parsed = std.json.parseFromTokenSource(RegistryType, allocator, &scanner, .{}) catch |err| {
const parsed = std.json.parseFromTokenSource(RegistryType, arena, &scanner, .{}) catch |err| {
std.debug.print("{s}:{}:{}:\n", .{ path, diagnostics.getLine(), diagnostics.getColumn() });
return err;
};
@@ -158,8 +153,8 @@ fn readRegistry(io: Io, comptime RegistryType: type, dir: Io.Dir, path: []const
/// Returns a set with types that require an extra struct for the `Instruction` interface
/// to the spir-v spec, or whether the original type can be used.
fn extendedStructs(kinds: []const OperandKind) !ExtendedStructSet {
var map = ExtendedStructSet.init(allocator);
fn extendedStructs(arena: Allocator, kinds: []const OperandKind) !ExtendedStructSet {
var map = ExtendedStructSet.init(arena);
try map.ensureTotalCapacity(@as(u32, @intCast(kinds.len)));
for (kinds) |kind| {
@@ -194,6 +189,7 @@ fn tagPriorityScore(tag: []const u8) usize {
}
fn render(
arena: Allocator,
writer: *std.Io.Writer,
registry: CoreRegistry,
extensions: []const Extension,
@@ -299,7 +295,7 @@ fn render(
);
// Merge the operand kinds from all extensions together.
var all_operand_kinds = OperandKindMap.init(allocator);
var all_operand_kinds = OperandKindMap.init(arena);
for (registry.operand_kinds) |kind| {
try all_operand_kinds.putNoClobber(.{ "core", kind.kind }, kind);
}
@@ -312,22 +308,22 @@ fn render(
try all_operand_kinds.ensureUnusedCapacity(ext.spec.operand_kinds.len);
for (ext.spec.operand_kinds) |kind| {
var new_kind = kind;
new_kind.kind = try std.mem.join(allocator, ".", &.{ ext.name, kind.kind });
new_kind.kind = try std.mem.join(arena, ".", &.{ ext.name, kind.kind });
try all_operand_kinds.putNoClobber(.{ ext.name, kind.kind }, new_kind);
}
}
const extended_structs = try extendedStructs(all_operand_kinds.values());
const extended_structs = try extendedStructs(arena, all_operand_kinds.values());
// Note: extensions don't seem to have class.
try renderClass(writer, registry.instructions);
try renderClass(arena, writer, registry.instructions);
try renderOperandKind(writer, all_operand_kinds.values());
try renderOpcodes(writer, "Opcode", true, registry.instructions, extended_structs);
try renderOpcodes(arena, writer, "Opcode", true, registry.instructions, extended_structs);
for (extensions) |ext| {
try renderOpcodes(writer, ext.opcode_name, false, ext.spec.instructions, extended_structs);
try renderOpcodes(arena, writer, ext.opcode_name, false, ext.spec.instructions, extended_structs);
}
try renderOperandKinds(writer, all_operand_kinds.values(), extended_structs);
try renderOperandKinds(arena, writer, all_operand_kinds.values(), extended_structs);
try renderInstructionSet(writer, registry, extensions, all_operand_kinds);
}
@@ -414,8 +410,8 @@ fn renderInstructionsCase(
);
}
fn renderClass(writer: *std.Io.Writer, instructions: []const Instruction) !void {
var class_map = std.StringArrayHashMap(void).init(allocator);
fn renderClass(arena: Allocator, writer: *std.Io.Writer, instructions: []const Instruction) !void {
var class_map = std.StringArrayHashMap(void).init(arena);
for (instructions) |inst| {
if (std.mem.eql(u8, inst.class.?, "@exclude")) continue;
@@ -535,16 +531,17 @@ fn renderEnumerant(writer: *std.Io.Writer, enumerant: Enumerant) !void {
}
fn renderOpcodes(
arena: Allocator,
writer: *std.Io.Writer,
opcode_type_name: []const u8,
want_operands: bool,
instructions: []const Instruction,
extended_structs: ExtendedStructSet,
) !void {
var inst_map = std.AutoArrayHashMap(u32, usize).init(allocator);
var inst_map = std.AutoArrayHashMap(u32, usize).init(arena);
try inst_map.ensureTotalCapacity(instructions.len);
var aliases = std.array_list.Managed(struct { inst: usize, alias: usize }).init(allocator);
var aliases = std.array_list.Managed(struct { inst: usize, alias: usize }).init(arena);
try aliases.ensureTotalCapacity(instructions.len);
for (instructions, 0..) |inst, i| {
@@ -634,30 +631,32 @@ fn renderOpcodes(
}
fn renderOperandKinds(
arena: Allocator,
writer: *std.Io.Writer,
kinds: []const OperandKind,
extended_structs: ExtendedStructSet,
) !void {
for (kinds) |kind| {
switch (kind.category) {
.ValueEnum => try renderValueEnum(writer, kind, extended_structs),
.BitEnum => try renderBitEnum(writer, kind, extended_structs),
.ValueEnum => try renderValueEnum(arena, writer, kind, extended_structs),
.BitEnum => try renderBitEnum(arena, writer, kind, extended_structs),
else => {},
}
}
}
fn renderValueEnum(
arena: Allocator,
writer: *std.Io.Writer,
enumeration: OperandKind,
extended_structs: ExtendedStructSet,
) !void {
const enumerants = enumeration.enumerants orelse return error.InvalidRegistry;
var enum_map = std.AutoArrayHashMap(u32, usize).init(allocator);
var enum_map = std.AutoArrayHashMap(u32, usize).init(arena);
try enum_map.ensureTotalCapacity(enumerants.len);
var aliases = std.array_list.Managed(struct { enumerant: usize, alias: usize }).init(allocator);
var aliases = std.array_list.Managed(struct { enumerant: usize, alias: usize }).init(arena);
try aliases.ensureTotalCapacity(enumerants.len);
for (enumerants, 0..) |enumerant, i| {
@@ -726,6 +725,7 @@ fn renderValueEnum(
}
fn renderBitEnum(
arena: Allocator,
writer: *std.Io.Writer,
enumeration: OperandKind,
extended_structs: ExtendedStructSet,
@@ -735,7 +735,7 @@ fn renderBitEnum(
var flags_by_bitpos = [_]?usize{null} ** 32;
const enumerants = enumeration.enumerants orelse return error.InvalidRegistry;
var aliases = std.array_list.Managed(struct { flag: usize, alias: u5 }).init(allocator);
var aliases = std.array_list.Managed(struct { flag: usize, alias: u5 }).init(arena);
try aliases.ensureTotalCapacity(enumerants.len);
for (enumerants, 0..) |enumerant, i| {
@@ -749,7 +749,7 @@ fn renderBitEnum(
continue;
}
std.debug.assert(@popCount(value) == 1);
assert(@popCount(value) == 1);
const bitpos = std.math.log2_int(u32, value);
if (flags_by_bitpos[bitpos]) |*existing| {
tools/gen_stubs.zig
+4 -10
View File
@@ -281,16 +281,10 @@ const Parse = struct {
arch: Arch,
};
pub fn main() !void {
var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena_instance.deinit();
const arena = arena_instance.allocator();
var threaded: std.Io.Threaded = .init(arena, .{});
defer threaded.deinit();
const io = threaded.io();
const args = try std.process.argsAlloc(arena);
pub fn main(init: std.process.Init) !void {
const arena = init.arena.allocator();
const io = init.io;
const args = try init.minimal.args.toSlice(arena);
const build_all_path = args[1];
var build_all_dir = try Io.Dir.cwd().openDir(io, build_all_path, .{});
tools/generate_c_size_and_align_checks.zig
+1 -1
View File
@@ -29,7 +29,7 @@ fn cName(ty: std.Target.CType) []const u8 {
var general_purpose_allocator: std.heap.GeneralPurposeAllocator(.{}) = .init;
pub fn main(init: std.process.Init) !void {
const args = try init.args.toSlice(init.arena);
const args = try init.minimal.args.toSlice(init.arena.allocator());
const io = init.io;
if (args.len != 2) {
tools/generate_linux_syscalls.zig
+1 -1
View File
@@ -174,7 +174,7 @@ pub fn main(init: std.process.Init) !void {
const gpa = init.gpa;
const io = init.io;
const args = try std.process.argsAlloc(gpa);
const args = try init.minimal.args.toSlice(init.arena.allocator());
if (args.len < 2 or mem.eql(u8, args[1], "--help")) {
const stderr = std.debug.lockStderr(&.{});
const w = &stderr.file_writer.interface;
tools/incr-check.zig
+24 -22
View File
@@ -171,14 +171,6 @@ pub fn main(init: std.process.Init) !void {
const zig_prog_node = target_prog_node.start("zig build-exe", 0);
defer zig_prog_node.end();
var child = std.process.Child.init(child_args.items, arena);
child.stdin_behavior = .Pipe;
child.stdout_behavior = .Pipe;
child.stderr_behavior = .Pipe;
child.progress_node = zig_prog_node;
child.cwd_dir = tmp_dir;
child.cwd = tmp_dir_path;
var cc_child_args: std.ArrayList([]const u8) = .empty;
if (target.backend == .cbe) {
const resolved_cc_zig_exe = if (opt_cc_zig) |cc_zig_exe|
@@ -201,6 +193,17 @@ pub fn main(init: std.process.Init) !void {
try cc_child_args.append(arena, "-o");
}
var child = std.process.spawn(io, .{
.argv = child_args.items,
.stdin = .pipe,
.stdout = .pipe,
.stderr = .pipe,
.progress_node = zig_prog_node,
.cwd_dir = tmp_dir,
.cwd = tmp_dir_path,
});
defer child.kill(io);
var eval: Eval = .{
.arena = arena,
.io = io,
@@ -219,11 +222,6 @@ pub fn main(init: std.process.Init) !void {
.enable_darling = enable_darling,
};
try child.spawn(io);
errdefer {
_ = child.kill(io) catch {};
}
var poller = Io.poll(arena, Eval.StreamEnum, .{
.stdout = child.stdout.?,
.stderr = child.stderr.?,
@@ -528,7 +526,7 @@ const Eval = struct {
const run_prog_node = prog_node.start("run generated executable", 0);
defer run_prog_node.end();
const result = std.process.Child.run(eval.arena, io, .{
const result = std.process.run(eval.arena, io, .{
.argv = argv,
.cwd_dir = eval.tmp_dir,
.cwd = eval.tmp_dir_path,
@@ -556,7 +554,7 @@ const Eval = struct {
}
switch (result.term) {
.Exited => |code| switch (update.outcome) {
.exited => |code| switch (update.outcome) {
.unknown, .compile_errors => unreachable,
.stdout => |expected_stdout| {
if (code != 0) {
@@ -564,9 +562,12 @@ const Eval = struct {
}
try std.testing.expectEqualStrings(expected_stdout, result.stdout);
},
.exit_code => |expected_code| try std.testing.expectEqual(expected_code, result.term.Exited),
.exit_code => |expected_code| try std.testing.expectEqual(expected_code, code),
},
.Signal, .Stopped, .Unknown => {
.signal => |sig| {
eval.fatal("generated executable '{s}' terminated with signal {t}", .{ binary_path, sig });
},
.stopped, .unknown => {
eval.fatal("generated executable '{s}' terminated unexpectedly", .{binary_path});
},
}
@@ -614,7 +615,7 @@ const Eval = struct {
try eval.cc_child_args.appendSlice(eval.arena, &.{ out_path, c_path });
defer eval.cc_child_args.items.len -= 2;
const result = std.process.Child.run(eval.arena, eval.io, .{
const result = std.process.run(eval.arena, eval.io, .{
.argv = eval.cc_child_args.items,
.cwd_dir = eval.tmp_dir,
.cwd = eval.tmp_dir_path,
@@ -623,13 +624,13 @@ const Eval = struct {
eval.fatal("failed to spawn zig cc for '{s}': {t}", .{ c_path, err });
};
switch (result.term) {
.Exited => |code| if (code != 0) {
.exited => |code| if (code != 0) {
if (result.stderr.len != 0) {
std.log.err("zig cc stderr:\n{s}", .{result.stderr});
}
eval.fatal("zig cc for '{s}' failed with code {d}", .{ c_path, code });
},
.Signal, .Stopped, .Unknown => {
.signal, .stopped, .unknown => {
if (result.stderr.len != 0) {
std.log.err("zig cc stderr:\n{s}", .{result.stderr});
}
@@ -909,8 +910,9 @@ fn waitChild(child: *std.process.Child, eval: *Eval) void {
requestExit(child, eval);
const term = child.wait(io) catch |err| eval.fatal("child process failed: {t}", .{err});
switch (term) {
.Exited => |code| if (code != 0) eval.fatal("compiler failed with code {d}", .{code}),
.Signal, .Stopped, .Unknown => eval.fatal("compiler terminated unexpectedly", .{}),
.exited => |code| if (code != 0) eval.fatal("compiler failed with code {d}", .{code}),
.signal => |sig| eval.fatal("compiler terminated with signal {t}", .{sig}),
.stopped, .unknown => eval.fatal("compiler terminated unexpectedly", .{}),
}
}
tools/migrate_langref.zig
+4 -11
View File
@@ -11,21 +11,14 @@ const fatal = std.process.fatal;
const max_doc_file_size = 10 * 1024 * 1024;
pub fn main() !void {
var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena_instance.deinit();
const arena = arena_instance.allocator();
pub fn main(init: std.process.Init) !void {
const arena = init.arena.allocator();
const io = init.io;
const args = try init.minimal.args.toSlice(arena);
const gpa = arena;
const args = try std.process.argsAlloc(arena);
const input_file = args[1];
const output_file = args[2];
var threaded: std.Io.Threaded = .init(gpa, .{});
defer threaded.deinit();
const io = threaded.io();
var in_file = try Dir.cwd().openFile(io, input_file, .{ .mode = .read_only });
defer in_file.close(io);
tools/update-linux-headers.zig
+7 -9
View File
@@ -141,15 +141,13 @@ const HashToContents = std.StringHashMap(Contents);
const TargetToHash = std.ArrayHashMap(DestTarget, []const u8, DestTarget.HashContext, true);
const PathTable = std.StringHashMap(*TargetToHash);
pub fn main() !void {
var arena_state = std.heap.ArenaAllocator.init(std.heap.page_allocator);
const arena = arena_state.allocator();
pub fn main(init: std.process.Init) !void {
const arena = init.arena.allocator();
const io = init.io;
const args = try init.minimal.args.toSlice(arena);
const env_map = init.env_map;
const cwd = try std.process.getCwdAlloc(arena);
var threaded: Io.Threaded = .init(arena, .{});
defer threaded.deinit();
const io = threaded.io();
const args = try std.process.argsAlloc(arena);
var search_paths = std.array_list.Managed([]const u8).init(arena);
var opt_out_dir: ?[]const u8 = null;
@@ -211,7 +209,7 @@ pub fn main() !void {
switch (entry.kind) {
.directory => try dir_stack.append(full_path),
.file => {
const rel_path = try Dir.path.relative(arena, target_include_dir, full_path);
const rel_path = try Dir.path.relative(arena, cwd, env_map, target_include_dir, full_path);
const max_size = 2 * 1024 * 1024 * 1024;
const raw_bytes = try Dir.cwd().readFileAlloc(io, full_path, arena, .limited(max_size));
const trimmed = std.mem.trim(u8, raw_bytes, " \r\n\t");
tools/update_clang_options.zig
+12 -18
View File
@@ -627,16 +627,10 @@ const cpu_targets = struct {
pub const xtensa = std.Target.xtensa;
};
pub fn main() anyerror!void {
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena.deinit();
const allocator = arena.allocator();
const args = try std.process.argsAlloc(allocator);
var threaded: std.Io.Threaded = .init(allocator, .{});
defer threaded.deinit();
const io = threaded.io();
pub fn main(init: std.process.Init) !void {
const arena = init.arena.allocator();
const args = try init.minimal.args.toSlice(arena);
const io = init.io;
var stdout_buffer: [4000]u8 = undefined;
var stdout_writer = Io.File.stdout().writerStreaming(io, &stdout_buffer);
@@ -658,7 +652,7 @@ pub fn main() anyerror!void {
const llvm_src_root = args[2];
if (std.mem.startsWith(u8, llvm_src_root, "-")) printUsageAndExit(args[0]);
var llvm_to_zig_cpu_features = std.StringHashMap([]const u8).init(allocator);
var llvm_to_zig_cpu_features = std.StringHashMap([]const u8).init(arena);
inline for (@typeInfo(cpu_targets).@"struct".decls) |decl| {
const Feature = @field(cpu_targets, decl.name).Feature;
@@ -675,12 +669,12 @@ pub fn main() anyerror!void {
const child_args = [_][]const u8{
llvm_tblgen_exe,
"--dump-json",
try std.fmt.allocPrint(allocator, "{s}/clang/include/clang/Driver/Options.td", .{llvm_src_root}),
try std.fmt.allocPrint(allocator, "-I={s}/llvm/include", .{llvm_src_root}),
try std.fmt.allocPrint(allocator, "-I={s}/clang/include/clang/Driver", .{llvm_src_root}),
try std.fmt.allocPrint(arena, "{s}/clang/include/clang/Driver/Options.td", .{llvm_src_root}),
try std.fmt.allocPrint(arena, "-I={s}/llvm/include", .{llvm_src_root}),
try std.fmt.allocPrint(arena, "-I={s}/clang/include/clang/Driver", .{llvm_src_root}),
};
const child_result = try std.process.Child.run(allocator, io, .{
const child_result = try std.process.run(arena, io, .{
.argv = &child_args,
.max_output_bytes = 100 * 1024 * 1024,
});
@@ -688,7 +682,7 @@ pub fn main() anyerror!void {
std.debug.print("{s}\n", .{child_result.stderr});
const json_text = switch (child_result.term) {
.Exited => |code| if (code == 0) child_result.stdout else {
.exited => |code| if (code == 0) child_result.stdout else {
std.debug.print("llvm-tblgen exited with code {d}\n", .{code});
std.process.exit(1);
},
@@ -698,11 +692,11 @@ pub fn main() anyerror!void {
},
};
const parsed = try json.parseFromSlice(json.Value, allocator, json_text, .{});
const parsed = try json.parseFromSlice(json.Value, arena, json_text, .{});
defer parsed.deinit();
const root_map = &parsed.value.object;
var all_objects = std.array_list.Managed(*json.ObjectMap).init(allocator);
var all_objects = std.array_list.Managed(*json.ObjectMap).init(arena);
{
var it = root_map.iterator();
it_map: while (it.next()) |kv| {
tools/update_cpu_features.zig
+3 -3
View File
@@ -1884,7 +1884,7 @@ const targets = [_]ArchTarget{
};
pub fn main(init: std.process.Init) !void {
const arena = init.arena_allocator.allocator();
const arena = init.arena.allocator();
const io = init.io;
var args = try init.minimal.args.iterateAllocator(arena);
@@ -1985,7 +1985,7 @@ fn processOneTarget(io: Io, job: Job) void {
}),
};
const child_result = try std.process.Child.run(arena, io, .{
const child_result = try std.process.run(arena, io, .{
.argv = &child_args,
.max_output_bytes = 500 * 1024 * 1024,
});
@@ -1995,7 +1995,7 @@ fn processOneTarget(io: Io, job: Job) void {
}
const json_text = switch (child_result.term) {
.Exited => |code| if (code == 0) child_result.stdout else {
.exited => |code| if (code == 0) child_result.stdout else {
std.debug.print("llvm-tblgen exited with code {d}\n", .{code});
std.process.exit(1);
},
tools/update_crc_catalog.zig
+7 -9
View File
@@ -6,16 +6,14 @@ const ascii = std.ascii;
const catalog_txt = @embedFile("crc/catalog.txt");
pub fn main() anyerror!void {
var arena_state = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena_state.deinit();
const arena = arena_state.allocator();
pub fn main(init: std.process.Init) !void {
const arena = init.arena.allocator();
const io = init.io;
const args = try init.minimal.args.toSlice(arena);
return @"i like cheese"(arena, io, args);
}
var threaded: Io.Threaded = .init(arena, .{});
defer threaded.deinit();
const io = threaded.io();
const args = try std.process.argsAlloc(arena);
fn @"i like cheese"(arena: std.mem.Allocator, io: Io, args: []const []const u8) !void {
if (args.len <= 1) printUsageAndExit(args[0]);
const zig_src_root = args[1];
tools/update_freebsd_libc.zig
+4 -9
View File
@@ -12,16 +12,11 @@ const exempt_files = [_][]const u8{
"abilists",
};
pub fn main() !void {
var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena_instance.deinit();
const arena = arena_instance.allocator();
pub fn main(init: std.process.Init) !void {
const arena = init.arena.allocator();
const io = init.io;
const args = try init.minimal.args.toSlice(arena);
var threaded: Io.Threaded = .init(arena, .{});
defer threaded.deinit();
const io = threaded.io();
const args = try std.process.argsAlloc(arena);
const freebsd_src_path = args[1];
const zig_src_path = args[2];
tools/update_glibc.zig
+4 -9
View File
@@ -38,16 +38,11 @@ const exempt_extensions = [_][]const u8{
"-2.33.c",
};
pub fn main() !void {
var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena_instance.deinit();
const arena = arena_instance.allocator();
pub fn main(init: std.process.Init) !void {
const arena = init.arena.allocator();
const io = init.io;
const args = try init.minimal.args.toSlice(arena);
var threaded: Io.Threaded = .init(arena, .{});
defer threaded.deinit();
const io = threaded.io();
const args = try std.process.argsAlloc(arena);
const glibc_src_path = args[1];
const zig_src_path = args[2];
tools/update_mingw.zig
+4 -9
View File
@@ -2,16 +2,11 @@ const std = @import("std");
const Io = std.Io;
const Dir = std.Io.Dir;
pub fn main() !void {
var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena_instance.deinit();
const arena = arena_instance.allocator();
pub fn main(init: std.process.Init) !void {
const arena = init.arena.allocator();
const io = init.io;
const args = try init.minimal.args.toSlice(arena);
var threaded: Io.Threaded = .init(arena, .{});
defer threaded.deinit();
const io = threaded.io();
const args = try std.process.argsAlloc(arena);
const zig_src_lib_path = args[1];
const mingw_src_path = args[2];
tools/update_netbsd_libc.zig
+4 -9
View File
@@ -12,16 +12,11 @@ const exempt_files = [_][]const u8{
"abilists",
};
pub fn main() !void {
var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena_instance.deinit();
const arena = arena_instance.allocator();
pub fn main(init: std.process.Init) !void {
const arena = init.arena.allocator();
const io = init.io;
const args = try init.minimal.args.toSlice(arena);
var threaded: Io.Threaded = .init(arena, .{});
defer threaded.deinit();
const io = threaded.io();
const args = try std.process.argsAlloc(arena);
const netbsd_src_path = args[1];
const zig_src_path = args[2];