Commit 105db13536b4dc2affe130cb8d2eee6c97c89bcd | zig

build.zig+8-8

...	...	@@ -45,7 +45,7 @@ pub fn build(b: *std.Build) !void {
45	45	});
46	46
47	47	const docgen_cmd = b.addRunArtifact(docgen_exe);
48		docgen_cmd.addArgs(&.{ "--zig", b.zig_exe });
	48	docgen_cmd.addArgs(&.{ "--zig", b.graph.zig_exe });
49	49	if (b.zig_lib_dir) \|p\| {
50	50	docgen_cmd.addArg("--zig-lib-dir");
51	51	docgen_cmd.addDirectoryArg(p);
...	...	@@ -410,14 +410,14 @@ pub fn build(b: *std.Build) !void {
410	410	test_cases_options.addOption(bool, "only_c", only_c);
411	411	test_cases_options.addOption(bool, "only_core_functionality", true);
412	412	test_cases_options.addOption(bool, "only_reduce", false);
413		test_cases_options.addOption(bool, "enable_qemu", b.enable_qemu);
414		test_cases_options.addOption(bool, "enable_wine", b.enable_wine);
415		test_cases_options.addOption(bool, "enable_wasmtime", b.enable_wasmtime);
416		test_cases_options.addOption(bool, "enable_rosetta", b.enable_rosetta);
417		test_cases_options.addOption(bool, "enable_darling", b.enable_darling);
	413	test_cases_options.addOption(bool, "enable_qemu", b.graph.enable_qemu);
	414	test_cases_options.addOption(bool, "enable_wine", b.graph.enable_wine);
	415	test_cases_options.addOption(bool, "enable_wasmtime", b.graph.enable_wasmtime);
	416	test_cases_options.addOption(bool, "enable_rosetta", b.graph.enable_rosetta);
	417	test_cases_options.addOption(bool, "enable_darling", b.graph.enable_darling);
418	418	test_cases_options.addOption(u32, "mem_leak_frames", mem_leak_frames * 2);
419	419	test_cases_options.addOption(bool, "value_tracing", value_tracing);
420		test_cases_options.addOption(?[]const u8, "glibc_runtimes_dir", b.glibc_runtimes_dir);
	420	test_cases_options.addOption(?[]const u8, "glibc_runtimes_dir", b.graph.glibc_runtimes_dir);
421	421	test_cases_options.addOption([:0]const u8, "version", version);
422	422	test_cases_options.addOption(std.SemanticVersion, "semver", semver);
423	423	test_cases_options.addOption(?[]const u8, "test_filter", test_filter);
...	...	@@ -884,7 +884,7 @@ fn findConfigH(b: *std.Build, config_h_path_option: ?[]const u8) ?[]const u8 {
884	884	}
885	885	}
886	886
887		var check_dir = fs.path.dirname(b.zig_exe).?;
	887	var check_dir = fs.path.dirname(b.graph.zig_exe).?;
888	888	while (true) {
889	889	var dir = fs.cwd().openDir(check_dir, .{}) catch unreachable;
890	890	defer dir.close();

deps/aro/build/GenerateDef.zig+1-1

...	...	@@ -53,7 +53,7 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {
53	53	const self = @fieldParentPtr(GenerateDef, "step", step);
54	54	const arena = b.allocator;
55	55
56		var man = b.cache.obtain();
	56	var man = b.graph.cache.obtain();
57	57	defer man.deinit();
58	58
59	59	// Random bytes to make GenerateDef unique. Refresh this with new

lib/build_runner.zig+50-40

...	...	@@ -46,11 +46,6 @@ pub fn main() !void {
46	46	return error.InvalidArgs;
47	47	};
48	48
49		const host: std.Build.ResolvedTarget = .{
50		.query = .{},
51		.result = try std.zig.system.resolveTargetQuery(.{}),
52		};
53
54	49	const build_root_directory: std.Build.Cache.Directory = .{
55	50	.path = build_root,
56	51	.handle = try std.fs.cwd().openDir(build_root, .{}),
...	...	@@ -66,28 +61,28 @@ pub fn main() !void {
66	61	.handle = try std.fs.cwd().makeOpenPath(global_cache_root, .{}),
67	62	};
68	63
69		var cache: std.Build.Cache = .{
70		.gpa = arena,
71		.manifest_dir = try local_cache_directory.handle.makeOpenPath("h", .{}),
	64	var graph: std.Build.Graph = .{
	65	.arena = arena,
	66	.cache = .{
	67	.gpa = arena,
	68	.manifest_dir = try local_cache_directory.handle.makeOpenPath("h", .{}),
	69	},
	70	.zig_exe = zig_exe,
	71	.env_map = try process.getEnvMap(arena),
	72	.global_cache_root = global_cache_directory,
72	73	};
73		cache.addPrefix(.{ .path = null, .handle = std.fs.cwd() });
74		cache.addPrefix(build_root_directory);
75		cache.addPrefix(local_cache_directory);
76		cache.addPrefix(global_cache_directory);
77		cache.hash.addBytes(builtin.zig_version_string);
78	74
79		var system_library_options: std.StringArrayHashMapUnmanaged(std.Build.SystemLibraryMode) = .{};
	75	graph.cache.addPrefix(.{ .path = null, .handle = std.fs.cwd() });
	76	graph.cache.addPrefix(build_root_directory);
	77	graph.cache.addPrefix(local_cache_directory);
	78	graph.cache.addPrefix(global_cache_directory);
	79	graph.cache.hash.addBytes(builtin.zig_version_string);
80	80
81	81	const builder = try std.Build.create(
82		arena,
83		zig_exe,
	82	&graph,
84	83	build_root_directory,
85	84	local_cache_directory,
86		global_cache_directory,
87		host,
88		&cache,
89	85	dependencies.root_deps,
90		&system_library_options,
91	86	);
92	87
93	88	var targets = ArrayList([]const u8).init(arena);
...	...	@@ -132,10 +127,16 @@ pub fn main() !void {
132	127	steps_menu = true;
133	128	} else if (mem.eql(u8, arg, "--system-lib")) {
134	129	const name = nextArgOrFatal(args, &arg_idx);
135		builder.system_library_options.put(arena, name, .user_enabled) catch @panic("OOM");
	130	graph.system_library_options.put(arena, name, .user_enabled) catch @panic("OOM");
136	131	} else if (mem.eql(u8, arg, "--no-system-lib")) {
137	132	const name = nextArgOrFatal(args, &arg_idx);
138		builder.system_library_options.put(arena, name, .user_disabled) catch @panic("OOM");
	133	graph.system_library_options.put(arena, name, .user_disabled) catch @panic("OOM");
	134	} else if (mem.eql(u8, arg, "--host-target")) {
	135	graph.host_query_options.arch_os_abi = nextArgOrFatal(args, &arg_idx);
	136	} else if (mem.eql(u8, arg, "--host-cpu")) {
	137	graph.host_query_options.cpu_features = nextArgOrFatal(args, &arg_idx);
	138	} else if (mem.eql(u8, arg, "--host-dynamic-linker")) {
	139	graph.host_query_options.dynamic_linker = nextArgOrFatal(args, &arg_idx);
139	140	} else if (mem.eql(u8, arg, "--prefix-lib-dir")) {
140	141	dir_list.lib_dir = nextArgOrFatal(args, &arg_idx);
141	142	} else if (mem.eql(u8, arg, "--prefix-exe-dir")) {
...	...	@@ -193,7 +194,7 @@ pub fn main() !void {
193	194	} else if (mem.eql(u8, arg, "--debug-compile-errors")) {
194	195	builder.debug_compile_errors = true;
195	196	} else if (mem.eql(u8, arg, "--glibc-runtimes")) {
196		builder.glibc_runtimes_dir = nextArgOrFatal(args, &arg_idx);
	197	graph.glibc_runtimes_dir = nextArgOrFatal(args, &arg_idx);
197	198	} else if (mem.eql(u8, arg, "--verbose-link")) {
198	199	builder.verbose_link = true;
199	200	} else if (mem.eql(u8, arg, "--verbose-air")) {
...	...	@@ -213,25 +214,25 @@ pub fn main() !void {
213	214	} else if (mem.eql(u8, arg, "--prominent-compile-errors")) {
214	215	prominent_compile_errors = true;
215	216	} else if (mem.eql(u8, arg, "-fwine")) {
216		builder.enable_wine = true;
	217	graph.enable_wine = true;
217	218	} else if (mem.eql(u8, arg, "-fno-wine")) {
218		builder.enable_wine = false;
	219	graph.enable_wine = false;
219	220	} else if (mem.eql(u8, arg, "-fqemu")) {
220		builder.enable_qemu = true;
	221	graph.enable_qemu = true;
221	222	} else if (mem.eql(u8, arg, "-fno-qemu")) {
222		builder.enable_qemu = false;
	223	graph.enable_qemu = false;
223	224	} else if (mem.eql(u8, arg, "-fwasmtime")) {
224		builder.enable_wasmtime = true;
	225	graph.enable_wasmtime = true;
225	226	} else if (mem.eql(u8, arg, "-fno-wasmtime")) {
226		builder.enable_wasmtime = false;
	227	graph.enable_wasmtime = false;
227	228	} else if (mem.eql(u8, arg, "-frosetta")) {
228		builder.enable_rosetta = true;
	229	graph.enable_rosetta = true;
229	230	} else if (mem.eql(u8, arg, "-fno-rosetta")) {
230		builder.enable_rosetta = false;
	231	graph.enable_rosetta = false;
231	232	} else if (mem.eql(u8, arg, "-fdarling")) {
232		builder.enable_darling = true;
	233	graph.enable_darling = true;
233	234	} else if (mem.eql(u8, arg, "-fno-darling")) {
234		builder.enable_darling = false;
	235	graph.enable_darling = false;
235	236	} else if (mem.eql(u8, arg, "-freference-trace")) {
236	237	builder.reference_trace = 256;
237	238	} else if (mem.startsWith(u8, arg, "-freference-trace=")) {
...	...	@@ -266,11 +267,19 @@ pub fn main() !void {
266	267	}
267	268	}
268	269
	270	const host_query = std.Build.parseTargetQuery(graph.host_query_options) catch \|err\| switch (err) {
	271	error.ParseFailed => process.exit(1),
	272	};
	273	builder.host = .{
	274	.query = .{},
	275	.result = try std.zig.system.resolveTargetQuery(host_query),
	276	};
	277
269	278	const stderr = std.io.getStdErr();
270	279	const ttyconf = get_tty_conf(color, stderr);
271	280	switch (ttyconf) {
272		.no_color => try builder.env_map.put("NO_COLOR", "1"),
273		.escape_codes => try builder.env_map.put("YES_COLOR", "1"),
	281	.no_color => try graph.env_map.put("NO_COLOR", "1"),
	282	.escape_codes => try graph.env_map.put("YES_COLOR", "1"),
274	283	.windows_api => {},
275	284	}
276	285
...	...	@@ -1029,7 +1038,7 @@ fn usage(b: *std.Build, out_stream: anytype) !void {
1029	1038	\\
1030	1039	\\Steps:
1031	1040	\\
1032		, .{b.zig_exe});
	1041	, .{b.graph.zig_exe});
1033	1042	try steps(b, out_stream);
1034	1043
1035	1044	try out_stream.writeAll(
...	...	@@ -1104,22 +1113,23 @@ fn usage(b: *std.Build, out_stream: anytype) !void {
1104	1113	\\ --system [dir] System Package Mode. Disable fetching; prefer system libs
1105	1114	\\ --host-target [triple] Use the provided target as the host
1106	1115	\\ --host-cpu [cpu] Use the provided CPU as the host
	1116	\\ --host-dynamic-linker [path] Use the provided dynamic linker as the host
1107	1117	\\ --system-lib [name] Use the system-provided library
1108	1118	\\ --no-system-lib [name] Do not use the system-provided library
1109	1119	\\
1110	1120	\\ Available System Library Integrations: Enabled:
1111	1121	\\
1112	1122	);
1113		if (b.system_library_options.entries.len == 0) {
	1123	if (b.graph.system_library_options.entries.len == 0) {
1114	1124	try out_stream.writeAll(" (none) -\n");
1115	1125	} else {
1116		for (b.system_library_options.keys(), b.system_library_options.values()) \|name, v\| {
	1126	for (b.graph.system_library_options.keys(), b.graph.system_library_options.values()) \|k, v\| {
1117	1127	const status = switch (v) {
1118	1128	.declared_enabled => "yes",
1119	1129	.declared_disabled => "no",
1120	1130	.user_enabled, .user_disabled => unreachable, // already emitted error
1121	1131	};
1122		try out_stream.print(" {s:<43} {s}\n", .{ name, status });
	1132	try out_stream.print(" {s:<43} {s}\n", .{ k, status });
1123	1133	}
1124	1134	}
1125	1135
...	...	@@ -1203,7 +1213,7 @@ fn fatal(comptime f: []const u8, args: anytype) noreturn {
1203	1213
1204	1214	fn validateSystemLibraryOptions(b: *std.Build) void {
1205	1215	var bad = false;
1206		for (b.system_library_options.keys(), b.system_library_options.values()) \|k, v\| {
	1216	for (b.graph.system_library_options.keys(), b.graph.system_library_options.values()) \|k, v\| {
1207	1217	switch (v) {
1208	1218	.user_disabled, .user_enabled => {
1209	1219	// The user tried to enable or disable a system library integration, but

lib/std/Build.zig+115-122

...	...	@@ -22,15 +22,14 @@ pub const Cache = @import("Build/Cache.zig");
22	22	pub const Step = @import("Build/Step.zig");
23	23	pub const Module = @import("Build/Module.zig");
24	24
	25	/// Shared state among all Build instances.
	26	graph: *Graph,
25	27	install_tls: TopLevelStep,
26	28	uninstall_tls: TopLevelStep,
27	29	allocator: Allocator,
28	30	user_input_options: UserInputOptionsMap,
29	31	available_options_map: AvailableOptionsMap,
30	32	available_options_list: ArrayList(AvailableOption),
31		/// All Build instances share this hash map.
32		system_library_options: *std.StringArrayHashMapUnmanaged(SystemLibraryMode),
33		system_package_mode: bool,
34	33	verbose: bool,
35	34	verbose_link: bool,
36	35	verbose_cc: bool,
...	...	@@ -41,9 +40,7 @@ verbose_cimport: bool,
41	40	verbose_llvm_cpu_features: bool,
42	41	reference_trace: ?u32 = null,
43	42	invalid_user_input: bool,
44		zig_exe: [:0]const u8,
45	43	default_step: *Step,
46		env_map: *EnvMap,
47	44	top_level_steps: std.StringArrayHashMapUnmanaged(*TopLevelStep),
48	45	install_prefix: []const u8,
49	46	dest_dir: ?[]const u8,
...	...	@@ -52,14 +49,12 @@ exe_dir: []const u8,
52	49	h_dir: []const u8,
53	50	install_path: []const u8,
54	51	sysroot: ?[]const u8 = null,
55		search_prefixes: ArrayList([]const u8),
	52	search_prefixes: std.ArrayListUnmanaged([]const u8),
56	53	libc_file: ?[]const u8 = null,
57	54	installed_files: ArrayList(InstalledFile),
58	55	/// Path to the directory containing build.zig.
59	56	build_root: Cache.Directory,
60	57	cache_root: Cache.Directory,
61		global_cache_root: Cache.Directory,
62		cache: *Cache,
63	58	zig_lib_dir: ?LazyPath,
64	59	pkg_config_pkg_list: ?(PkgConfigError![]const PkgConfigPkg) = null,
65	60	args: ?[][]const u8 = null,
...	...	@@ -71,22 +66,6 @@ debug_pkg_config: bool = false,
71	66	/// Set to 0 to disable stack collection.
72	67	debug_stack_frames_count: u8 = 8,
73	68
74		/// Experimental. Use system Darling installation to run cross compiled macOS build artifacts.
75		enable_darling: bool = false,
76		/// Use system QEMU installation to run cross compiled foreign architecture build artifacts.
77		enable_qemu: bool = false,
78		/// Darwin. Use Rosetta to run x86_64 macOS build artifacts on arm64 macOS.
79		enable_rosetta: bool = false,
80		/// Use system Wasmtime installation to run cross compiled wasm/wasi build artifacts.
81		enable_wasmtime: bool = false,
82		/// Use system Wine installation to run cross compiled Windows build artifacts.
83		enable_wine: bool = false,
84		/// After following the steps in https://github.com/ziglang/zig/wiki/Updating-libc#glibc,
85		/// this will be the directory $glibc-build-dir/install/glibcs
86		/// Given the example of the aarch64 target, this is the directory
87		/// that contains the path `aarch64-linux-gnu/lib/ld-linux-aarch64.so.1`.
88		glibc_runtimes_dir: ?[]const u8 = null,
89
90	69	/// Information about the native target. Computed before build() is invoked.
91	70	host: ResolvedTarget,
92	71
...	...	@@ -101,9 +80,38 @@ initialized_deps: *InitializedDepMap,
101	80	/// A mapping from dependency names to package hashes.
102	81	available_deps: AvailableDeps,
103	82
	83	/// Shared state among all Build instances.
	84	/// Settings that are here rather than in Build are not configurable per-package.
	85	pub const Graph = struct {
	86	arena: Allocator,
	87	system_library_options: std.StringArrayHashMapUnmanaged(SystemLibraryMode) = .{},
	88	system_package_mode: bool = false,
	89	cache: Cache,
	90	zig_exe: [:0]const u8,
	91	env_map: EnvMap,
	92	global_cache_root: Cache.Directory,
	93	host_query_options: std.Target.Query.ParseOptions = .{},
	94
	95	/// Experimental. Use system Darling installation to run cross compiled macOS build artifacts.
	96	enable_darling: bool = false,
	97	/// Use system QEMU installation to run cross compiled foreign architecture build artifacts.
	98	enable_qemu: bool = false,
	99	/// Darwin. Use Rosetta to run x86_64 macOS build artifacts on arm64 macOS.
	100	enable_rosetta: bool = false,
	101	/// Use system Wasmtime installation to run cross compiled wasm/wasi build artifacts.
	102	enable_wasmtime: bool = false,
	103	/// Use system Wine installation to run cross compiled Windows build artifacts.
	104	enable_wine: bool = false,
	105	/// After following the steps in https://github.com/ziglang/zig/wiki/Updating-libc#glibc,
	106	/// this will be the directory $glibc-build-dir/install/glibcs
	107	/// Given the example of the aarch64 target, this is the directory
	108	/// that contains the path `aarch64-linux-gnu/lib/ld-linux-aarch64.so.1`.
	109	glibc_runtimes_dir: ?[]const u8 = null,
	110	};
	111
104	112	const AvailableDeps = []const struct { []const u8, []const u8 };
105	113
106		pub const SystemLibraryMode = enum {
	114	const SystemLibraryMode = enum {
107	115	/// User asked for the library to be disabled.
108	116	/// The build runner has not confirmed whether the setting is recognized yet.
109	117	user_disabled,
...	...	@@ -226,29 +234,20 @@ pub const DirList = struct {
226	234	};
227	235
228	236	pub fn create(
229		allocator: Allocator,
230		zig_exe: [:0]const u8,
	237	graph: *Graph,
231	238	build_root: Cache.Directory,
232	239	cache_root: Cache.Directory,
233		global_cache_root: Cache.Directory,
234		host: ResolvedTarget,
235		cache: *Cache,
236	240	available_deps: AvailableDeps,
237		system_library_options: *std.StringArrayHashMapUnmanaged(SystemLibraryMode),
238	241	) !*Build {
239		const env_map = try allocator.create(EnvMap);
240		env_map.* = try process.getEnvMap(allocator);
	242	const arena = graph.arena;
	243	const initialized_deps = try arena.create(InitializedDepMap);
	244	initialized_deps.* = InitializedDepMap.initContext(arena, .{ .allocator = arena });
241	245
242		const initialized_deps = try allocator.create(InitializedDepMap);
243		initialized_deps.* = InitializedDepMap.initContext(allocator, .{ .allocator = allocator });
244
245		const self = try allocator.create(Build);
	246	const self = try arena.create(Build);
246	247	self.* = .{
247		.zig_exe = zig_exe,
	248	.graph = graph,
248	249	.build_root = build_root,
249	250	.cache_root = cache_root,
250		.global_cache_root = global_cache_root,
251		.cache = cache,
252	251	.verbose = false,
253	252	.verbose_link = false,
254	253	.verbose_cc = false,
...	...	@@ -258,20 +257,19 @@ pub fn create(
258	257	.verbose_cimport = false,
259	258	.verbose_llvm_cpu_features = false,
260	259	.invalid_user_input = false,
261		.allocator = allocator,
262		.user_input_options = UserInputOptionsMap.init(allocator),
263		.available_options_map = AvailableOptionsMap.init(allocator),
264		.available_options_list = ArrayList(AvailableOption).init(allocator),
	260	.allocator = arena,
	261	.user_input_options = UserInputOptionsMap.init(arena),
	262	.available_options_map = AvailableOptionsMap.init(arena),
	263	.available_options_list = ArrayList(AvailableOption).init(arena),
265	264	.top_level_steps = .{},
266	265	.default_step = undefined,
267		.env_map = env_map,
268		.search_prefixes = ArrayList([]const u8).init(allocator),
	266	.search_prefixes = .{},
269	267	.install_prefix = undefined,
270	268	.lib_dir = undefined,
271	269	.exe_dir = undefined,
272	270	.h_dir = undefined,
273		.dest_dir = env_map.get("DESTDIR"),
274		.installed_files = ArrayList(InstalledFile).init(allocator),
	271	.dest_dir = graph.env_map.get("DESTDIR"),
	272	.installed_files = ArrayList(InstalledFile).init(arena),
275	273	.install_tls = .{
276	274	.step = Step.init(.{
277	275	.id = .top_level,
...	...	@@ -292,16 +290,14 @@ pub fn create(
292	290	.zig_lib_dir = null,
293	291	.install_path = undefined,
294	292	.args = null,
295		.host = host,
296		.modules = std.StringArrayHashMap(*Module).init(allocator),
297		.named_writefiles = std.StringArrayHashMap(*Step.WriteFile).init(allocator),
	293	.host = undefined,
	294	.modules = std.StringArrayHashMap(*Module).init(arena),
	295	.named_writefiles = std.StringArrayHashMap(*Step.WriteFile).init(arena),
298	296	.initialized_deps = initialized_deps,
299	297	.available_deps = available_deps,
300		.system_library_options = system_library_options,
301		.system_package_mode = false,
302	298	};
303		try self.top_level_steps.put(allocator, self.install_tls.step.name, &self.install_tls);
304		try self.top_level_steps.put(allocator, self.uninstall_tls.step.name, &self.uninstall_tls);
	299	try self.top_level_steps.put(arena, self.install_tls.step.name, &self.install_tls);
	300	try self.top_level_steps.put(arena, self.uninstall_tls.step.name, &self.uninstall_tls);
305	301	self.default_step = &self.install_tls.step;
306	302	return self;
307	303	}
...	...	@@ -328,6 +324,7 @@ fn createChildOnly(
328	324	const allocator = parent.allocator;
329	325	const child = try allocator.create(Build);
330	326	child.* = .{
	327	.graph = parent.graph,
331	328	.allocator = allocator,
332	329	.install_tls = .{
333	330	.step = Step.init(.{
...	...	@@ -359,9 +356,7 @@ fn createChildOnly(
359	356	.verbose_llvm_cpu_features = parent.verbose_llvm_cpu_features,
360	357	.reference_trace = parent.reference_trace,
361	358	.invalid_user_input = false,
362		.zig_exe = parent.zig_exe,
363	359	.default_step = undefined,
364		.env_map = parent.env_map,
365	360	.top_level_steps = .{},
366	361	.install_prefix = undefined,
367	362	.dest_dir = parent.dest_dir,
...	...	@@ -375,26 +370,16 @@ fn createChildOnly(
375	370	.installed_files = ArrayList(InstalledFile).init(allocator),
376	371	.build_root = build_root,
377	372	.cache_root = parent.cache_root,
378		.global_cache_root = parent.global_cache_root,
379		.cache = parent.cache,
380	373	.zig_lib_dir = parent.zig_lib_dir,
381	374	.debug_log_scopes = parent.debug_log_scopes,
382	375	.debug_compile_errors = parent.debug_compile_errors,
383	376	.debug_pkg_config = parent.debug_pkg_config,
384		.enable_darling = parent.enable_darling,
385		.enable_qemu = parent.enable_qemu,
386		.enable_rosetta = parent.enable_rosetta,
387		.enable_wasmtime = parent.enable_wasmtime,
388		.enable_wine = parent.enable_wine,
389		.glibc_runtimes_dir = parent.glibc_runtimes_dir,
390	377	.host = parent.host,
391	378	.dep_prefix = parent.fmt("{s}{s}.", .{ parent.dep_prefix, dep_name }),
392	379	.modules = std.StringArrayHashMap(*Module).init(allocator),
393	380	.named_writefiles = std.StringArrayHashMap(*Step.WriteFile).init(allocator),
394	381	.initialized_deps = parent.initialized_deps,
395	382	.available_deps = pkg_deps,
396		.system_library_options = parent.system_library_options,
397		.system_package_mode = parent.system_package_mode,
398	383	};
399	384	try child.top_level_steps.put(allocator, child.install_tls.step.name, &child.install_tls);
400	385	try child.top_level_steps.put(allocator, child.uninstall_tls.step.name, &child.uninstall_tls);
...	...	@@ -572,7 +557,7 @@ fn hashUserInputOptionsMap(allocator: Allocator, user_input_options: UserInputOp
572	557	fn determineAndApplyInstallPrefix(b: *Build) !void {
573	558	// Create an installation directory local to this package. This will be used when
574	559	// dependant packages require a standard prefix, such as include directories for C headers.
575		var hash = b.cache.hash;
	560	var hash = b.graph.cache.hash;
576	561	// Random bytes to make unique. Refresh this with new random bytes when
577	562	// implementation is modified in a non-backwards-compatible way.
578	563	hash.add(@as(u32, 0xd8cb0055));
...	...	@@ -587,12 +572,6 @@ fn determineAndApplyInstallPrefix(b: *Build) !void {
587	572	b.resolveInstallPrefix(install_prefix, .{});
588	573	}
589	574
590		pub fn destroy(b: *Build) void {
591		b.env_map.deinit();
592		b.top_level_steps.deinit(b.allocator);
593		b.allocator.destroy(b);
594		}
595
596	575	/// This function is intended to be called by lib/build_runner.zig, not a build.zig file.
597	576	pub fn resolveInstallPrefix(self: *Build, install_prefix: ?[]const u8, dir_list: DirList) void {
598	577	if (self.dest_dir) \|dest_dir\| {
...	...	@@ -1273,67 +1252,83 @@ pub fn standardTargetOptions(b: *Build, args: StandardTargetOptionsArgs) Resolve
1273	1252	return b.resolveTargetQuery(query);
1274	1253	}
1275	1254
1276		/// Exposes standard `zig build` options for choosing a target.
1277		pub fn standardTargetOptionsQueryOnly(b: *Build, args: StandardTargetOptionsArgs) Target.Query {
1278		const maybe_triple = b.option(
1279		[]const u8,
1280		"target",
1281		"The CPU architecture, OS, and ABI to build for",
1282		);
1283		const mcpu = b.option([]const u8, "cpu", "Target CPU features to add or subtract");
1284
1285		if (maybe_triple == null and mcpu == null) {
1286		return args.default_target;
1287		}
1288
1289		const triple = maybe_triple orelse "native";
1290
	1255	pub fn parseTargetQuery(options: std.Target.Query.ParseOptions) error{ParseFailed}!std.Target.Query {
1291	1256	var diags: Target.Query.ParseOptions.Diagnostics = .{};
1292		const selected_target = Target.Query.parse(.{
1293		.arch_os_abi = triple,
1294		.cpu_features = mcpu,
1295		.diagnostics = &diags,
1296		}) catch \|err\| switch (err) {
	1257	var opts_copy = options;
	1258	opts_copy.diagnostics = &diags;
	1259	return std.Target.Query.parse(options) catch \|err\| switch (err) {
1297	1260	error.UnknownCpuModel => {
1298		log.err("Unknown CPU: '{s}'\nAvailable CPUs for architecture '{s}':", .{
1299		diags.cpu_name.?,
1300		@tagName(diags.arch.?),
	1261	std.debug.print("unknown CPU: '{s}'\navailable CPUs for architecture '{s}':\n", .{
	1262	diags.cpu_name.?, @tagName(diags.arch.?),
1301	1263	});
1302	1264	for (diags.arch.?.allCpuModels()) \|cpu\| {
1303		log.err(" {s}", .{cpu.name});
	1265	std.debug.print(" {s}\n", .{cpu.name});
1304	1266	}
1305		b.markInvalidUserInput();
1306		return args.default_target;
	1267	return error.ParseFailed;
1307	1268	},
1308	1269	error.UnknownCpuFeature => {
1309		log.err(
1310		\\Unknown CPU feature: '{s}'
1311		\\Available CPU features for architecture '{s}':
	1270	std.debug.print(
	1271	\\unknown CPU feature: '{s}'
	1272	\\available CPU features for architecture '{s}':
1312	1273	\\
1313	1274	, .{
1314	1275	diags.unknown_feature_name.?,
1315	1276	@tagName(diags.arch.?),
1316	1277	});
1317	1278	for (diags.arch.?.allFeaturesList()) \|feature\| {
1318		log.err(" {s}: {s}", .{ feature.name, feature.description });
	1279	std.debug.print(" {s}: {s}\n", .{ feature.name, feature.description });
1319	1280	}
1320		b.markInvalidUserInput();
1321		return args.default_target;
	1281	return error.ParseFailed;
1322	1282	},
1323	1283	error.UnknownOperatingSystem => {
1324		log.err(
1325		\\Unknown OS: '{s}'
1326		\\Available operating systems:
	1284	std.debug.print(
	1285	\\unknown OS: '{s}'
	1286	\\available operating systems:
1327	1287	\\
1328	1288	, .{diags.os_name.?});
1329	1289	inline for (std.meta.fields(Target.Os.Tag)) \|field\| {
1330		log.err(" {s}", .{field.name});
	1290	std.debug.print(" {s}\n", .{field.name});
1331	1291	}
1332		b.markInvalidUserInput();
1333		return args.default_target;
	1292	return error.ParseFailed;
1334	1293	},
1335	1294	else => \|e\| {
1336		log.err("Unable to parse target '{s}': {s}\n", .{ triple, @errorName(e) });
	1295	std.debug.print("unable to parse target '{s}': {s}\n", .{
	1296	options.arch_os_abi, @errorName(e),
	1297	});
	1298	return error.ParseFailed;
	1299	},
	1300	};
	1301	}
	1302
	1303	/// Exposes standard `zig build` options for choosing a target.
	1304	pub fn standardTargetOptionsQueryOnly(b: *Build, args: StandardTargetOptionsArgs) Target.Query {
	1305	const maybe_triple = b.option(
	1306	[]const u8,
	1307	"target",
	1308	"The CPU architecture, OS, and ABI to build for",
	1309	);
	1310	const mcpu = b.option(
	1311	[]const u8,
	1312	"cpu",
	1313	"Target CPU features to add or subtract",
	1314	);
	1315	const dynamic_linker = b.option(
	1316	[]const u8,
	1317	"dynamic-linker",
	1318	"Path to interpreter on the target system",
	1319	);
	1320
	1321	if (maybe_triple == null and mcpu == null and dynamic_linker == null)
	1322	return args.default_target;
	1323
	1324	const triple = maybe_triple orelse "native";
	1325
	1326	const selected_target = parseTargetQuery(.{
	1327	.arch_os_abi = triple,
	1328	.cpu_features = mcpu,
	1329	.dynamic_linker = dynamic_linker,
	1330	}) catch \|err\| switch (err) {
	1331	error.ParseFailed => {
1337	1332	b.markInvalidUserInput();
1338	1333	return args.default_target;
1339	1334	},
...	...	@@ -1622,7 +1617,7 @@ pub fn findProgram(self: *Build, names: []const []const u8, paths: []const []con
1622	1617	return fs.realpathAlloc(self.allocator, full_path) catch continue;
1623	1618	}
1624	1619	}
1625		if (self.env_map.get("PATH")) \|PATH\| {
	1620	if (self.graph.env_map.get("PATH")) \|PATH\| {
1626	1621	for (names) \|name\| {
1627	1622	if (fs.path.isAbsolute(name)) {
1628	1623	return name;
...	...	@@ -1668,7 +1663,7 @@ pub fn runAllowFail(
1668	1663	child.stdin_behavior = .Ignore;
1669	1664	child.stdout_behavior = .Pipe;
1670	1665	child.stderr_behavior = stderr_behavior;
1671		child.env_map = self.env_map;
	1666	child.env_map = &self.graph.env_map;
1672	1667
1673	1668	try child.spawn();
1674	1669
...	...	@@ -1714,8 +1709,8 @@ pub fn run(b: *Build, argv: []const []const u8) []u8 {
1714	1709	};
1715	1710	}
1716	1711
1717		pub fn addSearchPrefix(self: *Build, search_prefix: []const u8) void {
1718		self.search_prefixes.append(self.dupePath(search_prefix)) catch @panic("OOM");
	1712	pub fn addSearchPrefix(b: *Build, search_prefix: []const u8) void {
	1713	b.search_prefixes.append(b.allocator, b.dupePath(search_prefix)) catch @panic("OOM");
1719	1714	}
1720	1715
1721	1716	pub fn getInstallPath(self: *Build, dir: InstallDir, dest_rel_path: []const u8) []const u8 {
...	...	@@ -2310,9 +2305,7 @@ pub const ResolvedTarget = struct {
2310	2305	/// Converts a target query into a fully resolved target that can be passed to
2311	2306	/// various parts of the API.
2312	2307	pub fn resolveTargetQuery(b: *Build, query: Target.Query) ResolvedTarget {
2313		// This context will likely be required in the future when the target is
2314		// resolved via a WASI API or via the build protocol.
2315		_ = b;
	2308	if (query.isNative()) return b.host;
2316	2309
2317	2310	return .{
2318	2311	.query = query,
...	...	@@ -2326,7 +2319,7 @@ pub fn wantSharedLibSymLinks(target: Target) bool {
2326	2319	}
2327	2320
2328	2321	pub fn systemLibraryOption(b: *Build, name: []const u8) bool {
2329		const gop = b.system_library_options.getOrPut(b.allocator, name) catch @panic("OOM");
	2322	const gop = b.graph.system_library_options.getOrPut(b.allocator, name) catch @panic("OOM");
2330	2323	if (gop.found_existing) switch (gop.value_ptr.*) {
2331	2324	.user_disabled => {
2332	2325	gop.value_ptr.* = .declared_disabled;
...	...	@@ -2340,7 +2333,7 @@ pub fn systemLibraryOption(b: *Build, name: []const u8) bool {
2340	2333	.declared_enabled => return true,
2341	2334	} else {
2342	2335	gop.key_ptr.* = b.dupe(name);
2343		if (b.system_package_mode) {
	2336	if (b.graph.system_package_mode) {
2344	2337	gop.value_ptr.* = .declared_enabled;
2345	2338	return true;
2346	2339	} else {

lib/std/Build/Step.zig+1-1

...	...	@@ -314,7 +314,7 @@ pub fn evalZigProcess(
314	314	try handleVerbose(s.owner, null, argv);
315	315
316	316	var child = std.ChildProcess.init(argv, arena);
317		child.env_map = b.env_map;
	317	child.env_map = &b.graph.env_map;
318	318	child.stdin_behavior = .Pipe;
319	319	child.stdout_behavior = .Pipe;
320	320	child.stderr_behavior = .Pipe;

lib/std/Build/Step/Compile.zig+12-2

...	...	@@ -923,7 +923,7 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {
923	923	var zig_args = ArrayList([]const u8).init(arena);
924	924	defer zig_args.deinit();
925	925
926		try zig_args.append(b.zig_exe);
	926	try zig_args.append(b.graph.zig_exe);
927	927
928	928	const cmd = switch (self.kind) {
929	929	.lib => "build-lib",
...	...	@@ -933,6 +933,16 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {
933	933	};
934	934	try zig_args.append(cmd);
935	935
	936	if (!mem.eql(u8, b.graph.host_query_options.arch_os_abi, "native")) {
	937	try zig_args.appendSlice(&.{ "--host-target", b.graph.host_query_options.arch_os_abi });
	938	}
	939	if (b.graph.host_query_options.cpu_features) \|cpu\| {
	940	try zig_args.appendSlice(&.{ "--host-cpu", cpu });
	941	}
	942	if (b.graph.host_query_options.dynamic_linker) \|dl\| {
	943	try zig_args.appendSlice(&.{ "--host-dynamic-linker", dl });
	944	}
	945
936	946	if (b.reference_trace) \|some\| {
937	947	try zig_args.append(try std.fmt.allocPrint(arena, "-freference-trace={d}", .{some}));
938	948	}
...	...	@@ -1393,7 +1403,7 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {
1393	1403	try zig_args.append(b.cache_root.path orelse ".");
1394	1404
1395	1405	try zig_args.append("--global-cache-dir");
1396		try zig_args.append(b.global_cache_root.path orelse ".");
	1406	try zig_args.append(b.graph.global_cache_root.path orelse ".");
1397	1407
1398	1408	try zig_args.append("--name");
1399	1409	try zig_args.append(self.name);

lib/std/Build/Step/ConfigHeader.zig+1-1

...	...	@@ -171,7 +171,7 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {
171	171	const gpa = b.allocator;
172	172	const arena = b.allocator;
173	173
174		var man = b.cache.obtain();
	174	var man = b.graph.cache.obtain();
175	175	defer man.deinit();
176	176
177	177	// Random bytes to make ConfigHeader unique. Refresh this with new

lib/std/Build/Step/Fmt.zig+1-1

...	...	@@ -52,7 +52,7 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {
52	52	var argv: std.ArrayListUnmanaged([]const u8) = .{};
53	53	try argv.ensureUnusedCapacity(arena, 2 + 1 + self.paths.len + 2 * self.exclude_paths.len);
54	54
55		argv.appendAssumeCapacity(b.zig_exe);
	55	argv.appendAssumeCapacity(b.graph.zig_exe);
56	56	argv.appendAssumeCapacity("fmt");
57	57
58	58	if (self.check) {

lib/std/Build/Step/ObjCopy.zig+2-2

...	...	@@ -94,7 +94,7 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {
94	94	const b = step.owner;
95	95	const self = @fieldParentPtr(ObjCopy, "step", step);
96	96
97		var man = b.cache.obtain();
	97	var man = b.graph.cache.obtain();
98	98	defer man.deinit();
99	99
100	100	// Random bytes to make ObjCopy unique. Refresh this with new random
...	...	@@ -133,7 +133,7 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {
133	133	};
134	134
135	135	var argv = std.ArrayList([]const u8).init(b.allocator);
136		try argv.appendSlice(&.{ b.zig_exe, "objcopy" });
	136	try argv.appendSlice(&.{ b.graph.zig_exe, "objcopy" });
137	137
138	138	if (self.only_section) \|only_section\| {
139	139	try argv.appendSlice(&.{ "-j", only_section });

lib/std/Build/Step/Options.zig+16-15

...	...	@@ -222,7 +222,7 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {
222	222	const basename = "options.zig";
223	223
224	224	// Hash contents to file name.
225		var hash = b.cache.hash;
	225	var hash = b.graph.cache.hash;
226	226	// Random bytes to make unique. Refresh this with new random bytes when
227	227	// implementation is modified in a non-backwards-compatible way.
228	228	hash.add(@as(u32, 0xad95e922));
...	...	@@ -301,27 +301,28 @@ test Options {
301	301	var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
302	302	defer arena.deinit();
303	303
304		const host: std.Build.ResolvedTarget = .{
305		.query = .{},
306		.result = try std.zig.system.resolveTargetQuery(.{}),
307		};
308
309		var cache: std.Build.Cache = .{
310		.gpa = arena.allocator(),
311		.manifest_dir = std.fs.cwd(),
	304	var graph: std.Build.Graph = .{
	305	.arena = arena.allocator(),
	306	.cache = .{
	307	.gpa = arena.allocator(),
	308	.manifest_dir = std.fs.cwd(),
	309	},
	310	.zig_exe = "test",
	311	.env_map = std.process.EnvMap.init(arena.allocator()),
	312	.global_cache_root = .{ .path = "test", .handle = std.fs.cwd() },
312	313	};
313	314
314	315	var builder = try std.Build.create(
315		arena.allocator(),
316		"test",
	316	&graph,
317	317	.{ .path = "test", .handle = std.fs.cwd() },
318	318	.{ .path = "test", .handle = std.fs.cwd() },
319		.{ .path = "test", .handle = std.fs.cwd() },
320		host,
321		&cache,
322	319	&.{},
323	320	);
324		defer builder.destroy();
	321
	322	builder.host = .{
	323	.query = .{},
	324	.result = try std.zig.system.resolveTargetQuery(.{}),
	325	};
325	326
326	327	const options = builder.addOptions();
327	328

lib/std/Build/Step/Run.zig+8-8

...	...	@@ -463,7 +463,7 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {
463	463	var argv_list = ArrayList([]const u8).init(arena);
464	464	var output_placeholders = ArrayList(IndexedOutput).init(arena);
465	465
466		var man = b.cache.obtain();
	466	var man = b.graph.cache.obtain();
467	467	defer man.deinit();
468	468
469	469	for (self.argv.items) \|arg\| {
...	...	@@ -747,7 +747,7 @@ fn runCommand(
747	747	exe.is_linking_libc;
748	748	const other_target = exe.root_module.resolved_target.?.result;
749	749	switch (std.zig.system.getExternalExecutor(b.host.result, &other_target, .{
750		.qemu_fixes_dl = need_cross_glibc and b.glibc_runtimes_dir != null,
	750	.qemu_fixes_dl = need_cross_glibc and b.graph.glibc_runtimes_dir != null,
751	751	.link_libc = exe.is_linking_libc,
752	752	})) {
753	753	.native, .rosetta => {
...	...	@@ -755,7 +755,7 @@ fn runCommand(
755	755	break :interpret;
756	756	},
757	757	.wine => \|bin_name\| {
758		if (b.enable_wine) {
	758	if (b.graph.enable_wine) {
759	759	try interp_argv.append(bin_name);
760	760	try interp_argv.appendSlice(argv);
761	761	} else {
...	...	@@ -763,9 +763,9 @@ fn runCommand(
763	763	}
764	764	},
765	765	.qemu => \|bin_name\| {
766		if (b.enable_qemu) {
	766	if (b.graph.enable_qemu) {
767	767	const glibc_dir_arg = if (need_cross_glibc)
768		b.glibc_runtimes_dir orelse
	768	b.graph.glibc_runtimes_dir orelse
769	769	return failForeign(self, "--glibc-runtimes", argv[0], exe)
770	770	else
771	771	null;
...	...	@@ -798,7 +798,7 @@ fn runCommand(
798	798	}
799	799	},
800	800	.darling => \|bin_name\| {
801		if (b.enable_darling) {
	801	if (b.graph.enable_darling) {
802	802	try interp_argv.append(bin_name);
803	803	try interp_argv.appendSlice(argv);
804	804	} else {
...	...	@@ -806,7 +806,7 @@ fn runCommand(
806	806	}
807	807	},
808	808	.wasmtime => \|bin_name\| {
809		if (b.enable_wasmtime) {
	809	if (b.graph.enable_wasmtime) {
810	810	try interp_argv.append(bin_name);
811	811	try interp_argv.append("--dir=.");
812	812	try interp_argv.append(argv[0]);
...	...	@@ -1036,7 +1036,7 @@ fn spawnChildAndCollect(
1036	1036	child.cwd = b.build_root.path;
1037	1037	child.cwd_dir = b.build_root.handle;
1038	1038	}
1039		child.env_map = self.env_map orelse b.env_map;
	1039	child.env_map = self.env_map orelse &b.graph.env_map;
1040	1040	child.request_resource_usage_statistics = true;
1041	1041
1042	1042	child.stdin_behavior = switch (self.stdio) {

lib/std/Build/Step/TranslateC.zig+1-1

...	...	@@ -121,7 +121,7 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {
121	121	const self = @fieldParentPtr(TranslateC, "step", step);
122	122
123	123	var argv_list = std.ArrayList([]const u8).init(b.allocator);
124		try argv_list.append(b.zig_exe);
	124	try argv_list.append(b.graph.zig_exe);
125	125	try argv_list.append("translate-c");
126	126	if (self.link_libc) {
127	127	try argv_list.append("-lc");

lib/std/Build/Step/WriteFile.zig+1-1

...	...	@@ -190,7 +190,7 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {
190	190	// If, for example, a hard-coded path was used as the location to put WriteFile
191	191	// files, then two WriteFiles executing in parallel might clobber each other.
192	192
193		var man = b.cache.obtain();
	193	var man = b.graph.cache.obtain();
194	194	defer man.deinit();
195	195
196	196	// Random bytes to make WriteFile unique. Refresh this with

test/src/Cases.zig+2-2

...	...	@@ -562,7 +562,7 @@ pub fn lowerToBuildSteps(
562	562	run.setName(incr_case.base_path);
563	563	run.addArgs(&.{
564	564	case_base_path_with_dir,
565		b.zig_exe,
	565	b.graph.zig_exe,
566	566	});
567	567	run.expectStdOutEqual("");
568	568	parent_step.dependOn(&run.step);
...	...	@@ -653,7 +653,7 @@ pub fn lowerToBuildSteps(
653	653	break :no_exec;
654	654	}
655	655	const run_c = b.addSystemCommand(&.{
656		b.zig_exe,
	656	b.graph.zig_exe,
657	657	"run",
658	658	"-cflags",
659	659	"-Ilib",

test/tests.zig+11-11

...	...	@@ -796,7 +796,7 @@ pub fn addCliTests(b: std.Build) Step {
796	796	{
797	797	// Test `zig init`.
798	798	const tmp_path = b.makeTempPath();
799		const init_exe = b.addSystemCommand(&.{ b.zig_exe, "init" });
	799	const init_exe = b.addSystemCommand(&.{ b.graph.zig_exe, "init" });
800	800	init_exe.setCwd(.{ .cwd_relative = tmp_path });
801	801	init_exe.setName("zig init");
802	802	init_exe.expectStdOutEqual("");
...	...	@@ -810,20 +810,20 @@ pub fn addCliTests(b: std.Build) Step {
810	810	const bad_out_arg = "-femit-bin=does" ++ s ++ "not" ++ s ++ "exist" ++ s ++ "foo.exe";
811	811	const ok_src_arg = "src" ++ s ++ "main.zig";
812	812	const expected = "error: unable to open output directory 'does" ++ s ++ "not" ++ s ++ "exist': FileNotFound\n";
813		const run_bad = b.addSystemCommand(&.{ b.zig_exe, "build-exe", ok_src_arg, bad_out_arg });
	813	const run_bad = b.addSystemCommand(&.{ b.graph.zig_exe, "build-exe", ok_src_arg, bad_out_arg });
814	814	run_bad.setName("zig build-exe error message for bad -femit-bin arg");
815	815	run_bad.expectExitCode(1);
816	816	run_bad.expectStdErrEqual(expected);
817	817	run_bad.expectStdOutEqual("");
818	818	run_bad.step.dependOn(&init_exe.step);
819	819
820		const run_test = b.addSystemCommand(&.{ b.zig_exe, "build", "test" });
	820	const run_test = b.addSystemCommand(&.{ b.graph.zig_exe, "build", "test" });
821	821	run_test.setCwd(.{ .cwd_relative = tmp_path });
822	822	run_test.setName("zig build test");
823	823	run_test.expectStdOutEqual("");
824	824	run_test.step.dependOn(&init_exe.step);
825	825
826		const run_run = b.addSystemCommand(&.{ b.zig_exe, "build", "run" });
	826	const run_run = b.addSystemCommand(&.{ b.graph.zig_exe, "build", "run" });
827	827	run_run.setCwd(.{ .cwd_relative = tmp_path });
828	828	run_run.setName("zig build run");
829	829	run_run.expectStdOutEqual("Run `zig build test` to run the tests.\n");
...	...	@@ -857,7 +857,7 @@ pub fn addCliTests(b: std.Build) Step {
857	857
858	858	// This is intended to be the exact CLI usage used by godbolt.org.
859	859	const run = b.addSystemCommand(&.{
860		b.zig_exe, "build-obj",
	860	b.graph.zig_exe, "build-obj",
861	861	"--cache-dir", tmp_path,
862	862	"--name", "example",
863	863	"-fno-emit-bin", "-fno-emit-h",
...	...	@@ -900,7 +900,7 @@ pub fn addCliTests(b: std.Build) Step {
900	900	subdir.writeFile("fmt3.zig", unformatted_code) catch @panic("unhandled");
901	901
902	902	// Test zig fmt affecting only the appropriate files.
903		const run1 = b.addSystemCommand(&.{ b.zig_exe, "fmt", "fmt1.zig" });
	903	const run1 = b.addSystemCommand(&.{ b.graph.zig_exe, "fmt", "fmt1.zig" });
904	904	run1.setName("run zig fmt one file");
905	905	run1.setCwd(.{ .cwd_relative = tmp_path });
906	906	run1.has_side_effects = true;
...	...	@@ -908,7 +908,7 @@ pub fn addCliTests(b: std.Build) Step {
908	908	run1.expectStdOutEqual("fmt1.zig\n");
909	909
910	910	// Test excluding files and directories from a run
911		const run2 = b.addSystemCommand(&.{ b.zig_exe, "fmt", "--exclude", "fmt2.zig", "--exclude", "subdir", "." });
	911	const run2 = b.addSystemCommand(&.{ b.graph.zig_exe, "fmt", "--exclude", "fmt2.zig", "--exclude", "subdir", "." });
912	912	run2.setName("run zig fmt on directory with exclusions");
913	913	run2.setCwd(.{ .cwd_relative = tmp_path });
914	914	run2.has_side_effects = true;
...	...	@@ -916,7 +916,7 @@ pub fn addCliTests(b: std.Build) Step {
916	916	run2.step.dependOn(&run1.step);
917	917
918	918	// Test excluding non-existent file
919		const run3 = b.addSystemCommand(&.{ b.zig_exe, "fmt", "--exclude", "fmt2.zig", "--exclude", "nonexistent.zig", "." });
	919	const run3 = b.addSystemCommand(&.{ b.graph.zig_exe, "fmt", "--exclude", "fmt2.zig", "--exclude", "nonexistent.zig", "." });
920	920	run3.setName("run zig fmt on directory with non-existent exclusion");
921	921	run3.setCwd(.{ .cwd_relative = tmp_path });
922	922	run3.has_side_effects = true;
...	...	@@ -924,7 +924,7 @@ pub fn addCliTests(b: std.Build) Step {
924	924	run3.step.dependOn(&run2.step);
925	925
926	926	// running it on the dir, only the new file should be changed
927		const run4 = b.addSystemCommand(&.{ b.zig_exe, "fmt", "." });
	927	const run4 = b.addSystemCommand(&.{ b.graph.zig_exe, "fmt", "." });
928	928	run4.setName("run zig fmt the directory");
929	929	run4.setCwd(.{ .cwd_relative = tmp_path });
930	930	run4.has_side_effects = true;
...	...	@@ -932,7 +932,7 @@ pub fn addCliTests(b: std.Build) Step {
932	932	run4.step.dependOn(&run3.step);
933	933
934	934	// both files have been formatted, nothing should change now
935		const run5 = b.addSystemCommand(&.{ b.zig_exe, "fmt", "." });
	935	const run5 = b.addSystemCommand(&.{ b.graph.zig_exe, "fmt", "." });
936	936	run5.setName("run zig fmt with nothing to do");
937	937	run5.setCwd(.{ .cwd_relative = tmp_path });
938	938	run5.has_side_effects = true;
...	...	@@ -946,7 +946,7 @@ pub fn addCliTests(b: std.Build) Step {
946	946	write6.step.dependOn(&run5.step);
947	947
948	948	// Test `zig fmt` handling UTF-16 decoding.
949		const run6 = b.addSystemCommand(&.{ b.zig_exe, "fmt", "." });
	949	const run6 = b.addSystemCommand(&.{ b.graph.zig_exe, "fmt", "." });
950	950	run6.setName("run zig fmt convert UTF-16 to UTF-8");
951	951	run6.setCwd(.{ .cwd_relative = tmp_path });
952	952	run6.has_side_effects = true;

author	Andrew Kelley <andrew@ziglang.org> 2024-02-01 15:44:44-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2024-02-02 20:43:01-07:00
log	105db13536b4dc2affe130cb8d2eee6c97c89bcd
tree	07d5a285d7ff1ea5262118e94ea61a018f1d775a
parent	bd1d2b0ae25ead6cd27c0bfeb65490ee92f06bad

std.Build: implement --host-target, --host-cpu, --host-dynamic-linker