MORPH
SIGN IN SIGN UP
ziglang / zig UNCLAIMED

Moved to Codeberg

0 0 0 Zig
Normal View History Raw
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
const builtin = @import("builtin");
std.zig.system: upgrade to std.Io.Reader
2025-10-06 18:34:51 -07:00
const std = @import("std.zig");
const Io = std.Io;
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
const fs = std.fs;
const mem = std.mem;
const debug = std.debug;
const panic = std.debug.panic;
const assert = debug.assert;
const log = std.log;
const StringHashMap = std.StringHashMap;
const Allocator = mem.Allocator;
rename std.zig.CrossTarget to std.Target.Query
2023-12-04 12:35:04 -07:00
const Target = std.Target;
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
const process = std.process;
const EnvMap = std.process.EnvMap;
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
const File = fs.File;
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
const Sha256 = std.crypto.hash.sha2.Sha256;
const Build = @This();
std.ArrayList: make unmanaged the default
2025-07-31 21:54:07 -07:00
const ArrayList = std.ArrayList;
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
move the cache system from compiler to std lib
2023-02-05 19:39:04 -07:00
pub const Cache = @import("Build/Cache.zig");
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
pub const Step = @import("Build/Step.zig");
introduce std.Build.Module and extract some logic into it This moves many settings from `std.Build.Step.Compile` and into `std.Build.Module`, and then makes them transitive. In other words, it adds support for exposing Zig modules in packages, which are configured in various ways, such as depending on other link objects, include paths, or even a different optimization mode. Now, transitive dependencies will be included in the compilation, so you can, for example, make a Zig module depend on some C source code, and expose that Zig module in a package. Currently, the compiler frontend autogenerates only one `@import("builtin")` module for the entire compilation, however, a future enhancement will be to make it honor the differences in modules, so that modules can be compiled with different optimization modes, code model, valgrind integration, or even target CPU feature set. closes #14719
2023-11-28 22:47:34 -07:00
pub const Module = @import("Build/Module.zig");
proof-of-concept --watch implementation based on fanotify So far, only implemented for InstallFile steps. Default debounce interval bumped to 50ms. I think it should be configurable. Next I have an idea to simplify the fanotify implementation, but other OS implementations might want to refer back to this commit before I make those changes.
2024-07-09 18:17:27 -07:00
pub const Watch = @import("Build/Watch.zig");
build runner: extract logic to std.Build.Fuzz
2024-07-23 21:17:14 -07:00
pub const Fuzz = @import("Build/Fuzz.zig");
build system: replace fuzzing UI with build UI, add time report This commit replaces the "fuzzer" UI, previously accessed with the `--fuzz` and `--port` flags, with a more interesting web UI which allows more interactions with the Zig build system. Most notably, it allows accessing the data emitted by a new "time report" system, which allows users to see which parts of Zig programs take the longest to compile. The option to expose the web UI is `--webui`. By default, it will listen on `[::1]` on a random port, but any IPv6 or IPv4 address can be specified with e.g. `--webui=[::1]:8000` or `--webui=127.0.0.1:8000`. The options `--fuzz` and `--time-report` both imply `--webui` if not given. Currently, `--webui` is incompatible with `--watch`; specifying both will cause `zig build` to exit with a fatal error. When the web UI is enabled, the build runner spawns the web server as soon as the configure phase completes. The frontend code consists of one HTML file, one JavaScript file, two CSS files, and a few Zig source files which are built into a WASM blob on-demand -- this is all very similar to the old fuzzer UI. Also inherited from the fuzzer UI is that the build system communicates with web clients over a WebSocket connection. When the build finishes, if `--webui` was passed (i.e. if the web server is running), the build runner does not terminate; it continues running to serve web requests, allowing interactive control of the build system. In the web interface is an overall "status" indicating whether a build is currently running, and also a list of all steps in this build. There are visual indicators (colors and spinners) for in-progress, succeeded, and failed steps. There is a "Rebuild" button which will cause the build system to reset the state of every step (note that this does not affect caching) and evaluate the step graph again. If `--time-report` is passed to `zig build`, a new section of the interface becomes visible, which associates every build step with a "time report". For most steps, this is just a simple "time taken" value. However, for `Compile` steps, the compiler communicates with the build system to provide it with much more interesting information: time taken for various pipeline phases, with a per-declaration and per-file breakdown, sorted by slowest declarations/files first. This feature is still in its early stages: the data can be a little tricky to understand, and there is no way to, for instance, sort by different properties, or filter to certain files. However, it has already given us some interesting statistics, and can be useful for spotting, for instance, particularly complex and slow compile-time logic. Additionally, if a compilation uses LLVM, its time report includes the "LLVM pass timing" information, which was previously accessible with the (now removed) `-ftime-report` compiler flag. To make time reports more useful, ZIR and compilation caches are ignored by the Zig compiler when they are enabled -- in other words, `Compile` steps *always* run, even if their result should be cached. This means that the flag can be used to analyze a project's compile time without having to repeatedly clear cache directory, for instance. However, when using `-fincremental`, updates other than the first will only show you the statistics for what changed on that particular update. Notably, this gives us a fairly nice way to see exactly which declarations were re-analyzed by an incremental update. If `--fuzz` is passed to `zig build`, another section of the web interface becomes visible, this time exposing the fuzzer. This is quite similar to the fuzzer UI this commit replaces, with only a few cosmetic tweaks. The interface is closer than before to supporting multiple fuzz steps at a time (in line with the overall strategy for this build UI, the goal will be for all of the fuzz steps to be accessible in the same interface), but still doesn't actually support it. The fuzzer UI looks quite different under the hood: as a result, various bugs are fixed, although other bugs remain. For instance, viewing the source code of any file other than the root of the main module is completely broken (as on master) due to some bogus file-to-module assignment logic in the fuzzer UI. Implementation notes: * The `lib/build-web/` directory holds the client side of the web UI. * The general server logic is in `std.Build.WebServer`. * Fuzzing-specific logic is in `std.Build.Fuzz`. * `std.Build.abi` is the new home of `std.Build.Fuzz.abi`, since it now relates to the build system web UI in general. * The build runner now has an **actual** general-purpose allocator, because thanks to `--watch` and `--webui`, the process can be arbitrarily long-lived. The gpa is `std.heap.DebugAllocator`, but the arena remains backed by `std.heap.page_allocator` for efficiency. I fixed several crashes caused by conflation of `gpa` and `arena` in the build runner and `std.Build`, but there may still be some I have missed. * The I/O logic in `std.Build.WebServer` is pretty gnarly; there are a *lot* of threads involved. I anticipate this situation improving significantly once the `std.Io` interface (with concurrency support) is introduced.
2025-07-10 09:18:10 +01:00
pub const WebServer = @import("Build/WebServer.zig");
pub const abi = @import("Build/abi.zig");
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
std.Build: implement --host-target, --host-cpu, --host-dynamic-linker This also makes a long-overdue change of extracting common state from Build into a shared Graph object. Getting the semantics right for these flags turned out to be quite tricky. In the end it works like this: * The override only happens when the target is fully native, with no additional query parameters, such as versions or CPU features added. * The override affects the resolved Target but leaves the original Query unmodified. * The "is native?" detection logic operates on the original, unmodified query. This makes it possible to provide invalid host target information, causing confusing errors to occur. Don't do that. There are some minor breaking changes to std.Build API such as the fact that `b.zig_exe` is now moved to `b.graph.zig_exe`, as well as a handful of other similar flags.
2024-02-01 15:44:44 -07:00
/// Shared state among all Build instances.
graph: *Graph,
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
install_tls: TopLevelStep,
uninstall_tls: TopLevelStep,
allocator: Allocator,
user_input_options: UserInputOptionsMap,
available_options_map: AvailableOptionsMap,
std.ArrayList: make unmanaged the default
2025-07-31 21:54:07 -07:00
available_options_list: std.array_list.Managed(AvailableOption),
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
verbose: bool,
verbose_link: bool,
verbose_cc: bool,
verbose_air: bool,
main: add debug option to dump unoptimized llvm ir
2023-03-16 01:32:43 -04:00
verbose_llvm_ir: ?[]const u8,
verbose_llvm_bc: ?[]const u8,
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
verbose_cimport: bool,
verbose_llvm_cpu_features: bool,
reference_trace: ?u32 = null,
invalid_user_input: bool,
default_step: *Step,
extract some logic from std.Build to build_runner.zig
2023-02-13 13:10:20 -07:00
top_level_steps: std.StringArrayHashMapUnmanaged(*TopLevelStep),
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
install_prefix: []const u8,
dest_dir: ?[]const u8,
lib_dir: []const u8,
exe_dir: []const u8,
h_dir: []const u8,
install_path: []const u8,
sysroot: ?[]const u8 = null,
std.ArrayList: make unmanaged the default
2025-07-31 21:54:07 -07:00
search_prefixes: ArrayList([]const u8),
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
libc_file: ?[]const u8 = null,
/// Path to the directory containing build.zig.
std.Build: start using the cache system with RunStep * Use std.Build.Cache.Directory instead of a string for storing the cache roots and build roots. * Set up a std.Build.Cache in build_runner.zig and use it in std.Build.RunStep for avoiding redundant work.
2023-02-09 10:01:01 -07:00
build_root: Cache.Directory,
cache_root: Cache.Directory,
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
pkg_config_pkg_list: ?(PkgConfigError![]const PkgConfigPkg) = null,
std: mark Build.args as const I don't think these are intended to be mutated!
2024-06-20 12:12:20 +01:00
args: ?[]const []const u8 = null,
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
debug_log_scopes: []const []const u8 = &.{},
debug_compile_errors: bool = false,
compiler: introduce incremental debug server In a compiler built with debug extensions, pass `--debug-incremental` to spawn the "incremental debug server". This is a TCP server exposing a REPL which allows querying a bunch of compiler state, some of which is stored only when that flag is passed. Eventually, this will probably move into `std.zig.Server`/`std.zig.Client`, but this is easier to work with right now. The easiest way to interact with the server is `telnet`.
2025-05-24 22:25:17 +01:00
debug_incremental: bool = false,
std.build.CompileStep: eliminate std.log usage
2023-03-03 20:39:40 -07:00
debug_pkg_config: bool = false,
std.Build: make number of collected stack frames configurable
2023-08-11 12:19:56 +02:00
/// Number of stack frames captured when a `StackTrace` is recorded for debug purposes,
/// in particular at `Step` creation.
/// Set to 0 to disable stack collection.
debug_stack_frames_count: u8 = 8,
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
std.Build: revert moving some fields to Graph On second thought, let's keep a bunch of these flags how they already were. Partial revert of the previous commit.
2024-02-01 17:40:36 -07:00
/// Experimental. Use system Darling installation to run cross compiled macOS build artifacts.
enable_darling: bool = false,
/// Use system QEMU installation to run cross compiled foreign architecture build artifacts.
enable_qemu: bool = false,
/// Darwin. Use Rosetta to run x86_64 macOS build artifacts on arm64 macOS.
enable_rosetta: bool = false,
/// Use system Wasmtime installation to run cross compiled wasm/wasi build artifacts.
enable_wasmtime: bool = false,
/// Use system Wine installation to run cross compiled Windows build artifacts.
enable_wine: bool = false,
/// After following the steps in https://github.com/ziglang/zig/wiki/Updating-libc#glibc,
/// this will be the directory $glibc-build-dir/install/glibcs
/// Given the example of the aarch64 target, this is the directory
/// that contains the path `aarch64-linux-gnu/lib/ld-linux-aarch64.so.1`.
std.Build: Rename --glibc-runtimes to --libc-runtimes and enable it for musl.
2025-05-06 01:52:47 +02:00
/// Also works for dynamic musl.
libc_runtimes_dir: ?[]const u8 = null,
std.Build: revert moving some fields to Graph On second thought, let's keep a bunch of these flags how they already were. Partial revert of the previous commit.
2024-02-01 17:40:36 -07:00
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
dep_prefix: []const u8 = "",
std.Build: support exposing and depending on zig modules New API introduced: std.Build.addModule This function exposes a zig module with the given name, which can be used by packages that depend on this one via std.Build.Dependency.module. std.Build.Pkg and related functionality is deleted. Every use case has a straightforward upgrade path using the new Module struct. std.Build.OptionsStep.getPackage is replaced by std.Build.OptionsStep.createModule. std.Build.CompileStep.addPackagePath is replaced by std.Build.CompileStep.addAnonymousModule. This partially addresses #14307 by renaming some of the instances of "package" to "module". Closes #14278
2023-02-03 17:22:31 -07:00
modules: std.StringArrayHashMap(*Module),
Build: add namedWriteFiles to Build
2023-10-22 16:10:01 +02:00
named_writefiles: std.StringArrayHashMap(*Step.WriteFile),
std.Build: allow packages to expose arbitrary LazyPaths by name
2024-09-11 09:06:54 +01:00
named_lazy_paths: std.StringArrayHashMap(LazyPath),
std.Build: add `lazyImport` (`@import` for lazy dependencies)
2024-02-18 19:56:34 +01:00
/// The hash of this instance's package. `""` means that this is the root package.
pkg_hash: []const u8,
package manager: write deps in a flat format, eliminating the FQN concept The new `@depedencies` module contains generated code like the following (where strings like "abc123" represent hashes): ```zig pub const root_deps = [_]struct { []const u8, []const u8 }{ .{ "foo", "abc123" }, }; pub const packages = struct { pub const abc123 = struct { pub const build_root = "/home/mlugg/.cache/zig/blah/abc123"; pub const build_zig = @import("abc123"); pub const deps = [_]struct { []const u8, []const u8 }{ .{ "bar", "abc123" }, .{ "name", "ghi789" }, }; }; }; ``` Each package contains a build root string, the build.zig import, and a mapping from dependency names to package hashes. There is also such a mapping for the root package dependencies. In theory, we could now remove the `dep_prefix` field from `std.Build`, since its main purpose is now handled differently. I believe this is a desirable goal, as it doesn't really make sense to assign a single FQN to any package (because it may appear in many different places in the package hierarchy). This commit does not remove that field, as it's used non-trivially in a few places in the build runner and compiler tests: this will be a future enhancement. Resolves: #16354 Resolves: #17135
2023-09-13 10:46:25 +01:00
/// A mapping from dependency names to package hashes.
available_deps: AvailableDeps,
build system: implement --release[=mode] This allows a `zig build` command to specify intention to create a release build, regardless of what per-project options exist. It also allows the command to specify a "preferred optimization mode", which is chosen if the project itself does not choose one (in other words, the project gets first choice). If neither the build command nor the project specify a preferred release mode, an error occurs.
2024-02-01 20:17:07 -07:00
release_mode: ReleaseMode,
std.Build: add build-id option
2025-01-17 20:53:30 +01:00
build_id: ?std.zig.BuildId = null,
build system: implement --release[=mode] This allows a `zig build` command to specify intention to create a release build, regardless of what per-project options exist. It also allows the command to specify a "preferred optimization mode", which is chosen if the project itself does not choose one (in other words, the project gets first choice). If neither the build command nor the project specify a preferred release mode, an error occurs.
2024-02-01 20:17:07 -07:00
pub const ReleaseMode = enum {
off,
any,
fast,
safe,
small,
};
std.Build: implement --host-target, --host-cpu, --host-dynamic-linker This also makes a long-overdue change of extracting common state from Build into a shared Graph object. Getting the semantics right for these flags turned out to be quite tricky. In the end it works like this: * The override only happens when the target is fully native, with no additional query parameters, such as versions or CPU features added. * The override affects the resolved Target but leaves the original Query unmodified. * The "is native?" detection logic operates on the original, unmodified query. This makes it possible to provide invalid host target information, causing confusing errors to occur. Don't do that. There are some minor breaking changes to std.Build API such as the fact that `b.zig_exe` is now moved to `b.graph.zig_exe`, as well as a handful of other similar flags.
2024-02-01 15:44:44 -07:00
/// Shared state among all Build instances.
/// Settings that are here rather than in Build are not configurable per-package.
pub const Graph = struct {
std.zig.system: upgrade to std.Io.Reader
2025-10-06 18:34:51 -07:00
io: Io,
std.Build: implement --host-target, --host-cpu, --host-dynamic-linker This also makes a long-overdue change of extracting common state from Build into a shared Graph object. Getting the semantics right for these flags turned out to be quite tricky. In the end it works like this: * The override only happens when the target is fully native, with no additional query parameters, such as versions or CPU features added. * The override affects the resolved Target but leaves the original Query unmodified. * The "is native?" detection logic operates on the original, unmodified query. This makes it possible to provide invalid host target information, causing confusing errors to occur. Don't do that. There are some minor breaking changes to std.Build API such as the fact that `b.zig_exe` is now moved to `b.graph.zig_exe`, as well as a handful of other similar flags.
2024-02-01 15:44:44 -07:00
arena: Allocator,
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
system_library_options: std.StringArrayHashMapUnmanaged(SystemLibraryMode) = .empty,
std.Build: implement --host-target, --host-cpu, --host-dynamic-linker This also makes a long-overdue change of extracting common state from Build into a shared Graph object. Getting the semantics right for these flags turned out to be quite tricky. In the end it works like this: * The override only happens when the target is fully native, with no additional query parameters, such as versions or CPU features added. * The override affects the resolved Target but leaves the original Query unmodified. * The "is native?" detection logic operates on the original, unmodified query. This makes it possible to provide invalid host target information, causing confusing errors to occur. Don't do that. There are some minor breaking changes to std.Build API such as the fact that `b.zig_exe` is now moved to `b.graph.zig_exe`, as well as a handful of other similar flags.
2024-02-01 15:44:44 -07:00
system_package_mode: bool = false,
add --debug-rt CLI arg to the compiler + bonus edits The flag makes compiler_rt and libfuzzer be in debug mode. Also: * fuzzer: override debug logs and disable debug logs for frequently called functions * std.Build.Fuzz: fix bug of rerunning the old unit test binary * report errors from rebuilding the unit tests better * link.Elf: additionally add tsan lib and fuzzer lib to the hash
2024-07-24 17:41:44 -07:00
debug_compiler_runtime_libs: bool = false,
std.Build: implement --host-target, --host-cpu, --host-dynamic-linker This also makes a long-overdue change of extracting common state from Build into a shared Graph object. Getting the semantics right for these flags turned out to be quite tricky. In the end it works like this: * The override only happens when the target is fully native, with no additional query parameters, such as versions or CPU features added. * The override affects the resolved Target but leaves the original Query unmodified. * The "is native?" detection logic operates on the original, unmodified query. This makes it possible to provide invalid host target information, causing confusing errors to occur. Don't do that. There are some minor breaking changes to std.Build API such as the fact that `b.zig_exe` is now moved to `b.graph.zig_exe`, as well as a handful of other similar flags.
2024-02-01 15:44:44 -07:00
cache: Cache,
zig_exe: [:0]const u8,
env_map: EnvMap,
global_cache_root: Cache.Directory,
integrate Compile steps with file watching Updates the build runner to unconditionally require a zig lib directory parameter. This parameter is needed in order to correctly understand file system inputs from zig compiler subprocesses, since they will refer to "the zig lib directory", and the build runner needs to place file system watches on directories in there. The build runner's fanotify file watching implementation now accounts for when two or more Cache.Path instances compare unequal but ultimately refer to the same directory in the file system. Breaking change: std.Build no longer has a zig_lib_dir field. Instead, there is the Graph zig_lib_directory field, and individual Compile steps can still have their zig lib directories overridden. I think this is unlikely to break anyone's build in practice. The compiler now sends a "file_system_inputs" message to the build runner which shares the full set of files that were added to the cache system with the build system, so that the build runner can watch properly and redo the Compile step. This is implemented for whole cache mode but not yet for incremental cache mode.
2024-07-11 16:26:04 -07:00
zig_lib_directory: Cache.Directory,
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
needed_lazy_dependencies: std.StringArrayHashMapUnmanaged(void) = .empty,
std.Build: revert --host-target, --host-cpu, --host-dynamic-linker This is a partial revert of 105db13536b4dc2affe130cb8d2eee6c97c89bcd. As we learned from Void Linux packaging, these options are not actually helpful since the distribution package manager may very well want to cross-compile the packages that it is building. So, let's not overcomplicate things. There are already the standard options: -Dtarget, -Dcpu, and -Ddynamic-linker. These options are generally provided when the project generates machine code artifacts, however, there may be a project that does no such thing, in which case it makes sense for these options to be missing. The Zig Build System is a general-purpose build system, after all.
2024-04-17 17:57:03 -07:00
/// Information about the native target. Computed before build() is invoked.
host: ResolvedTarget,
build runner: update watch caption to include subprocesses
2024-07-14 22:27:51 -07:00
incremental: ?bool = null,
add std.testing.random_seed closes #17609
2024-07-22 16:03:11 -07:00
random_seed: u32 = 0,
build: make dependency cache hash map unmanaged Allows Build.Graph to initialize dependency_cache with a default value.
2024-09-27 09:44:44 -06:00
dependency_cache: InitializedDepMap = .empty,
introduce a CLI flag to enable .so scripts; default off The compiler defaults this value to off so that users whose system shared libraries are all ELF files don't have to pay the cost of checking every file to find out if it is a text file instead. When a GNU ld script is encountered, the error message instructs users about the CLI flag that will immediately solve their problem.
2024-10-14 22:57:12 -07:00
allow_so_scripts: ?bool = null,
build system: replace fuzzing UI with build UI, add time report This commit replaces the "fuzzer" UI, previously accessed with the `--fuzz` and `--port` flags, with a more interesting web UI which allows more interactions with the Zig build system. Most notably, it allows accessing the data emitted by a new "time report" system, which allows users to see which parts of Zig programs take the longest to compile. The option to expose the web UI is `--webui`. By default, it will listen on `[::1]` on a random port, but any IPv6 or IPv4 address can be specified with e.g. `--webui=[::1]:8000` or `--webui=127.0.0.1:8000`. The options `--fuzz` and `--time-report` both imply `--webui` if not given. Currently, `--webui` is incompatible with `--watch`; specifying both will cause `zig build` to exit with a fatal error. When the web UI is enabled, the build runner spawns the web server as soon as the configure phase completes. The frontend code consists of one HTML file, one JavaScript file, two CSS files, and a few Zig source files which are built into a WASM blob on-demand -- this is all very similar to the old fuzzer UI. Also inherited from the fuzzer UI is that the build system communicates with web clients over a WebSocket connection. When the build finishes, if `--webui` was passed (i.e. if the web server is running), the build runner does not terminate; it continues running to serve web requests, allowing interactive control of the build system. In the web interface is an overall "status" indicating whether a build is currently running, and also a list of all steps in this build. There are visual indicators (colors and spinners) for in-progress, succeeded, and failed steps. There is a "Rebuild" button which will cause the build system to reset the state of every step (note that this does not affect caching) and evaluate the step graph again. If `--time-report` is passed to `zig build`, a new section of the interface becomes visible, which associates every build step with a "time report". For most steps, this is just a simple "time taken" value. However, for `Compile` steps, the compiler communicates with the build system to provide it with much more interesting information: time taken for various pipeline phases, with a per-declaration and per-file breakdown, sorted by slowest declarations/files first. This feature is still in its early stages: the data can be a little tricky to understand, and there is no way to, for instance, sort by different properties, or filter to certain files. However, it has already given us some interesting statistics, and can be useful for spotting, for instance, particularly complex and slow compile-time logic. Additionally, if a compilation uses LLVM, its time report includes the "LLVM pass timing" information, which was previously accessible with the (now removed) `-ftime-report` compiler flag. To make time reports more useful, ZIR and compilation caches are ignored by the Zig compiler when they are enabled -- in other words, `Compile` steps *always* run, even if their result should be cached. This means that the flag can be used to analyze a project's compile time without having to repeatedly clear cache directory, for instance. However, when using `-fincremental`, updates other than the first will only show you the statistics for what changed on that particular update. Notably, this gives us a fairly nice way to see exactly which declarations were re-analyzed by an incremental update. If `--fuzz` is passed to `zig build`, another section of the web interface becomes visible, this time exposing the fuzzer. This is quite similar to the fuzzer UI this commit replaces, with only a few cosmetic tweaks. The interface is closer than before to supporting multiple fuzz steps at a time (in line with the overall strategy for this build UI, the goal will be for all of the fuzz steps to be accessible in the same interface), but still doesn't actually support it. The fuzzer UI looks quite different under the hood: as a result, various bugs are fixed, although other bugs remain. For instance, viewing the source code of any file other than the root of the main module is completely broken (as on master) due to some bogus file-to-module assignment logic in the fuzzer UI. Implementation notes: * The `lib/build-web/` directory holds the client side of the web UI. * The general server logic is in `std.Build.WebServer`. * Fuzzing-specific logic is in `std.Build.Fuzz`. * `std.Build.abi` is the new home of `std.Build.Fuzz.abi`, since it now relates to the build system web UI in general. * The build runner now has an **actual** general-purpose allocator, because thanks to `--watch` and `--webui`, the process can be arbitrarily long-lived. The gpa is `std.heap.DebugAllocator`, but the arena remains backed by `std.heap.page_allocator` for efficiency. I fixed several crashes caused by conflation of `gpa` and `arena` in the build runner and `std.Build`, but there may still be some I have missed. * The I/O logic in `std.Build.WebServer` is pretty gnarly; there are a *lot* of threads involved. I anticipate this situation improving significantly once the `std.Io` interface (with concurrency support) is introduced.
2025-07-10 09:18:10 +01:00
time_report: bool,
std.Build: implement --host-target, --host-cpu, --host-dynamic-linker This also makes a long-overdue change of extracting common state from Build into a shared Graph object. Getting the semantics right for these flags turned out to be quite tricky. In the end it works like this: * The override only happens when the target is fully native, with no additional query parameters, such as versions or CPU features added. * The override affects the resolved Target but leaves the original Query unmodified. * The "is native?" detection logic operates on the original, unmodified query. This makes it possible to provide invalid host target information, causing confusing errors to occur. Don't do that. There are some minor breaking changes to std.Build API such as the fact that `b.zig_exe` is now moved to `b.graph.zig_exe`, as well as a handful of other similar flags.
2024-02-01 15:44:44 -07:00
};
package manager: write deps in a flat format, eliminating the FQN concept The new `@depedencies` module contains generated code like the following (where strings like "abc123" represent hashes): ```zig pub const root_deps = [_]struct { []const u8, []const u8 }{ .{ "foo", "abc123" }, }; pub const packages = struct { pub const abc123 = struct { pub const build_root = "/home/mlugg/.cache/zig/blah/abc123"; pub const build_zig = @import("abc123"); pub const deps = [_]struct { []const u8, []const u8 }{ .{ "bar", "abc123" }, .{ "name", "ghi789" }, }; }; }; ``` Each package contains a build root string, the build.zig import, and a mapping from dependency names to package hashes. There is also such a mapping for the root package dependencies. In theory, we could now remove the `dep_prefix` field from `std.Build`, since its main purpose is now handled differently. I believe this is a desirable goal, as it doesn't really make sense to assign a single FQN to any package (because it may appear in many different places in the package hierarchy). This commit does not remove that field, as it's used non-trivially in a few places in the build runner and compiler tests: this will be a future enhancement. Resolves: #16354 Resolves: #17135
2023-09-13 10:46:25 +01:00
const AvailableDeps = []const struct { []const u8, []const u8 };
Compare user input for multiple dependency build variants (#16600)
2023-08-10 15:32:55 -07:00
std.Build: implement --host-target, --host-cpu, --host-dynamic-linker This also makes a long-overdue change of extracting common state from Build into a shared Graph object. Getting the semantics right for these flags turned out to be quite tricky. In the end it works like this: * The override only happens when the target is fully native, with no additional query parameters, such as versions or CPU features added. * The override affects the resolved Target but leaves the original Query unmodified. * The "is native?" detection logic operates on the original, unmodified query. This makes it possible to provide invalid host target information, causing confusing errors to occur. Don't do that. There are some minor breaking changes to std.Build API such as the fact that `b.zig_exe` is now moved to `b.graph.zig_exe`, as well as a handful of other similar flags.
2024-02-01 15:44:44 -07:00
const SystemLibraryMode = enum {
build system: introduce system library integration * New --help section * Add b.systemLibraryOption * Rework the build runner CLI logic a bit
2024-01-31 22:02:27 -07:00
/// User asked for the library to be disabled.
/// The build runner has not confirmed whether the setting is recognized yet.
user_disabled,
/// User asked for the library to be enabled.
/// The build runner has not confirmed whether the setting is recognized yet.
user_enabled,
/// The build runner has confirmed that this setting is recognized.
/// System integration with this library has been resolved to off.
declared_disabled,
/// The build runner has confirmed that this setting is recognized.
/// System integration with this library has been resolved to on.
declared_enabled,
};
build: make dependency cache hash map unmanaged Allows Build.Graph to initialize dependency_cache with a default value.
2024-09-27 09:44:44 -06:00
const InitializedDepMap = std.HashMapUnmanaged(InitializedDepKey, *Dependency, InitializedDepContext, std.hash_map.default_max_load_percentage);
Compare user input for multiple dependency build variants (#16600)
2023-08-10 15:32:55 -07:00
const InitializedDepKey = struct {
build_root_string: []const u8,
user_input_options: UserInputOptionsMap,
};
const InitializedDepContext = struct {
allocator: Allocator,
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
pub fn hash(ctx: @This(), k: InitializedDepKey) u64 {
Compare user input for multiple dependency build variants (#16600)
2023-08-10 15:32:55 -07:00
var hasher = std.hash.Wyhash.init(0);
hasher.update(k.build_root_string);
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
hashUserInputOptionsMap(ctx.allocator, k.user_input_options, &hasher);
Compare user input for multiple dependency build variants (#16600)
2023-08-10 15:32:55 -07:00
return hasher.final();
}
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
pub fn eql(_: @This(), lhs: InitializedDepKey, rhs: InitializedDepKey) bool {
Compare user input for multiple dependency build variants (#16600)
2023-08-10 15:32:55 -07:00
if (!std.mem.eql(u8, lhs.build_root_string, rhs.build_root_string))
return false;
if (lhs.user_input_options.count() != rhs.user_input_options.count())
return false;
var it = lhs.user_input_options.iterator();
while (it.next()) |lhs_entry| {
const rhs_value = rhs.user_input_options.get(lhs_entry.key_ptr.*) orelse return false;
if (!userValuesAreSame(lhs_entry.value_ptr.*.value, rhs_value.value))
return false;
}
return true;
}
};
std.Build: support exposing and depending on zig modules New API introduced: std.Build.addModule This function exposes a zig module with the given name, which can be used by packages that depend on this one via std.Build.Dependency.module. std.Build.Pkg and related functionality is deleted. Every use case has a straightforward upgrade path using the new Module struct. std.Build.OptionsStep.getPackage is replaced by std.Build.OptionsStep.createModule. std.Build.CompileStep.addPackagePath is replaced by std.Build.CompileStep.addAnonymousModule. This partially addresses #14307 by renaming some of the instances of "package" to "module". Closes #14278
2023-02-03 17:22:31 -07:00
child_process + Build: rename exec to run + all related code Justification: exec, execv etc are unix concepts and portable version should be called differently. Do no touch non-Zig code. Adjust error names as well, if associated. Closes #5853.
2023-10-19 22:36:11 +02:00
pub const RunError = error{
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
ReadFailure,
ExitCodeFailure,
ProcessTerminated,
ExecNotSupported,
std: restructure child process namespace
2024-05-23 11:25:41 -07:00
} || std.process.Child.SpawnError;
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
pub const PkgConfigError = error{
PkgConfigCrashed,
PkgConfigFailed,
PkgConfigNotInstalled,
PkgConfigInvalidOutput,
};
pub const PkgConfigPkg = struct {
name: []const u8,
desc: []const u8,
};
const UserInputOptionsMap = StringHashMap(UserInputOption);
const AvailableOptionsMap = StringHashMap(AvailableOption);
const AvailableOption = struct {
name: []const u8,
type_id: TypeId,
description: []const u8,
Add support for []enum in Build.option
2024-06-06 06:02:42 +02:00
/// If the `type_id` is `enum` or `enum_list` this provides the list of enum options
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
enum_options: ?[]const []const u8,
};
const UserInputOption = struct {
name: []const u8,
value: UserValue,
used: bool,
};
const UserValue = union(enum) {
flag: void,
scalar: []const u8,
std.ArrayList: make unmanaged the default
2025-07-31 21:54:07 -07:00
list: std.array_list.Managed([]const u8),
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
map: StringHashMap(*const UserValue),
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
lazy_path: LazyPath,
std.ArrayList: make unmanaged the default
2025-07-31 21:54:07 -07:00
lazy_path_list: std.array_list.Managed(LazyPath),
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
};
const TypeId = enum {
bool,
int,
float,
@"enum",
Add support for []enum in Build.option
2024-06-06 06:02:42 +02:00
enum_list,
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
string,
list,
tweaks to --build-id * build.zig: the result of b.option() can be assigned directly in many cases thanks to the return type being an optional * std.Build: make the build system aware of the std.Build.Step.Compile.BuildId type when used as an option. - remove extraneous newlines in error logs * simplify caching logic * simplify hexstring parsing tests and use a doc test * simplify hashing logic. don't use an optional when the `none` tag already provides this meaning. * CLI: fix incorrect linker arg parsing
2023-05-16 20:00:47 -07:00
build_id,
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
lazy_path,
lazy_path_list,
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
};
const TopLevelStep = struct {
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
pub const base_id: Step.Id = .top_level;
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
step: Step,
description: []const u8,
};
pub const DirList = struct {
lib_dir: ?[]const u8 = null,
exe_dir: ?[]const u8 = null,
include_dir: ?[]const u8 = null,
};
pub fn create(
std.Build: implement --host-target, --host-cpu, --host-dynamic-linker This also makes a long-overdue change of extracting common state from Build into a shared Graph object. Getting the semantics right for these flags turned out to be quite tricky. In the end it works like this: * The override only happens when the target is fully native, with no additional query parameters, such as versions or CPU features added. * The override affects the resolved Target but leaves the original Query unmodified. * The "is native?" detection logic operates on the original, unmodified query. This makes it possible to provide invalid host target information, causing confusing errors to occur. Don't do that. There are some minor breaking changes to std.Build API such as the fact that `b.zig_exe` is now moved to `b.graph.zig_exe`, as well as a handful of other similar flags.
2024-02-01 15:44:44 -07:00
graph: *Graph,
std.Build: start using the cache system with RunStep * Use std.Build.Cache.Directory instead of a string for storing the cache roots and build roots. * Set up a std.Build.Cache in build_runner.zig and use it in std.Build.RunStep for avoiding redundant work.
2023-02-09 10:01:01 -07:00
build_root: Cache.Directory,
cache_root: Cache.Directory,
package manager: write deps in a flat format, eliminating the FQN concept The new `@depedencies` module contains generated code like the following (where strings like "abc123" represent hashes): ```zig pub const root_deps = [_]struct { []const u8, []const u8 }{ .{ "foo", "abc123" }, }; pub const packages = struct { pub const abc123 = struct { pub const build_root = "/home/mlugg/.cache/zig/blah/abc123"; pub const build_zig = @import("abc123"); pub const deps = [_]struct { []const u8, []const u8 }{ .{ "bar", "abc123" }, .{ "name", "ghi789" }, }; }; }; ``` Each package contains a build root string, the build.zig import, and a mapping from dependency names to package hashes. There is also such a mapping for the root package dependencies. In theory, we could now remove the `dep_prefix` field from `std.Build`, since its main purpose is now handled differently. I believe this is a desirable goal, as it doesn't really make sense to assign a single FQN to any package (because it may appear in many different places in the package hierarchy). This commit does not remove that field, as it's used non-trivially in a few places in the build runner and compiler tests: this will be a future enhancement. Resolves: #16354 Resolves: #17135
2023-09-13 10:46:25 +01:00
available_deps: AvailableDeps,
std.Build: add more explicit error sets to some functions Signed-off-by: Eric Joldasov <bratishkaerik@landless-city.net>
2024-12-26 00:17:56 +05:00
) error{OutOfMemory}!*Build {
std.Build: implement --host-target, --host-cpu, --host-dynamic-linker This also makes a long-overdue change of extracting common state from Build into a shared Graph object. Getting the semantics right for these flags turned out to be quite tricky. In the end it works like this: * The override only happens when the target is fully native, with no additional query parameters, such as versions or CPU features added. * The override affects the resolved Target but leaves the original Query unmodified. * The "is native?" detection logic operates on the original, unmodified query. This makes it possible to provide invalid host target information, causing confusing errors to occur. Don't do that. There are some minor breaking changes to std.Build API such as the fact that `b.zig_exe` is now moved to `b.graph.zig_exe`, as well as a handful of other similar flags.
2024-02-01 15:44:44 -07:00
const arena = graph.arena;
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
const b = try arena.create(Build);
b.* = .{
std.Build: implement --host-target, --host-cpu, --host-dynamic-linker This also makes a long-overdue change of extracting common state from Build into a shared Graph object. Getting the semantics right for these flags turned out to be quite tricky. In the end it works like this: * The override only happens when the target is fully native, with no additional query parameters, such as versions or CPU features added. * The override affects the resolved Target but leaves the original Query unmodified. * The "is native?" detection logic operates on the original, unmodified query. This makes it possible to provide invalid host target information, causing confusing errors to occur. Don't do that. There are some minor breaking changes to std.Build API such as the fact that `b.zig_exe` is now moved to `b.graph.zig_exe`, as well as a handful of other similar flags.
2024-02-01 15:44:44 -07:00
.graph = graph,
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
.build_root = build_root,
std.Build: start using the cache system with RunStep * Use std.Build.Cache.Directory instead of a string for storing the cache roots and build roots. * Set up a std.Build.Cache in build_runner.zig and use it in std.Build.RunStep for avoiding redundant work.
2023-02-09 10:01:01 -07:00
.cache_root = cache_root,
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
.verbose = false,
.verbose_link = false,
.verbose_cc = false,
.verbose_air = false,
main: add debug option to dump unoptimized llvm ir
2023-03-16 01:32:43 -04:00
.verbose_llvm_ir = null,
.verbose_llvm_bc = null,
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
.verbose_cimport = false,
.verbose_llvm_cpu_features = false,
.invalid_user_input = false,
std.Build: implement --host-target, --host-cpu, --host-dynamic-linker This also makes a long-overdue change of extracting common state from Build into a shared Graph object. Getting the semantics right for these flags turned out to be quite tricky. In the end it works like this: * The override only happens when the target is fully native, with no additional query parameters, such as versions or CPU features added. * The override affects the resolved Target but leaves the original Query unmodified. * The "is native?" detection logic operates on the original, unmodified query. This makes it possible to provide invalid host target information, causing confusing errors to occur. Don't do that. There are some minor breaking changes to std.Build API such as the fact that `b.zig_exe` is now moved to `b.graph.zig_exe`, as well as a handful of other similar flags.
2024-02-01 15:44:44 -07:00
.allocator = arena,
.user_input_options = UserInputOptionsMap.init(arena),
.available_options_map = AvailableOptionsMap.init(arena),
std.ArrayList: make unmanaged the default
2025-07-31 21:54:07 -07:00
.available_options_list = std.array_list.Managed(AvailableOption).init(arena),
extract some logic from std.Build to build_runner.zig
2023-02-13 13:10:20 -07:00
.top_level_steps = .{},
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
.default_step = undefined,
std.ArrayList: make unmanaged the default
2025-07-31 21:54:07 -07:00
.search_prefixes = .empty,
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
.install_prefix = undefined,
.lib_dir = undefined,
.exe_dir = undefined,
.h_dir = undefined,
std.Build: implement --host-target, --host-cpu, --host-dynamic-linker This also makes a long-overdue change of extracting common state from Build into a shared Graph object. Getting the semantics right for these flags turned out to be quite tricky. In the end it works like this: * The override only happens when the target is fully native, with no additional query parameters, such as versions or CPU features added. * The override affects the resolved Target but leaves the original Query unmodified. * The "is native?" detection logic operates on the original, unmodified query. This makes it possible to provide invalid host target information, causing confusing errors to occur. Don't do that. There are some minor breaking changes to std.Build API such as the fact that `b.zig_exe` is now moved to `b.graph.zig_exe`, as well as a handful of other similar flags.
2024-02-01 15:44:44 -07:00
.dest_dir = graph.env_map.get("DESTDIR"),
std.Build: improve debugging of misconfigured steps * Step.init() now takes an options struct * Step.init() now captures a small stack trace and stores it in the Step so that it can be accessed when printing user-friendly debugging information, including the lines of code that created the step in question.
2023-02-14 12:47:45 -07:00
.install_tls = .{
fix build runner
2025-07-02 11:16:20 -07:00
.step = .init(.{
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
.id = TopLevelStep.base_id,
std.Build: improve debugging of misconfigured steps * Step.init() now takes an options struct * Step.init() now captures a small stack trace and stores it in the Step so that it can be accessed when printing user-friendly debugging information, including the lines of code that created the step in question.
2023-02-14 12:47:45 -07:00
.name = "install",
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
.owner = b,
std.Build: improve debugging of misconfigured steps * Step.init() now takes an options struct * Step.init() now captures a small stack trace and stores it in the Step so that it can be accessed when printing user-friendly debugging information, including the lines of code that created the step in question.
2023-02-14 12:47:45 -07:00
}),
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
.description = "Copy build artifacts to prefix path",
},
std.Build: improve debugging of misconfigured steps * Step.init() now takes an options struct * Step.init() now captures a small stack trace and stores it in the Step so that it can be accessed when printing user-friendly debugging information, including the lines of code that created the step in question.
2023-02-14 12:47:45 -07:00
.uninstall_tls = .{
fix build runner
2025-07-02 11:16:20 -07:00
.step = .init(.{
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
.id = TopLevelStep.base_id,
std.Build: improve debugging of misconfigured steps * Step.init() now takes an options struct * Step.init() now captures a small stack trace and stores it in the Step so that it can be accessed when printing user-friendly debugging information, including the lines of code that created the step in question.
2023-02-14 12:47:45 -07:00
.name = "uninstall",
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
.owner = b,
std.Build: improve debugging of misconfigured steps * Step.init() now takes an options struct * Step.init() now captures a small stack trace and stores it in the Step so that it can be accessed when printing user-friendly debugging information, including the lines of code that created the step in question.
2023-02-14 12:47:45 -07:00
.makeFn = makeUninstall,
}),
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
.description = "Remove build artifacts from prefix path",
},
.install_path = undefined,
.args = null,
std.Build: allow packages to expose arbitrary LazyPaths by name
2024-09-11 09:06:54 +01:00
.modules = .init(arena),
.named_writefiles = .init(arena),
.named_lazy_paths = .init(arena),
std.Build: add `lazyImport` (`@import` for lazy dependencies)
2024-02-18 19:56:34 +01:00
.pkg_hash = "",
package manager: write deps in a flat format, eliminating the FQN concept The new `@depedencies` module contains generated code like the following (where strings like "abc123" represent hashes): ```zig pub const root_deps = [_]struct { []const u8, []const u8 }{ .{ "foo", "abc123" }, }; pub const packages = struct { pub const abc123 = struct { pub const build_root = "/home/mlugg/.cache/zig/blah/abc123"; pub const build_zig = @import("abc123"); pub const deps = [_]struct { []const u8, []const u8 }{ .{ "bar", "abc123" }, .{ "name", "ghi789" }, }; }; }; ``` Each package contains a build root string, the build.zig import, and a mapping from dependency names to package hashes. There is also such a mapping for the root package dependencies. In theory, we could now remove the `dep_prefix` field from `std.Build`, since its main purpose is now handled differently. I believe this is a desirable goal, as it doesn't really make sense to assign a single FQN to any package (because it may appear in many different places in the package hierarchy). This commit does not remove that field, as it's used non-trivially in a few places in the build runner and compiler tests: this will be a future enhancement. Resolves: #16354 Resolves: #17135
2023-09-13 10:46:25 +01:00
.available_deps = available_deps,
build system: implement --release[=mode] This allows a `zig build` command to specify intention to create a release build, regardless of what per-project options exist. It also allows the command to specify a "preferred optimization mode", which is chosen if the project itself does not choose one (in other words, the project gets first choice). If neither the build command nor the project specify a preferred release mode, an error occurs.
2024-02-01 20:17:07 -07:00
.release_mode = .off,
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
};
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
try b.top_level_steps.put(arena, b.install_tls.step.name, &b.install_tls);
try b.top_level_steps.put(arena, b.uninstall_tls.step.name, &b.uninstall_tls);
b.default_step = &b.install_tls.step;
return b;
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
fn createChild(
parent: *Build,
dep_name: []const u8,
std.Build: start using the cache system with RunStep * Use std.Build.Cache.Directory instead of a string for storing the cache roots and build roots. * Set up a std.Build.Cache in build_runner.zig and use it in std.Build.RunStep for avoiding redundant work.
2023-02-09 10:01:01 -07:00
build_root: Cache.Directory,
std.Build: add `lazyImport` (`@import` for lazy dependencies)
2024-02-18 19:56:34 +01:00
pkg_hash: []const u8,
package manager: write deps in a flat format, eliminating the FQN concept The new `@depedencies` module contains generated code like the following (where strings like "abc123" represent hashes): ```zig pub const root_deps = [_]struct { []const u8, []const u8 }{ .{ "foo", "abc123" }, }; pub const packages = struct { pub const abc123 = struct { pub const build_root = "/home/mlugg/.cache/zig/blah/abc123"; pub const build_zig = @import("abc123"); pub const deps = [_]struct { []const u8, []const u8 }{ .{ "bar", "abc123" }, .{ "name", "ghi789" }, }; }; }; ``` Each package contains a build root string, the build.zig import, and a mapping from dependency names to package hashes. There is also such a mapping for the root package dependencies. In theory, we could now remove the `dep_prefix` field from `std.Build`, since its main purpose is now handled differently. I believe this is a desirable goal, as it doesn't really make sense to assign a single FQN to any package (because it may appear in many different places in the package hierarchy). This commit does not remove that field, as it's used non-trivially in a few places in the build runner and compiler tests: this will be a future enhancement. Resolves: #16354 Resolves: #17135
2023-09-13 10:46:25 +01:00
pkg_deps: AvailableDeps,
Compare user input for multiple dependency build variants (#16600)
2023-08-10 15:32:55 -07:00
user_input_options: UserInputOptionsMap,
std.Build: add more explicit error sets to some functions Signed-off-by: Eric Joldasov <bratishkaerik@landless-city.net>
2024-12-26 00:17:56 +05:00
) error{OutOfMemory}!*Build {
std.Build: add `lazyImport` (`@import` for lazy dependencies)
2024-02-18 19:56:34 +01:00
const child = try createChildOnly(parent, dep_name, build_root, pkg_hash, pkg_deps, user_input_options);
Compare user input for multiple dependency build variants (#16600)
2023-08-10 15:32:55 -07:00
try determineAndApplyInstallPrefix(child);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
return child;
}
build system: introduce system library integration * New --help section * Add b.systemLibraryOption * Rework the build runner CLI logic a bit
2024-01-31 22:02:27 -07:00
fn createChildOnly(
parent: *Build,
dep_name: []const u8,
build_root: Cache.Directory,
std.Build: add `lazyImport` (`@import` for lazy dependencies)
2024-02-18 19:56:34 +01:00
pkg_hash: []const u8,
build system: introduce system library integration * New --help section * Add b.systemLibraryOption * Rework the build runner CLI logic a bit
2024-01-31 22:02:27 -07:00
pkg_deps: AvailableDeps,
user_input_options: UserInputOptionsMap,
std.Build: add more explicit error sets to some functions Signed-off-by: Eric Joldasov <bratishkaerik@landless-city.net>
2024-12-26 00:17:56 +05:00
) error{OutOfMemory}!*Build {
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
const allocator = parent.allocator;
const child = try allocator.create(Build);
child.* = .{
std.Build: implement --host-target, --host-cpu, --host-dynamic-linker This also makes a long-overdue change of extracting common state from Build into a shared Graph object. Getting the semantics right for these flags turned out to be quite tricky. In the end it works like this: * The override only happens when the target is fully native, with no additional query parameters, such as versions or CPU features added. * The override affects the resolved Target but leaves the original Query unmodified. * The "is native?" detection logic operates on the original, unmodified query. This makes it possible to provide invalid host target information, causing confusing errors to occur. Don't do that. There are some minor breaking changes to std.Build API such as the fact that `b.zig_exe` is now moved to `b.graph.zig_exe`, as well as a handful of other similar flags.
2024-02-01 15:44:44 -07:00
.graph = parent.graph,
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
.allocator = allocator,
.install_tls = .{
fix build runner
2025-07-02 11:16:20 -07:00
.step = .init(.{
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
.id = TopLevelStep.base_id,
std.Build: improve debugging of misconfigured steps * Step.init() now takes an options struct * Step.init() now captures a small stack trace and stores it in the Step so that it can be accessed when printing user-friendly debugging information, including the lines of code that created the step in question.
2023-02-14 12:47:45 -07:00
.name = "install",
zig build: many enhancements related to parallel building Rework std.Build.Step to have an `owner: *Build` field. This simplified the implementation of installation steps, as well as provided some much-needed common API for the new parallelized build system. --verbose is now defined very concretely: it prints to stderr just before spawning a child process. Child process execution is updated to conform to the new parallel-friendly make() function semantics. DRY up the failWithCacheError handling code. It now integrates properly with the step graph instead of incorrectly dumping to stderr and calling process exit. In the main CLI, fix `zig fmt` crash when there are no errors and stdin is used. Deleted steps: * EmulatableRunStep - this entire thing can be removed in favor of a flag added to std.Build.RunStep called `skip_foreign_checks`. * LogStep - this doesn't really fit with a multi-threaded build runner and is effectively superseded by the new build summary output. build runner: * add -fsummary and -fno-summary to override the default behavior, which is to print a summary if any of the build steps fail. * print the dep prefix when emitting error messages for steps. std.Build.FmtStep: * This step now supports exclude paths as well as a check flag. * The check flag decides between two modes, modify mode, and check mode. These can be used to update source files in place, or to fail the build, respectively. Zig's own build.zig: * The `test-fmt` step will do all the `zig fmt` checking that we expect to be done. Since the `test` step depends on this one, we can simply remove the explicit call to `zig fmt` in the CI. * The new `fmt` step will actually perform `zig fmt` and update source files in place. std.Build.RunStep: * expose max_stdio_size is a field (previously an unchangeable hard-coded value). * rework the API. Instead of configuring each stream independently, there is a `stdio` field where you can choose between `infer_from_args`, `inherit`, or `check`. These determine whether the RunStep is considered to have side-effects or not. The previous field, `condition` is gone. * when stdio mode is set to `check` there is a slice of any number of checks to make, which include things like exit code, stderr matching, or stdout matching. * remove the ill-defined `print` field. * when adding an output arg, it takes the opportunity to give itself a better name. * The flag `skip_foreign_checks` is added. If this is true, a RunStep which is configured to check the output of the executed binary will not fail the build if the binary cannot be executed due to being for a foreign binary to the host system which is running the build graph. Command-line arguments such as -fqemu and -fwasmtime may affect whether a binary is detected as foreign, as well as system configuration such as Rosetta (macOS) and binfmt_misc (Linux). - This makes EmulatableRunStep no longer needed. * Fix the child process handling to properly integrate with the new bulid API and to avoid deadlocks in stdout/stderr streams by polling if necessary. std.Build.RemoveDirStep now uses the open build_root directory handle instead of an absolute path.
2023-03-01 22:56:37 -07:00
.owner = child,
std.Build: improve debugging of misconfigured steps * Step.init() now takes an options struct * Step.init() now captures a small stack trace and stores it in the Step so that it can be accessed when printing user-friendly debugging information, including the lines of code that created the step in question.
2023-02-14 12:47:45 -07:00
}),
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
.description = "Copy build artifacts to prefix path",
},
.uninstall_tls = .{
fix build runner
2025-07-02 11:16:20 -07:00
.step = .init(.{
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
.id = TopLevelStep.base_id,
std.Build: improve debugging of misconfigured steps * Step.init() now takes an options struct * Step.init() now captures a small stack trace and stores it in the Step so that it can be accessed when printing user-friendly debugging information, including the lines of code that created the step in question.
2023-02-14 12:47:45 -07:00
.name = "uninstall",
zig build: many enhancements related to parallel building Rework std.Build.Step to have an `owner: *Build` field. This simplified the implementation of installation steps, as well as provided some much-needed common API for the new parallelized build system. --verbose is now defined very concretely: it prints to stderr just before spawning a child process. Child process execution is updated to conform to the new parallel-friendly make() function semantics. DRY up the failWithCacheError handling code. It now integrates properly with the step graph instead of incorrectly dumping to stderr and calling process exit. In the main CLI, fix `zig fmt` crash when there are no errors and stdin is used. Deleted steps: * EmulatableRunStep - this entire thing can be removed in favor of a flag added to std.Build.RunStep called `skip_foreign_checks`. * LogStep - this doesn't really fit with a multi-threaded build runner and is effectively superseded by the new build summary output. build runner: * add -fsummary and -fno-summary to override the default behavior, which is to print a summary if any of the build steps fail. * print the dep prefix when emitting error messages for steps. std.Build.FmtStep: * This step now supports exclude paths as well as a check flag. * The check flag decides between two modes, modify mode, and check mode. These can be used to update source files in place, or to fail the build, respectively. Zig's own build.zig: * The `test-fmt` step will do all the `zig fmt` checking that we expect to be done. Since the `test` step depends on this one, we can simply remove the explicit call to `zig fmt` in the CI. * The new `fmt` step will actually perform `zig fmt` and update source files in place. std.Build.RunStep: * expose max_stdio_size is a field (previously an unchangeable hard-coded value). * rework the API. Instead of configuring each stream independently, there is a `stdio` field where you can choose between `infer_from_args`, `inherit`, or `check`. These determine whether the RunStep is considered to have side-effects or not. The previous field, `condition` is gone. * when stdio mode is set to `check` there is a slice of any number of checks to make, which include things like exit code, stderr matching, or stdout matching. * remove the ill-defined `print` field. * when adding an output arg, it takes the opportunity to give itself a better name. * The flag `skip_foreign_checks` is added. If this is true, a RunStep which is configured to check the output of the executed binary will not fail the build if the binary cannot be executed due to being for a foreign binary to the host system which is running the build graph. Command-line arguments such as -fqemu and -fwasmtime may affect whether a binary is detected as foreign, as well as system configuration such as Rosetta (macOS) and binfmt_misc (Linux). - This makes EmulatableRunStep no longer needed. * Fix the child process handling to properly integrate with the new bulid API and to avoid deadlocks in stdout/stderr streams by polling if necessary. std.Build.RemoveDirStep now uses the open build_root directory handle instead of an absolute path.
2023-03-01 22:56:37 -07:00
.owner = child,
std.Build: improve debugging of misconfigured steps * Step.init() now takes an options struct * Step.init() now captures a small stack trace and stores it in the Step so that it can be accessed when printing user-friendly debugging information, including the lines of code that created the step in question.
2023-02-14 12:47:45 -07:00
.makeFn = makeUninstall,
}),
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
.description = "Remove build artifacts from prefix path",
},
Compare user input for multiple dependency build variants (#16600)
2023-08-10 15:32:55 -07:00
.user_input_options = user_input_options,
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
.available_options_map = AvailableOptionsMap.init(allocator),
std.ArrayList: make unmanaged the default
2025-07-31 21:54:07 -07:00
.available_options_list = std.array_list.Managed(AvailableOption).init(allocator),
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
.verbose = parent.verbose,
.verbose_link = parent.verbose_link,
.verbose_cc = parent.verbose_cc,
.verbose_air = parent.verbose_air,
.verbose_llvm_ir = parent.verbose_llvm_ir,
main: add debug option to dump unoptimized llvm ir
2023-03-16 01:32:43 -04:00
.verbose_llvm_bc = parent.verbose_llvm_bc,
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
.verbose_cimport = parent.verbose_cimport,
.verbose_llvm_cpu_features = parent.verbose_llvm_cpu_features,
.reference_trace = parent.reference_trace,
.invalid_user_input = false,
.default_step = undefined,
extract some logic from std.Build to build_runner.zig
2023-02-13 13:10:20 -07:00
.top_level_steps = .{},
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
.install_prefix = undefined,
.dest_dir = parent.dest_dir,
.lib_dir = parent.lib_dir,
.exe_dir = parent.exe_dir,
.h_dir = parent.h_dir,
.install_path = parent.install_path,
.sysroot = parent.sysroot,
std.Build: make dependencies inherit `--search-prefix`
2023-10-17 22:25:40 -07:00
.search_prefixes = parent.search_prefixes,
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
.libc_file = parent.libc_file,
.build_root = build_root,
.cache_root = parent.cache_root,
.debug_log_scopes = parent.debug_log_scopes,
.debug_compile_errors = parent.debug_compile_errors,
compiler: introduce incremental debug server In a compiler built with debug extensions, pass `--debug-incremental` to spawn the "incremental debug server". This is a TCP server exposing a REPL which allows querying a bunch of compiler state, some of which is stored only when that flag is passed. Eventually, this will probably move into `std.zig.Server`/`std.zig.Client`, but this is easier to work with right now. The easiest way to interact with the server is `telnet`.
2025-05-24 22:25:17 +01:00
.debug_incremental = parent.debug_incremental,
std.build.CompileStep: eliminate std.log usage
2023-03-03 20:39:40 -07:00
.debug_pkg_config = parent.debug_pkg_config,
std.Build: revert moving some fields to Graph On second thought, let's keep a bunch of these flags how they already were. Partial revert of the previous commit.
2024-02-01 17:40:36 -07:00
.enable_darling = parent.enable_darling,
.enable_qemu = parent.enable_qemu,
.enable_rosetta = parent.enable_rosetta,
.enable_wasmtime = parent.enable_wasmtime,
.enable_wine = parent.enable_wine,
std.Build: Rename --glibc-runtimes to --libc-runtimes and enable it for musl.
2025-05-06 01:52:47 +02:00
.libc_runtimes_dir = parent.libc_runtimes_dir,
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
.dep_prefix = parent.fmt("{s}{s}.", .{ parent.dep_prefix, dep_name }),
std.Build: allow packages to expose arbitrary LazyPaths by name
2024-09-11 09:06:54 +01:00
.modules = .init(allocator),
.named_writefiles = .init(allocator),
.named_lazy_paths = .init(allocator),
std.Build: add `lazyImport` (`@import` for lazy dependencies)
2024-02-18 19:56:34 +01:00
.pkg_hash = pkg_hash,
package manager: write deps in a flat format, eliminating the FQN concept The new `@depedencies` module contains generated code like the following (where strings like "abc123" represent hashes): ```zig pub const root_deps = [_]struct { []const u8, []const u8 }{ .{ "foo", "abc123" }, }; pub const packages = struct { pub const abc123 = struct { pub const build_root = "/home/mlugg/.cache/zig/blah/abc123"; pub const build_zig = @import("abc123"); pub const deps = [_]struct { []const u8, []const u8 }{ .{ "bar", "abc123" }, .{ "name", "ghi789" }, }; }; }; ``` Each package contains a build root string, the build.zig import, and a mapping from dependency names to package hashes. There is also such a mapping for the root package dependencies. In theory, we could now remove the `dep_prefix` field from `std.Build`, since its main purpose is now handled differently. I believe this is a desirable goal, as it doesn't really make sense to assign a single FQN to any package (because it may appear in many different places in the package hierarchy). This commit does not remove that field, as it's used non-trivially in a few places in the build runner and compiler tests: this will be a future enhancement. Resolves: #16354 Resolves: #17135
2023-09-13 10:46:25 +01:00
.available_deps = pkg_deps,
build system: implement --release[=mode] This allows a `zig build` command to specify intention to create a release build, regardless of what per-project options exist. It also allows the command to specify a "preferred optimization mode", which is chosen if the project itself does not choose one (in other words, the project gets first choice). If neither the build command nor the project specify a preferred release mode, an error occurs.
2024-02-01 20:17:07 -07:00
.release_mode = parent.release_mode,
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
};
extract some logic from std.Build to build_runner.zig
2023-02-13 13:10:20 -07:00
try child.top_level_steps.put(allocator, child.install_tls.step.name, &child.install_tls);
try child.top_level_steps.put(allocator, child.uninstall_tls.step.name, &child.uninstall_tls);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
child.default_step = &child.install_tls.step;
return child;
}
Support passing null to `b.dependency()` Both null literals and optionals are supported.
2025-03-23 22:45:38 +01:00
fn userInputOptionsFromArgs(arena: Allocator, args: anytype) UserInputOptionsMap {
var map = UserInputOptionsMap.init(arena);
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
inline for (@typeInfo(@TypeOf(args)).@"struct".fields) |field| {
all: replace all `@Type` usages Co-authored-by: Matthew Lugg <mlugg@mlugg.co.uk>
2025-04-30 18:42:23 +03:30
if (field.type == @TypeOf(null)) continue;
Support passing null to `b.dependency()` Both null literals and optionals are supported.
2025-03-23 22:45:38 +01:00
addUserInputOptionFromArg(arena, &map, field, field.type, @field(args, field.name));
}
return map;
}
fn addUserInputOptionFromArg(
arena: Allocator,
map: *UserInputOptionsMap,
field: std.builtin.Type.StructField,
comptime T: type,
/// If null, the value won't be added, but `T` will still be type-checked.
maybe_value: ?T,
) void {
switch (T) {
Target.Query => return if (maybe_value) |v| {
map.put(field.name, .{
.name = field.name,
.value = .{ .scalar = v.zigTriple(arena) catch @panic("OOM") },
.used = false,
}) catch @panic("OOM");
map.put("cpu", .{
.name = "cpu",
.value = .{ .scalar = v.serializeCpuAlloc(arena) catch @panic("OOM") },
.used = false,
}) catch @panic("OOM");
},
ResolvedTarget => return if (maybe_value) |v| {
map.put(field.name, .{
.name = field.name,
.value = .{ .scalar = v.query.zigTriple(arena) catch @panic("OOM") },
.used = false,
}) catch @panic("OOM");
map.put("cpu", .{
.name = "cpu",
.value = .{ .scalar = v.query.serializeCpuAlloc(arena) catch @panic("OOM") },
.used = false,
}) catch @panic("OOM");
},
Support passing `std.zig.BuildId` to `b.dependency()`
2025-03-24 14:25:47 +01:00
std.zig.BuildId => return if (maybe_value) |v| {
map.put(field.name, .{
.name = field.name,
.value = .{ .scalar = std.fmt.allocPrint(arena, "{f}", .{v}) catch @panic("OOM") },
.used = false,
}) catch @panic("OOM");
},
Support passing null to `b.dependency()` Both null literals and optionals are supported.
2025-03-23 22:45:38 +01:00
LazyPath => return if (maybe_value) |v| {
map.put(field.name, .{
.name = field.name,
.value = .{ .lazy_path = v.dupeInner(arena) },
.used = false,
}) catch @panic("OOM");
},
[]const LazyPath => return if (maybe_value) |v| {
std.ArrayList: make unmanaged the default
2025-07-31 21:54:07 -07:00
var list = std.array_list.Managed(LazyPath).initCapacity(arena, v.len) catch @panic("OOM");
Support passing null to `b.dependency()` Both null literals and optionals are supported.
2025-03-23 22:45:38 +01:00
for (v) |lp| list.appendAssumeCapacity(lp.dupeInner(arena));
map.put(field.name, .{
.name = field.name,
.value = .{ .lazy_path_list = list },
.used = false,
}) catch @panic("OOM");
},
[]const u8 => return if (maybe_value) |v| {
map.put(field.name, .{
.name = field.name,
Dupe string options
2025-03-24 13:25:56 +01:00
.value = .{ .scalar = arena.dupe(u8, v) catch @panic("OOM") },
Support passing null to `b.dependency()` Both null literals and optionals are supported.
2025-03-23 22:45:38 +01:00
.used = false,
}) catch @panic("OOM");
},
[]const []const u8 => return if (maybe_value) |v| {
std.ArrayList: make unmanaged the default
2025-07-31 21:54:07 -07:00
var list = std.array_list.Managed([]const u8).initCapacity(arena, v.len) catch @panic("OOM");
Dupe string options
2025-03-24 13:25:56 +01:00
for (v) |s| list.appendAssumeCapacity(arena.dupe(u8, s) catch @panic("OOM"));
Support passing null to `b.dependency()` Both null literals and optionals are supported.
2025-03-23 22:45:38 +01:00
map.put(field.name, .{
.name = field.name,
.value = .{ .list = list },
.used = false,
}) catch @panic("OOM");
},
else => switch (@typeInfo(T)) {
.bool => return if (maybe_value) |v| {
map.put(field.name, .{
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
.name = field.name,
Support passing null to `b.dependency()` Both null literals and optionals are supported.
2025-03-23 22:45:38 +01:00
.value = .{ .scalar = if (v) "true" else "false" },
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
.used = false,
}) catch @panic("OOM");
},
Support passing null to `b.dependency()` Both null literals and optionals are supported.
2025-03-23 22:45:38 +01:00
.@"enum", .enum_literal => return if (maybe_value) |v| {
map.put(field.name, .{
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
.name = field.name,
Support passing null to `b.dependency()` Both null literals and optionals are supported.
2025-03-23 22:45:38 +01:00
.value = .{ .scalar = @tagName(v) },
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
.used = false,
}) catch @panic("OOM");
},
Support passing null to `b.dependency()` Both null literals and optionals are supported.
2025-03-23 22:45:38 +01:00
.comptime_int, .int => return if (maybe_value) |v| {
map.put(field.name, .{
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
.name = field.name,
Support passing null to `b.dependency()` Both null literals and optionals are supported.
2025-03-23 22:45:38 +01:00
.value = .{ .scalar = std.fmt.allocPrint(arena, "{d}", .{v}) catch @panic("OOM") },
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
.used = false,
Compare user input for multiple dependency build variants (#16600)
2023-08-10 15:32:55 -07:00
}) catch @panic("OOM");
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
},
Support passing null to `b.dependency()` Both null literals and optionals are supported.
2025-03-23 22:45:38 +01:00
.comptime_float, .float => return if (maybe_value) |v| {
map.put(field.name, .{
add support for lists when parsing user args
2023-12-31 19:42:48 -08:00
.name = field.name,
Serialize float options using the hexadecimal format This ensures no information is lost when the value is round-tripped.
2025-03-24 13:22:08 +01:00
.value = .{ .scalar = std.fmt.allocPrint(arena, "{x}", .{v}) catch @panic("OOM") },
add support for lists when parsing user args
2023-12-31 19:42:48 -08:00
.used = false,
}) catch @panic("OOM");
},
Coerce slice-like arguments passed to `b.dependency()` You can now pass string literals as options.
2025-03-24 00:01:28 +01:00
.pointer => |ptr_info| switch (ptr_info.size) {
.one => switch (@typeInfo(ptr_info.child)) {
.array => |array_info| {
addUserInputOptionFromArg(
arena,
map,
field,
all: replace all `@Type` usages Co-authored-by: Matthew Lugg <mlugg@mlugg.co.uk>
2025-04-30 18:42:23 +03:30
@Pointer(.slice, .{ .@"const" = true }, array_info.child, null),
Coerce slice-like arguments passed to `b.dependency()` You can now pass string literals as options.
2025-03-24 00:01:28 +01:00
maybe_value orelse null,
);
return;
},
else => {},
},
Support passing enum slices to `b.dependency()`
2025-03-24 00:14:25 +01:00
.slice => switch (@typeInfo(ptr_info.child)) {
.@"enum" => return if (maybe_value) |v| {
std.ArrayList: make unmanaged the default
2025-07-31 21:54:07 -07:00
var list = std.array_list.Managed([]const u8).initCapacity(arena, v.len) catch @panic("OOM");
Support passing enum slices to `b.dependency()`
2025-03-24 00:14:25 +01:00
for (v) |tag| list.appendAssumeCapacity(@tagName(tag));
map.put(field.name, .{
.name = field.name,
.value = .{ .list = list },
.used = false,
}) catch @panic("OOM");
},
else => {
addUserInputOptionFromArg(
arena,
map,
field,
all: replace all `@Type` usages Co-authored-by: Matthew Lugg <mlugg@mlugg.co.uk>
2025-04-30 18:42:23 +03:30
@Pointer(ptr_info.size, .{ .@"const" = true }, ptr_info.child, null),
Support passing enum slices to `b.dependency()`
2025-03-24 00:14:25 +01:00
maybe_value orelse null,
);
return;
},
Coerce slice-like arguments passed to `b.dependency()` You can now pass string literals as options.
2025-03-24 00:01:28 +01:00
},
else => {},
},
Support passing null to `b.dependency()` Both null literals and optionals are supported.
2025-03-23 22:45:38 +01:00
.null => unreachable,
.optional => |info| switch (@typeInfo(info.child)) {
.optional => {},
else => {
addUserInputOptionFromArg(
arena,
map,
field,
info.child,
maybe_value orelse null,
);
return;
std.Build: add support for passing comptime_int, float and comptime_float options
2024-07-04 10:39:17 +02:00
},
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
},
Support passing null to `b.dependency()` Both null literals and optionals are supported.
2025-03-23 22:45:38 +01:00
else => {},
},
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
Support passing null to `b.dependency()` Both null literals and optionals are supported.
2025-03-23 22:45:38 +01:00
@compileError("option '" ++ field.name ++ "' has unsupported type: " ++ @typeName(field.type));
Compare user input for multiple dependency build variants (#16600)
2023-08-10 15:32:55 -07:00
}
const OrderedUserValue = union(enum) {
flag: void,
scalar: []const u8,
std.ArrayList: make unmanaged the default
2025-07-31 21:54:07 -07:00
list: std.array_list.Managed([]const u8),
map: std.array_list.Managed(Pair),
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
lazy_path: LazyPath,
std.ArrayList: make unmanaged the default
2025-07-31 21:54:07 -07:00
lazy_path_list: std.array_list.Managed(LazyPath),
Compare user input for multiple dependency build variants (#16600)
2023-08-10 15:32:55 -07:00
const Pair = struct {
name: []const u8,
value: OrderedUserValue,
fn lessThan(_: void, lhs: Pair, rhs: Pair) bool {
return std.ascii.lessThanIgnoreCase(lhs.name, rhs.name);
}
};
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
fn hash(val: OrderedUserValue, hasher: *std.hash.Wyhash) void {
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
hasher.update(&std.mem.toBytes(std.meta.activeTag(val)));
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
switch (val) {
Compare user input for multiple dependency build variants (#16600)
2023-08-10 15:32:55 -07:00
.flag => {},
.scalar => |scalar| hasher.update(scalar),
// lists are already ordered
.list => |list| for (list.items) |list_entry|
hasher.update(list_entry),
.map => |map| for (map.items) |map_entry| {
hasher.update(map_entry.name);
map_entry.value.hash(hasher);
},
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
.lazy_path => |lp| hashLazyPath(lp, hasher),
.lazy_path_list => |lp_list| for (lp_list.items) |lp| {
hashLazyPath(lp, hasher);
},
}
}
fn hashLazyPath(lp: LazyPath, hasher: *std.hash.Wyhash) void {
switch (lp) {
.src_path => |sp| {
hasher.update(sp.owner.pkg_hash);
hasher.update(sp.sub_path);
},
.generated => |gen| {
hasher.update(gen.file.step.owner.pkg_hash);
hasher.update(std.mem.asBytes(&gen.up));
hasher.update(gen.sub_path);
},
.cwd_relative => |rel_path| {
hasher.update(rel_path);
},
.dependency => |dep| {
hasher.update(dep.dependency.builder.pkg_hash);
hasher.update(dep.sub_path);
},
Compare user input for multiple dependency build variants (#16600)
2023-08-10 15:32:55 -07:00
}
}
std.ArrayList: make unmanaged the default
2025-07-31 21:54:07 -07:00
fn mapFromUnordered(allocator: Allocator, unordered: std.StringHashMap(*const UserValue)) std.array_list.Managed(Pair) {
var ordered = std.array_list.Managed(Pair).init(allocator);
Compare user input for multiple dependency build variants (#16600)
2023-08-10 15:32:55 -07:00
var it = unordered.iterator();
while (it.next()) |entry| {
ordered.append(.{
.name = entry.key_ptr.*,
.value = OrderedUserValue.fromUnordered(allocator, entry.value_ptr.*.*),
}) catch @panic("OOM");
}
std.mem.sortUnstable(Pair, ordered.items, {}, Pair.lessThan);
return ordered;
}
fn fromUnordered(allocator: Allocator, unordered: UserValue) OrderedUserValue {
return switch (unordered) {
.flag => .{ .flag = {} },
.scalar => |scalar| .{ .scalar = scalar },
.list => |list| .{ .list = list },
.map => |map| .{ .map = OrderedUserValue.mapFromUnordered(allocator, map) },
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
.lazy_path => |lp| .{ .lazy_path = lp },
.lazy_path_list => |list| .{ .lazy_path_list = list },
Compare user input for multiple dependency build variants (#16600)
2023-08-10 15:32:55 -07:00
};
}
};
const OrderedUserInputOption = struct {
name: []const u8,
value: OrderedUserValue,
used: bool,
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
fn hash(opt: OrderedUserInputOption, hasher: *std.hash.Wyhash) void {
hasher.update(opt.name);
opt.value.hash(hasher);
Compare user input for multiple dependency build variants (#16600)
2023-08-10 15:32:55 -07:00
}
fn fromUnordered(allocator: Allocator, user_input_option: UserInputOption) OrderedUserInputOption {
return OrderedUserInputOption{
.name = user_input_option.name,
.used = user_input_option.used,
.value = OrderedUserValue.fromUnordered(allocator, user_input_option.value),
};
}
fn lessThan(_: void, lhs: OrderedUserInputOption, rhs: OrderedUserInputOption) bool {
return std.ascii.lessThanIgnoreCase(lhs.name, rhs.name);
}
};
// The hash should be consistent with the same values given a different order.
// This function takes a user input map, orders it, then hashes the contents.
fn hashUserInputOptionsMap(allocator: Allocator, user_input_options: UserInputOptionsMap, hasher: *std.hash.Wyhash) void {
std.ArrayList: make unmanaged the default
2025-07-31 21:54:07 -07:00
var ordered = std.array_list.Managed(OrderedUserInputOption).init(allocator);
Compare user input for multiple dependency build variants (#16600)
2023-08-10 15:32:55 -07:00
var it = user_input_options.iterator();
while (it.next()) |entry|
ordered.append(OrderedUserInputOption.fromUnordered(allocator, entry.value_ptr.*)) catch @panic("OOM");
std.mem.sortUnstable(OrderedUserInputOption, ordered.items, {}, OrderedUserInputOption.lessThan);
// juice it
for (ordered.items) |user_option|
user_option.hash(hasher);
}
std.Build: add more explicit error sets to some functions Signed-off-by: Eric Joldasov <bratishkaerik@landless-city.net>
2024-12-26 00:17:56 +05:00
fn determineAndApplyInstallPrefix(b: *Build) error{OutOfMemory}!void {
std.Build: use Cache hash helper for package prefix dirs Previously this code used SipHash(1, 3) directly; now that we have the cache system available in the build system, borrow the same implementation as is being used everywhere else.
2023-03-09 21:16:53 -07:00
// Create an installation directory local to this package. This will be used when
// dependant packages require a standard prefix, such as include directories for C headers.
std.Build: implement --host-target, --host-cpu, --host-dynamic-linker This also makes a long-overdue change of extracting common state from Build into a shared Graph object. Getting the semantics right for these flags turned out to be quite tricky. In the end it works like this: * The override only happens when the target is fully native, with no additional query parameters, such as versions or CPU features added. * The override affects the resolved Target but leaves the original Query unmodified. * The "is native?" detection logic operates on the original, unmodified query. This makes it possible to provide invalid host target information, causing confusing errors to occur. Don't do that. There are some minor breaking changes to std.Build API such as the fact that `b.zig_exe` is now moved to `b.graph.zig_exe`, as well as a handful of other similar flags.
2024-02-01 15:44:44 -07:00
var hash = b.graph.cache.hash;
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
// Random bytes to make unique. Refresh this with new random bytes when
// implementation is modified in a non-backwards-compatible way.
std.Build: use Cache hash helper for package prefix dirs Previously this code used SipHash(1, 3) directly; now that we have the cache system available in the build system, borrow the same implementation as is being used everywhere else.
2023-03-09 21:16:53 -07:00
hash.add(@as(u32, 0xd8cb0055));
hash.addBytes(b.dep_prefix);
Compare user input for multiple dependency build variants (#16600)
2023-08-10 15:32:55 -07:00
var wyhash = std.hash.Wyhash.init(0);
hashUserInputOptionsMap(b.allocator, b.user_input_options, &wyhash);
hash.add(wyhash.final());
std.Build: use Cache hash helper for package prefix dirs Previously this code used SipHash(1, 3) directly; now that we have the cache system available in the build system, borrow the same implementation as is being used everywhere else.
2023-03-09 21:16:53 -07:00
const digest = hash.final();
const install_prefix = try b.cache_root.join(b.allocator, &.{ "i", &digest });
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
b.resolveInstallPrefix(install_prefix, .{});
}
/// This function is intended to be called by lib/build_runner.zig, not a build.zig file.
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
pub fn resolveInstallPrefix(b: *Build, install_prefix: ?[]const u8, dir_list: DirList) void {
if (b.dest_dir) |dest_dir| {
b.install_prefix = install_prefix orelse "/usr";
b.install_path = b.pathJoin(&.{ dest_dir, b.install_prefix });
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
} else {
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
b.install_prefix = install_prefix orelse
(b.build_root.join(b.allocator, &.{"zig-out"}) catch @panic("unhandled error"));
b.install_path = b.install_prefix;
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
var lib_list = [_][]const u8{ b.install_path, "lib" };
var exe_list = [_][]const u8{ b.install_path, "bin" };
var h_list = [_][]const u8{ b.install_path, "include" };
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
if (dir_list.lib_dir) |dir| {
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
if (fs.path.isAbsolute(dir)) lib_list[0] = b.dest_dir orelse "";
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
lib_list[1] = dir;
}
if (dir_list.exe_dir) |dir| {
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
if (fs.path.isAbsolute(dir)) exe_list[0] = b.dest_dir orelse "";
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
exe_list[1] = dir;
}
if (dir_list.include_dir) |dir| {
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
if (fs.path.isAbsolute(dir)) h_list[0] = b.dest_dir orelse "";
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
h_list[1] = dir;
}
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
b.lib_dir = b.pathJoin(&lib_list);
b.exe_dir = b.pathJoin(&exe_list);
b.h_dir = b.pathJoin(&h_list);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
zig build: add doc comments for functions related to options closes #18204
2024-01-18 21:31:45 -07:00
/// Create a set of key-value pairs that can be converted into a Zig source
/// file and then inserted into a Zig compilation's module table for importing.
/// In other words, this provides a way to expose build.zig values to Zig
/// source code with `@import`.
/// Related: `Module.addOptions`.
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
pub fn addOptions(b: *Build) *Step.Options {
return Step.Options.create(b);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
pub const ExecutableOptions = struct {
name: []const u8,
Remove numerous things deprecated during the 0.14 release cycle Basically everything that has a direct replacement or no uses left. Notable omissions: - std.ArrayHashMap: Too much fallout, needs a separate cleanup. - std.debug.runtime_safety: Too much fallout. - std.heap.GeneralPurposeAllocator: Lots of references to it remain, not a simple find and replace as "debug allocator" is not equivalent to "general purpose allocator". - std.io.Reader: Is being reworked at the moment. - std.unicode.utf8Decode(): No replacement, needs a new API first. - Manifest backwards compat options: Removal would break test data used by TestFetchBuilder. - panic handler needs to be a namespace: Many tests still rely on it being a function, needs a separate cleanup.
2025-03-05 03:17:54 +00:00
root_module: *Module,
std: replace builtin.Version with SemanticVersion
2023-02-21 18:39:22 +01:00
version: ?std.SemanticVersion = null,
std.builtin: make link mode fields lowercase
2024-02-18 20:34:32 -08:00
linkage: ?std.builtin.LinkMode = null,
zig build: add an OOM-prevention system The problem is that one may execute too many subprocesses concurrently that, together, exceed an RSS value that causes the OOM killer to kill something problematic such as the window manager. Or worse, nothing, and the system freezes. This is a real world problem. For example when building LLVM a simple `ninja install` will bring your system to its knees if you don't know that you should add `-DLLVM_PARALLEL_LINK_JOBS=1`. In particular: compiling the zig std lib tests takes about 2G each, which at 16x at once (8 cores + hyperthreading) is using all 32GB of my RAM, causing the OOM killer to kill my window manager The idea here is that you can annotate steps that might use a high amount of system resources with an upper bound. So for example I could mark the std lib tests as having an upper bound peak RSS of 3 GiB. Then the build system will do 2 things: 1. ulimit the child process, so that it will fail if it would exceed that memory limit. 2. Notice how much system RAM is available and avoid running too many concurrent jobs at once that would total more than that. This implements (1) not with an operating system enforced limit, but by checking the maxrss after a child process exits. However it does implement (2) correctly. The available memory used by the build system defaults to the total system memory, regardless of whether it is used by other processes at the time of spawning the build runner. This value can be overridden with the new --maxrss flag to `zig build`. This mechanism will ensure that the sum total of upper bound RSS memory of concurrent tasks will not exceed this value. This system makes it so that project maintainers can annotate problematic subprocesses, avoiding bug reports from users, who can blissfully execute `zig build` without worrying about the project's internals. Nobody's computer crashes, and the build system uses as much parallelism as possible without risking OOM. Users do not need to unnecessarily resort to -j1 when the build system can figure this out for them.
2023-03-06 00:20:11 -07:00
max_rss: usize = 0,
std.Build: add some more init options to CompileStep
2023-04-13 16:44:28 -07:00
use_llvm: ?bool = null,
use_lld: ?bool = null,
build system: follow-up enhancements regarding LazyPath * introduce LazyPath.cwd_relative variant and use it for --zig-lib-dir. closes #12685 * move overrideZigLibDir and setMainPkgPath to options fields set once and then never mutated. * avoid introducing Build/util.zig * use doc comments for deprecation notices so that they show up in generated documentation. * introduce InstallArtifact.Options, accept it as a parameter to addInstallArtifact, and move override_dest_dir into it. Instead of configuring the installation via Compile step, configure the installation via the InstallArtifact step. In retrospect this is obvious. * remove calls to pushInstalledFile in InstallArtifact. See #14943 * rewrite InstallArtifact to not incorrectly observe whether a Compile step has any generated outputs. InstallArtifact is meant to trigger output generation. * fix child process evaluation code handling of `-fno-emit-bin`. * don't store out_h_filename, out_ll_filename, etc., pointlessly. these are all just simple extensions appended to the root name. * make emit_directory optional. It's possible to have nothing outputted, for example, if you're just type-checking. * avoid passing -femit-foo/-fno-emit-foo when it is the default * rename ConfigHeader.getTemplate to getOutput * deprecate addOptionArtifact * update the random number seed of Options step caching. * avoid using `inline for` pointlessly * avoid using `override_Dest_dir` pointlessly * avoid emitting an executable pointlessly in test cases Removes forceBuild and forceEmit. Let's consider these additions separately. Nearly all of the usage sites were suspicious.
2023-07-29 23:57:52 -07:00
zig_lib_dir: ?LazyPath = null,
Add preliminary support for Windows .manifest files An embedded manifest file is really just XML data embedded as a RT_MANIFEST resource (ID = 24). Typically, the Windows-only 'Manifest Tool' (`mt.exe`) is used to embed manifest files, and `mt.exe` also seems to perform some transformation of the manifest data before embedding, but in testing it doesn't seem like the transformations are necessary to get the intended result. So, to handle embedding manifest files, Zig now takes the following approach: - Generate a .rc file with the contents `1 24 "path-to-manifest.manifest"` - Compile that generated .rc file into a .res file - Link the .res file into the final binary This effectively achieves the same thing as `mt.exe` minus the validation/transformations of the XML data that it performs. How this is used: On the command line: ``` zig build-exe main.zig main.manifest ``` (on the command line, specifying a .manifest file when the target object format is not COFF is an error) or in build.zig: ``` const exe = b.addExecutable(.{ .name = "manifest-test", .root_source_file = .{ .path = "main.zig" }, .target = target, .optimize = optimize, .win32_manifest = .{ .path = "main.manifest" }, }); ``` (in build.zig, the manifest file is ignored if the target object format is not COFF) Note: Currently, only one manifest file can be specified per compilation. This is because the ID of the manifest resource is currently always 1. Specifying multiple manifests could be supported if a way for the user to specify an ID for each manifest is added (manifest IDs must be a u16). Closes #17406 options
2023-10-09 04:06:28 -07:00
/// Embed a `.manifest` file in the compilation if the object format supports it.
/// https://learn.microsoft.com/en-us/windows/win32/sbscs/manifest-files-reference
/// Manifest files must have the extension `.manifest`.
/// Can be set regardless of target. The `.manifest` file will be ignored
/// if the target object format does not support embedded manifests.
win32_manifest: ?LazyPath = null,
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
};
std.Build: use Step.* instead of *Step Follow up to 13eb7251d37759bd47403db304c6120c706fe353
2023-05-03 11:49:55 +03:00
pub fn addExecutable(b: *Build, options: ExecutableOptions) *Step.Compile {
std.Build: add API to create Compile steps from existing module This commit amends `std.Build.ExecutableOptions` etc to have a new field, `root_module`, which allows artifacts to be created whose root module is an existing `*Module` rather than a freshly constructed one. This API can be far more versatile, allowing construction of complex module graphs before creating any compile steps, and therefore also allowing easy reuse of modules. The fields which correspond to module options, such as `root_source_file`, are all considered deprecated. They may not be populated at the same time as the `root_module` field. In the next release cycle, these deprecated fields will be removed, and the `root_module` field made non-optional.
2024-06-18 23:49:21 +05:00
return .create(b, .{
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
.name = options.name,
Remove numerous things deprecated during the 0.14 release cycle Basically everything that has a direct replacement or no uses left. Notable omissions: - std.ArrayHashMap: Too much fallout, needs a separate cleanup. - std.debug.runtime_safety: Too much fallout. - std.heap.GeneralPurposeAllocator: Lots of references to it remain, not a simple find and replace as "debug allocator" is not equivalent to "general purpose allocator". - std.io.Reader: Is being reworked at the moment. - std.unicode.utf8Decode(): No replacement, needs a new API first. - Manifest backwards compat options: Removal would break test data used by TestFetchBuilder. - panic handler needs to be a namespace: Many tests still rely on it being a function, needs a separate cleanup.
2025-03-05 03:17:54 +00:00
.root_module = options.root_module,
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
.version = options.version,
.kind = .exe,
.linkage = options.linkage,
zig build: add an OOM-prevention system The problem is that one may execute too many subprocesses concurrently that, together, exceed an RSS value that causes the OOM killer to kill something problematic such as the window manager. Or worse, nothing, and the system freezes. This is a real world problem. For example when building LLVM a simple `ninja install` will bring your system to its knees if you don't know that you should add `-DLLVM_PARALLEL_LINK_JOBS=1`. In particular: compiling the zig std lib tests takes about 2G each, which at 16x at once (8 cores + hyperthreading) is using all 32GB of my RAM, causing the OOM killer to kill my window manager The idea here is that you can annotate steps that might use a high amount of system resources with an upper bound. So for example I could mark the std lib tests as having an upper bound peak RSS of 3 GiB. Then the build system will do 2 things: 1. ulimit the child process, so that it will fail if it would exceed that memory limit. 2. Notice how much system RAM is available and avoid running too many concurrent jobs at once that would total more than that. This implements (1) not with an operating system enforced limit, but by checking the maxrss after a child process exits. However it does implement (2) correctly. The available memory used by the build system defaults to the total system memory, regardless of whether it is used by other processes at the time of spawning the build runner. This value can be overridden with the new --maxrss flag to `zig build`. This mechanism will ensure that the sum total of upper bound RSS memory of concurrent tasks will not exceed this value. This system makes it so that project maintainers can annotate problematic subprocesses, avoiding bug reports from users, who can blissfully execute `zig build` without worrying about the project's internals. Nobody's computer crashes, and the build system uses as much parallelism as possible without risking OOM. Users do not need to unnecessarily resort to -j1 when the build system can figure this out for them.
2023-03-06 00:20:11 -07:00
.max_rss = options.max_rss,
std.Build: add some more init options to CompileStep
2023-04-13 16:44:28 -07:00
.use_llvm = options.use_llvm,
.use_lld = options.use_lld,
integrate Compile steps with file watching Updates the build runner to unconditionally require a zig lib directory parameter. This parameter is needed in order to correctly understand file system inputs from zig compiler subprocesses, since they will refer to "the zig lib directory", and the build runner needs to place file system watches on directories in there. The build runner's fanotify file watching implementation now accounts for when two or more Cache.Path instances compare unequal but ultimately refer to the same directory in the file system. Breaking change: std.Build no longer has a zig_lib_dir field. Instead, there is the Graph zig_lib_directory field, and individual Compile steps can still have their zig lib directories overridden. I think this is unlikely to break anyone's build in practice. The compiler now sends a "file_system_inputs" message to the build runner which shares the full set of files that were added to the cache system with the build system, so that the build runner can watch properly and redo the Compile step. This is implemented for whole cache mode but not yet for incremental cache mode.
2024-07-11 16:26:04 -07:00
.zig_lib_dir = options.zig_lib_dir,
Add preliminary support for Windows .manifest files An embedded manifest file is really just XML data embedded as a RT_MANIFEST resource (ID = 24). Typically, the Windows-only 'Manifest Tool' (`mt.exe`) is used to embed manifest files, and `mt.exe` also seems to perform some transformation of the manifest data before embedding, but in testing it doesn't seem like the transformations are necessary to get the intended result. So, to handle embedding manifest files, Zig now takes the following approach: - Generate a .rc file with the contents `1 24 "path-to-manifest.manifest"` - Compile that generated .rc file into a .res file - Link the .res file into the final binary This effectively achieves the same thing as `mt.exe` minus the validation/transformations of the XML data that it performs. How this is used: On the command line: ``` zig build-exe main.zig main.manifest ``` (on the command line, specifying a .manifest file when the target object format is not COFF is an error) or in build.zig: ``` const exe = b.addExecutable(.{ .name = "manifest-test", .root_source_file = .{ .path = "main.zig" }, .target = target, .optimize = optimize, .win32_manifest = .{ .path = "main.manifest" }, }); ``` (in build.zig, the manifest file is ignored if the target object format is not COFF) Note: Currently, only one manifest file can be specified per compilation. This is because the ID of the manifest resource is currently always 1. Specifying multiple manifests could be supported if a way for the user to specify an ID for each manifest is added (manifest IDs must be a u16). Closes #17406 options
2023-10-09 04:06:28 -07:00
.win32_manifest = options.win32_manifest,
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
});
}
pub const ObjectOptions = struct {
name: []const u8,
Remove numerous things deprecated during the 0.14 release cycle Basically everything that has a direct replacement or no uses left. Notable omissions: - std.ArrayHashMap: Too much fallout, needs a separate cleanup. - std.debug.runtime_safety: Too much fallout. - std.heap.GeneralPurposeAllocator: Lots of references to it remain, not a simple find and replace as "debug allocator" is not equivalent to "general purpose allocator". - std.io.Reader: Is being reworked at the moment. - std.unicode.utf8Decode(): No replacement, needs a new API first. - Manifest backwards compat options: Removal would break test data used by TestFetchBuilder. - panic handler needs to be a namespace: Many tests still rely on it being a function, needs a separate cleanup.
2025-03-05 03:17:54 +00:00
root_module: *Module,
std.Build: add API to create Compile steps from existing module This commit amends `std.Build.ExecutableOptions` etc to have a new field, `root_module`, which allows artifacts to be created whose root module is an existing `*Module` rather than a freshly constructed one. This API can be far more versatile, allowing construction of complex module graphs before creating any compile steps, and therefore also allowing easy reuse of modules. The fields which correspond to module options, such as `root_source_file`, are all considered deprecated. They may not be populated at the same time as the `root_module` field. In the next release cycle, these deprecated fields will be removed, and the `root_module` field made non-optional.
2024-06-18 23:49:21 +05:00
max_rss: usize = 0,
use_llvm: ?bool = null,
use_lld: ?bool = null,
zig_lib_dir: ?LazyPath = null,
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
};
std.Build: use Step.* instead of *Step Follow up to 13eb7251d37759bd47403db304c6120c706fe353
2023-05-03 11:49:55 +03:00
pub fn addObject(b: *Build, options: ObjectOptions) *Step.Compile {
std.Build: add API to create Compile steps from existing module This commit amends `std.Build.ExecutableOptions` etc to have a new field, `root_module`, which allows artifacts to be created whose root module is an existing `*Module` rather than a freshly constructed one. This API can be far more versatile, allowing construction of complex module graphs before creating any compile steps, and therefore also allowing easy reuse of modules. The fields which correspond to module options, such as `root_source_file`, are all considered deprecated. They may not be populated at the same time as the `root_module` field. In the next release cycle, these deprecated fields will be removed, and the `root_module` field made non-optional.
2024-06-18 23:49:21 +05:00
return .create(b, .{
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
.name = options.name,
Remove numerous things deprecated during the 0.14 release cycle Basically everything that has a direct replacement or no uses left. Notable omissions: - std.ArrayHashMap: Too much fallout, needs a separate cleanup. - std.debug.runtime_safety: Too much fallout. - std.heap.GeneralPurposeAllocator: Lots of references to it remain, not a simple find and replace as "debug allocator" is not equivalent to "general purpose allocator". - std.io.Reader: Is being reworked at the moment. - std.unicode.utf8Decode(): No replacement, needs a new API first. - Manifest backwards compat options: Removal would break test data used by TestFetchBuilder. - panic handler needs to be a namespace: Many tests still rely on it being a function, needs a separate cleanup.
2025-03-05 03:17:54 +00:00
.root_module = options.root_module,
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
.kind = .obj,
zig build: add an OOM-prevention system The problem is that one may execute too many subprocesses concurrently that, together, exceed an RSS value that causes the OOM killer to kill something problematic such as the window manager. Or worse, nothing, and the system freezes. This is a real world problem. For example when building LLVM a simple `ninja install` will bring your system to its knees if you don't know that you should add `-DLLVM_PARALLEL_LINK_JOBS=1`. In particular: compiling the zig std lib tests takes about 2G each, which at 16x at once (8 cores + hyperthreading) is using all 32GB of my RAM, causing the OOM killer to kill my window manager The idea here is that you can annotate steps that might use a high amount of system resources with an upper bound. So for example I could mark the std lib tests as having an upper bound peak RSS of 3 GiB. Then the build system will do 2 things: 1. ulimit the child process, so that it will fail if it would exceed that memory limit. 2. Notice how much system RAM is available and avoid running too many concurrent jobs at once that would total more than that. This implements (1) not with an operating system enforced limit, but by checking the maxrss after a child process exits. However it does implement (2) correctly. The available memory used by the build system defaults to the total system memory, regardless of whether it is used by other processes at the time of spawning the build runner. This value can be overridden with the new --maxrss flag to `zig build`. This mechanism will ensure that the sum total of upper bound RSS memory of concurrent tasks will not exceed this value. This system makes it so that project maintainers can annotate problematic subprocesses, avoiding bug reports from users, who can blissfully execute `zig build` without worrying about the project's internals. Nobody's computer crashes, and the build system uses as much parallelism as possible without risking OOM. Users do not need to unnecessarily resort to -j1 when the build system can figure this out for them.
2023-03-06 00:20:11 -07:00
.max_rss = options.max_rss,
std.Build: add some more init options to CompileStep
2023-04-13 16:44:28 -07:00
.use_llvm = options.use_llvm,
.use_lld = options.use_lld,
integrate Compile steps with file watching Updates the build runner to unconditionally require a zig lib directory parameter. This parameter is needed in order to correctly understand file system inputs from zig compiler subprocesses, since they will refer to "the zig lib directory", and the build runner needs to place file system watches on directories in there. The build runner's fanotify file watching implementation now accounts for when two or more Cache.Path instances compare unequal but ultimately refer to the same directory in the file system. Breaking change: std.Build no longer has a zig_lib_dir field. Instead, there is the Graph zig_lib_directory field, and individual Compile steps can still have their zig lib directories overridden. I think this is unlikely to break anyone's build in practice. The compiler now sends a "file_system_inputs" message to the build runner which shares the full set of files that were added to the cache system with the build system, so that the build runner can watch properly and redo the Compile step. This is implemented for whole cache mode but not yet for incremental cache mode.
2024-07-11 16:26:04 -07:00
.zig_lib_dir = options.zig_lib_dir,
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
});
}
std.Build: add `addLibrary` function (#22554) Acts as a replacement for `addSharedLibrary` and `addStaticLibrary`, but linking mode can be changed more easily in build.zig, for example: In library: ```zig const linkage = b.option(std.builtin.LinkMode, "linkage", "Link mode for a foo_bar library") orelse .static; // or other default const lib = b.addLibrary(.{ .linkage = linkage, .name = "foo_bar", .root_module = mod, }); ``` In consumer: ```zig const dep_foo_bar = b.dependency("foo_bar", .{ .target = target, .optimize = optimize, .linkage = .static // or dynamic }); mod.linkLibrary(dep_foor_bar.artifact("foo_bar")); ``` It also matches nicely with `linkLibrary` name. Signed-off-by: Eric Joldasov <bratishkaerik@landless-city.net>
2025-01-22 07:29:21 +05:00
pub const LibraryOptions = struct {
linkage: std.builtin.LinkMode = .static,
name: []const u8,
root_module: *Module,
version: ?std.SemanticVersion = null,
max_rss: usize = 0,
use_llvm: ?bool = null,
use_lld: ?bool = null,
zig_lib_dir: ?LazyPath = null,
/// Embed a `.manifest` file in the compilation if the object format supports it.
/// https://learn.microsoft.com/en-us/windows/win32/sbscs/manifest-files-reference
/// Manifest files must have the extension `.manifest`.
/// Can be set regardless of target. The `.manifest` file will be ignored
/// if the target object format does not support embedded manifests.
win32_manifest: ?LazyPath = null,
};
pub fn addLibrary(b: *Build, options: LibraryOptions) *Step.Compile {
return .create(b, .{
.name = options.name,
.root_module = options.root_module,
.kind = .lib,
.linkage = options.linkage,
.version = options.version,
.max_rss = options.max_rss,
.use_llvm = options.use_llvm,
.use_lld = options.use_lld,
.zig_lib_dir = options.zig_lib_dir,
.win32_manifest = options.win32_manifest,
});
}
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
pub const TestOptions = struct {
name: []const u8 = "test",
Remove numerous things deprecated during the 0.14 release cycle Basically everything that has a direct replacement or no uses left. Notable omissions: - std.ArrayHashMap: Too much fallout, needs a separate cleanup. - std.debug.runtime_safety: Too much fallout. - std.heap.GeneralPurposeAllocator: Lots of references to it remain, not a simple find and replace as "debug allocator" is not equivalent to "general purpose allocator". - std.io.Reader: Is being reworked at the moment. - std.unicode.utf8Decode(): No replacement, needs a new API first. - Manifest backwards compat options: Removal would break test data used by TestFetchBuilder. - panic handler needs to be a namespace: Many tests still rely on it being a function, needs a separate cleanup.
2025-03-05 03:17:54 +00:00
root_module: *Module,
zig build: add an OOM-prevention system The problem is that one may execute too many subprocesses concurrently that, together, exceed an RSS value that causes the OOM killer to kill something problematic such as the window manager. Or worse, nothing, and the system freezes. This is a real world problem. For example when building LLVM a simple `ninja install` will bring your system to its knees if you don't know that you should add `-DLLVM_PARALLEL_LINK_JOBS=1`. In particular: compiling the zig std lib tests takes about 2G each, which at 16x at once (8 cores + hyperthreading) is using all 32GB of my RAM, causing the OOM killer to kill my window manager The idea here is that you can annotate steps that might use a high amount of system resources with an upper bound. So for example I could mark the std lib tests as having an upper bound peak RSS of 3 GiB. Then the build system will do 2 things: 1. ulimit the child process, so that it will fail if it would exceed that memory limit. 2. Notice how much system RAM is available and avoid running too many concurrent jobs at once that would total more than that. This implements (1) not with an operating system enforced limit, but by checking the maxrss after a child process exits. However it does implement (2) correctly. The available memory used by the build system defaults to the total system memory, regardless of whether it is used by other processes at the time of spawning the build runner. This value can be overridden with the new --maxrss flag to `zig build`. This mechanism will ensure that the sum total of upper bound RSS memory of concurrent tasks will not exceed this value. This system makes it so that project maintainers can annotate problematic subprocesses, avoiding bug reports from users, who can blissfully execute `zig build` without worrying about the project's internals. Nobody's computer crashes, and the build system uses as much parallelism as possible without risking OOM. Users do not need to unnecessarily resort to -j1 when the build system can figure this out for them.
2023-03-06 00:20:11 -07:00
max_rss: usize = 0,
test: rework how filtering works * make test names contain the fully qualified name * make test filters match the fully qualified name * allow multiple test filters, where a test is skipped if it does not match any of the specified filters
2024-02-25 14:04:06 +01:00
filters: []const []const u8 = &.{},
std.Build: extend `test_runner` option to specify whether runner uses `std.zig.Server` The previous logic here was trying to assume that custom test runners never used `std.zig.Server` to communicate with the build runner; however, it was flawed, because modifying the `test_runner` field on `Step.Compile` would not update this flag. That might have been intentional (allowing a way for the user to specify a custom test runner which *does* use the compiler server protocol), but if so, it was a flawed API, since it was too easy to update one field without updating the other. Instead, bundle these two pieces of state into a new type `std.Build.Step.Compile.TestRunner`. When passing a custom test runner, you are now *provided* to specify whether it is a "simple" runner, or whether it uses the compiler server protocol. This is a breaking change, but is unlikely to affect many people, since custom test runners are seldom used in the wild.
2025-01-10 10:48:52 +00:00
test_runner: ?Step.Compile.TestRunner = null,
std.Build: add API to create Compile steps from existing module This commit amends `std.Build.ExecutableOptions` etc to have a new field, `root_module`, which allows artifacts to be created whose root module is an existing `*Module` rather than a freshly constructed one. This API can be far more versatile, allowing construction of complex module graphs before creating any compile steps, and therefore also allowing easy reuse of modules. The fields which correspond to module options, such as `root_source_file`, are all considered deprecated. They may not be populated at the same time as the `root_module` field. In the next release cycle, these deprecated fields will be removed, and the `root_module` field made non-optional.
2024-06-18 23:49:21 +05:00
use_llvm: ?bool = null,
use_lld: ?bool = null,
zig_lib_dir: ?LazyPath = null,
compiler: allow emitting tests to an object file This is fairly straightforward; the actual compiler changes are limited to the CLI, since `Compilation` already supports this combination. A new `std.Build` API is introduced to allow representing this. By passing the `emit_object` option to `std.Build.addTest`, you get a `Step.Compile` which emits an object file; you can then use that as you would any other object, such as either installing it for external use, or linking it into another step. A standalone test is added to cover the build system API. It builds a test into an object, and links it into a final executable, which it then runs. Using this build system mechanism prevents the build system from noticing that you're running a `zig test`, so the build runner and test runner do not communicate over stdio. However, that's okay, because the real-world use cases for this feature don't want to do that anyway! Resolves: #23374
2025-04-20 17:54:11 +01:00
/// Emits an object file instead of a test binary.
/// The object must be linked separately.
/// Usually used in conjunction with a custom `test_runner`.
emit_object: bool = false,
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
};
std.Build.addTest: add doc comments closes #15009
2024-03-21 14:02:58 -07:00
/// Creates an executable containing unit tests.
///
/// Equivalent to running the command `zig test --test-no-exec ...`.
///
/// **This step does not run the unit tests**. Typically, the result of this
/// function will be passed to `addRunArtifact`, creating a `Step.Run`. These
/// two steps are separated because they are independently configured and
/// cached.
std.Build: use Step.* instead of *Step Follow up to 13eb7251d37759bd47403db304c6120c706fe353
2023-05-03 11:49:55 +03:00
pub fn addTest(b: *Build, options: TestOptions) *Step.Compile {
std.Build: add API to create Compile steps from existing module This commit amends `std.Build.ExecutableOptions` etc to have a new field, `root_module`, which allows artifacts to be created whose root module is an existing `*Module` rather than a freshly constructed one. This API can be far more versatile, allowing construction of complex module graphs before creating any compile steps, and therefore also allowing easy reuse of modules. The fields which correspond to module options, such as `root_source_file`, are all considered deprecated. They may not be populated at the same time as the `root_module` field. In the next release cycle, these deprecated fields will be removed, and the `root_module` field made non-optional.
2024-06-18 23:49:21 +05:00
return .create(b, .{
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
.name = options.name,
compiler: allow emitting tests to an object file This is fairly straightforward; the actual compiler changes are limited to the CLI, since `Compilation` already supports this combination. A new `std.Build` API is introduced to allow representing this. By passing the `emit_object` option to `std.Build.addTest`, you get a `Step.Compile` which emits an object file; you can then use that as you would any other object, such as either installing it for external use, or linking it into another step. A standalone test is added to cover the build system API. It builds a test into an object, and links it into a final executable, which it then runs. Using this build system mechanism prevents the build system from noticing that you're running a `zig test`, so the build runner and test runner do not communicate over stdio. However, that's okay, because the real-world use cases for this feature don't want to do that anyway! Resolves: #23374
2025-04-20 17:54:11 +01:00
.kind = if (options.emit_object) .test_obj else .@"test",
Remove numerous things deprecated during the 0.14 release cycle Basically everything that has a direct replacement or no uses left. Notable omissions: - std.ArrayHashMap: Too much fallout, needs a separate cleanup. - std.debug.runtime_safety: Too much fallout. - std.heap.GeneralPurposeAllocator: Lots of references to it remain, not a simple find and replace as "debug allocator" is not equivalent to "general purpose allocator". - std.io.Reader: Is being reworked at the moment. - std.unicode.utf8Decode(): No replacement, needs a new API first. - Manifest backwards compat options: Removal would break test data used by TestFetchBuilder. - panic handler needs to be a namespace: Many tests still rely on it being a function, needs a separate cleanup.
2025-03-05 03:17:54 +00:00
.root_module = options.root_module,
zig build: add an OOM-prevention system The problem is that one may execute too many subprocesses concurrently that, together, exceed an RSS value that causes the OOM killer to kill something problematic such as the window manager. Or worse, nothing, and the system freezes. This is a real world problem. For example when building LLVM a simple `ninja install` will bring your system to its knees if you don't know that you should add `-DLLVM_PARALLEL_LINK_JOBS=1`. In particular: compiling the zig std lib tests takes about 2G each, which at 16x at once (8 cores + hyperthreading) is using all 32GB of my RAM, causing the OOM killer to kill my window manager The idea here is that you can annotate steps that might use a high amount of system resources with an upper bound. So for example I could mark the std lib tests as having an upper bound peak RSS of 3 GiB. Then the build system will do 2 things: 1. ulimit the child process, so that it will fail if it would exceed that memory limit. 2. Notice how much system RAM is available and avoid running too many concurrent jobs at once that would total more than that. This implements (1) not with an operating system enforced limit, but by checking the maxrss after a child process exits. However it does implement (2) correctly. The available memory used by the build system defaults to the total system memory, regardless of whether it is used by other processes at the time of spawning the build runner. This value can be overridden with the new --maxrss flag to `zig build`. This mechanism will ensure that the sum total of upper bound RSS memory of concurrent tasks will not exceed this value. This system makes it so that project maintainers can annotate problematic subprocesses, avoiding bug reports from users, who can blissfully execute `zig build` without worrying about the project's internals. Nobody's computer crashes, and the build system uses as much parallelism as possible without risking OOM. Users do not need to unnecessarily resort to -j1 when the build system can figure this out for them.
2023-03-06 00:20:11 -07:00
.max_rss = options.max_rss,
Remove numerous things deprecated during the 0.14 release cycle Basically everything that has a direct replacement or no uses left. Notable omissions: - std.ArrayHashMap: Too much fallout, needs a separate cleanup. - std.debug.runtime_safety: Too much fallout. - std.heap.GeneralPurposeAllocator: Lots of references to it remain, not a simple find and replace as "debug allocator" is not equivalent to "general purpose allocator". - std.io.Reader: Is being reworked at the moment. - std.unicode.utf8Decode(): No replacement, needs a new API first. - Manifest backwards compat options: Removal would break test data used by TestFetchBuilder. - panic handler needs to be a namespace: Many tests still rely on it being a function, needs a separate cleanup.
2025-03-05 03:17:54 +00:00
.filters = b.dupeStrings(options.filters),
fix build logic due to state mutations and break the API accordingly * remove setName, setFilter, and setTestRunner. Please set these options directly when creating the CompileStep. * removed unused field * remove computeOutFileNames and inline the logic, making clear the goal of avoiding state mutations after the build step is created.
2023-04-10 18:09:39 -07:00
.test_runner = options.test_runner,
std.Build: add some more init options to CompileStep
2023-04-13 16:44:28 -07:00
.use_llvm = options.use_llvm,
.use_lld = options.use_lld,
integrate Compile steps with file watching Updates the build runner to unconditionally require a zig lib directory parameter. This parameter is needed in order to correctly understand file system inputs from zig compiler subprocesses, since they will refer to "the zig lib directory", and the build runner needs to place file system watches on directories in there. The build runner's fanotify file watching implementation now accounts for when two or more Cache.Path instances compare unequal but ultimately refer to the same directory in the file system. Breaking change: std.Build no longer has a zig_lib_dir field. Instead, there is the Graph zig_lib_directory field, and individual Compile steps can still have their zig lib directories overridden. I think this is unlikely to break anyone's build in practice. The compiler now sends a "file_system_inputs" message to the build runner which shares the full set of files that were added to the cache system with the build system, so that the build runner can watch properly and redo the Compile step. This is implemented for whole cache mode but not yet for incremental cache mode.
2024-07-11 16:26:04 -07:00
.zig_lib_dir = options.zig_lib_dir,
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
});
}
pub const AssemblyOptions = struct {
name: []const u8,
Build.zig rename orgy (aka: #16353). Renames FileSource to LazyPath and removes functions that take literal paths instead of LazyPath.
2023-07-19 10:49:34 +02:00
source_file: LazyPath,
zig build system: change target, compilation, and module APIs Introduce the concept of "target query" and "resolved target". A target query is what the user specifies, with some things left to default. A resolved target has the default things discovered and populated. In the future, std.zig.CrossTarget will be rename to std.Target.Query. Introduces `std.Build.resolveTargetQuery` to get from one to the other. The concept of `main_mod_path` is gone, no longer supported. You have to put the root source file at the module root now. * remove deprecated API * update build.zig for the breaking API changes in this branch * move std.Build.Step.Compile.BuildId to std.zig.BuildId * add more options to std.Build.ExecutableOptions, std.Build.ObjectOptions, std.Build.SharedLibraryOptions, std.Build.StaticLibraryOptions, and std.Build.TestOptions. * remove `std.Build.constructCMacro`. There is no use for this API. * deprecate `std.Build.Step.Compile.defineCMacro`. Instead, `std.Build.Module.addCMacro` is provided. - remove `std.Build.Step.Compile.defineCMacroRaw`. * deprecate `std.Build.Step.Compile.linkFrameworkNeeded` - use `std.Build.Module.linkFramework` * deprecate `std.Build.Step.Compile.linkFrameworkWeak` - use `std.Build.Module.linkFramework` * move more logic into `std.Build.Module` * allow `target` and `optimize` to be `null` when creating a Module. Along with other fields, those unspecified options will be inherited from parent `Module` when inserted into an import table. * the `target` field of `addExecutable` is now required. pass `b.host` to get the host target.
2023-12-02 21:51:34 -07:00
/// To choose the same computer as the one building the package, pass the
/// `host` field of the package's `Build` instance.
target: ResolvedTarget,
change uses of std.builtin.Mode to OptimizeMode (#16745) std.builtin.Mode is deprecated.
2023-08-09 13:39:34 -05:00
optimize: std.builtin.OptimizeMode,
zig build: add an OOM-prevention system The problem is that one may execute too many subprocesses concurrently that, together, exceed an RSS value that causes the OOM killer to kill something problematic such as the window manager. Or worse, nothing, and the system freezes. This is a real world problem. For example when building LLVM a simple `ninja install` will bring your system to its knees if you don't know that you should add `-DLLVM_PARALLEL_LINK_JOBS=1`. In particular: compiling the zig std lib tests takes about 2G each, which at 16x at once (8 cores + hyperthreading) is using all 32GB of my RAM, causing the OOM killer to kill my window manager The idea here is that you can annotate steps that might use a high amount of system resources with an upper bound. So for example I could mark the std lib tests as having an upper bound peak RSS of 3 GiB. Then the build system will do 2 things: 1. ulimit the child process, so that it will fail if it would exceed that memory limit. 2. Notice how much system RAM is available and avoid running too many concurrent jobs at once that would total more than that. This implements (1) not with an operating system enforced limit, but by checking the maxrss after a child process exits. However it does implement (2) correctly. The available memory used by the build system defaults to the total system memory, regardless of whether it is used by other processes at the time of spawning the build runner. This value can be overridden with the new --maxrss flag to `zig build`. This mechanism will ensure that the sum total of upper bound RSS memory of concurrent tasks will not exceed this value. This system makes it so that project maintainers can annotate problematic subprocesses, avoiding bug reports from users, who can blissfully execute `zig build` without worrying about the project's internals. Nobody's computer crashes, and the build system uses as much parallelism as possible without risking OOM. Users do not need to unnecessarily resort to -j1 when the build system can figure this out for them.
2023-03-06 00:20:11 -07:00
max_rss: usize = 0,
build system: follow-up enhancements regarding LazyPath * introduce LazyPath.cwd_relative variant and use it for --zig-lib-dir. closes #12685 * move overrideZigLibDir and setMainPkgPath to options fields set once and then never mutated. * avoid introducing Build/util.zig * use doc comments for deprecation notices so that they show up in generated documentation. * introduce InstallArtifact.Options, accept it as a parameter to addInstallArtifact, and move override_dest_dir into it. Instead of configuring the installation via Compile step, configure the installation via the InstallArtifact step. In retrospect this is obvious. * remove calls to pushInstalledFile in InstallArtifact. See #14943 * rewrite InstallArtifact to not incorrectly observe whether a Compile step has any generated outputs. InstallArtifact is meant to trigger output generation. * fix child process evaluation code handling of `-fno-emit-bin`. * don't store out_h_filename, out_ll_filename, etc., pointlessly. these are all just simple extensions appended to the root name. * make emit_directory optional. It's possible to have nothing outputted, for example, if you're just type-checking. * avoid passing -femit-foo/-fno-emit-foo when it is the default * rename ConfigHeader.getTemplate to getOutput * deprecate addOptionArtifact * update the random number seed of Options step caching. * avoid using `inline for` pointlessly * avoid using `override_Dest_dir` pointlessly * avoid emitting an executable pointlessly in test cases Removes forceBuild and forceEmit. Let's consider these additions separately. Nearly all of the usage sites were suspicious.
2023-07-29 23:57:52 -07:00
zig_lib_dir: ?LazyPath = null,
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
};
std.Build.addModule: return the created module
2023-03-03 16:17:23 -07:00
/// This function creates a module and adds it to the package's module set, making
/// it available to other packages which depend on this one.
/// `createModule` can be used instead to create a private module.
introduce std.Build.Module and extract some logic into it This moves many settings from `std.Build.Step.Compile` and into `std.Build.Module`, and then makes them transitive. In other words, it adds support for exposing Zig modules in packages, which are configured in various ways, such as depending on other link objects, include paths, or even a different optimization mode. Now, transitive dependencies will be included in the compilation, so you can, for example, make a Zig module depend on some C source code, and expose that Zig module in a package. Currently, the compiler frontend autogenerates only one `@import("builtin")` module for the entire compilation, however, a future enhancement will be to make it honor the differences in modules, so that modules can be compiled with different optimization modes, code model, valgrind integration, or even target CPU feature set. closes #14719
2023-11-28 22:47:34 -07:00
pub fn addModule(b: *Build, name: []const u8, options: Module.CreateOptions) *Module {
const module = Module.create(b, options);
std.Build.addModule: return the created module
2023-03-03 16:17:23 -07:00
b.modules.put(b.dupe(name), module) catch @panic("OOM");
return module;
std.Build: support exposing and depending on zig modules New API introduced: std.Build.addModule This function exposes a zig module with the given name, which can be used by packages that depend on this one via std.Build.Dependency.module. std.Build.Pkg and related functionality is deleted. Every use case has a straightforward upgrade path using the new Module struct. std.Build.OptionsStep.getPackage is replaced by std.Build.OptionsStep.createModule. std.Build.CompileStep.addPackagePath is replaced by std.Build.CompileStep.addAnonymousModule. This partially addresses #14307 by renaming some of the instances of "package" to "module". Closes #14278
2023-02-03 17:22:31 -07:00
}
std.Build.addModule: return the created module
2023-03-03 16:17:23 -07:00
/// This function creates a private module, to be used by the current package,
/// but not exposed to other packages depending on this one.
/// `addModule` can be used instead to create a public module.
introduce std.Build.Module and extract some logic into it This moves many settings from `std.Build.Step.Compile` and into `std.Build.Module`, and then makes them transitive. In other words, it adds support for exposing Zig modules in packages, which are configured in various ways, such as depending on other link objects, include paths, or even a different optimization mode. Now, transitive dependencies will be included in the compilation, so you can, for example, make a Zig module depend on some C source code, and expose that Zig module in a package. Currently, the compiler frontend autogenerates only one `@import("builtin")` module for the entire compilation, however, a future enhancement will be to make it honor the differences in modules, so that modules can be compiled with different optimization modes, code model, valgrind integration, or even target CPU feature set. closes #14719
2023-11-28 22:47:34 -07:00
pub fn createModule(b: *Build, options: Module.CreateOptions) *Module {
return Module.create(b, options);
std.Build: support exposing and depending on zig modules New API introduced: std.Build.addModule This function exposes a zig module with the given name, which can be used by packages that depend on this one via std.Build.Dependency.module. std.Build.Pkg and related functionality is deleted. Every use case has a straightforward upgrade path using the new Module struct. std.Build.OptionsStep.getPackage is replaced by std.Build.OptionsStep.createModule. std.Build.CompileStep.addPackagePath is replaced by std.Build.CompileStep.addAnonymousModule. This partially addresses #14307 by renaming some of the instances of "package" to "module". Closes #14278
2023-02-03 17:22:31 -07:00
}
std.Build: use Step.* instead of *Step Follow up to 13eb7251d37759bd47403db304c6120c706fe353
2023-05-03 11:49:55 +03:00
/// Initializes a `Step.Run` with argv, which must at least have the path to the
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
/// executable. More command line arguments can be added with `addArg`,
/// `addArgs`, and `addArtifactArg`.
/// Be careful using this function, as it introduces a system dependency.
std.Build: use Step.* instead of *Step Follow up to 13eb7251d37759bd47403db304c6120c706fe353
2023-05-03 11:49:55 +03:00
/// To run an executable built with zig build, see `Step.Compile.run`.
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
pub fn addSystemCommand(b: *Build, argv: []const []const u8) *Step.Run {
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
assert(argv.len >= 1);
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
const run_step = Step.Run.create(b, b.fmt("run {s}", .{argv[0]}));
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
run_step.addArgs(argv);
return run_step;
}
std.Build: use Step.* instead of *Step Follow up to 13eb7251d37759bd47403db304c6120c706fe353
2023-05-03 11:49:55 +03:00
/// Creates a `Step.Run` with an executable built with `addExecutable`.
/// Add command line arguments with methods of `Step.Run`.
pub fn addRunArtifact(b: *Build, exe: *Step.Compile) *Step.Run {
std.Build: support running build artifacts from packages Deprecate CompileStep.run. The problem with this function is that it does the RunStep with the same build.zig context as the CompileStep, but this is not desirable when running an executable that is provided by a dependency package. Instead, users should use `b.addRunArtifact`. This has the additional benefit of conforming to the existing naming conventions. Additionally, support enum literals in config header options values.
2023-02-05 16:44:03 -07:00
// It doesn't have to be native. We catch that if you actually try to run it.
// Consider that this is declarative; the run step may not be run unless a user
// option is supplied.
Build: change how the target is printed in step names e.g. `x86_64-windows.win10...win11_dt-gnu` -> `x86_64-windows-gnu` When the OS version is the default this is redundant with checking the default in the standard library.
2025-06-13 05:46:15 -04:00
// Avoid the common case of the step name looking like "run test test".
const step_name = if (exe.kind.isTest() and mem.eql(u8, exe.name, "test"))
b.fmt("run {s}", .{@tagName(exe.kind)})
else
b.fmt("run {s} {s}", .{ @tagName(exe.kind), exe.name });
const run_step = Step.Run.create(b, step_name);
add `--fuzz` CLI argument to `zig build` This flag makes the build runner rebuild unit tests after the pipeline finishes, if it finds any unit tests. I did not make this integrate with file system watching yet. The test runner is updated to detect which tests are fuzz tests. Run step is updated to track which test indexes are fuzz tests.
2024-07-23 20:49:00 -07:00
run_step.producer = exe;
build: inherit setExecCmd from test compile steps when creating run steps This should fix #17756
2024-04-13 15:30:03 +02:00
if (exe.kind == .@"test") {
if (exe.exec_cmd_args) |exec_cmd_args| {
for (exec_cmd_args) |cmd_arg| {
if (cmd_arg) |arg| {
run_step.addArg(arg);
} else {
run_step.addArtifactArg(exe);
}
}
} else {
run_step.addArtifactArg(exe);
}
std.Build: support running build artifacts from packages Deprecate CompileStep.run. The problem with this function is that it does the RunStep with the same build.zig context as the CompileStep, but this is not desirable when running an executable that is provided by a dependency package. Instead, users should use `b.addRunArtifact`. This has the additional benefit of conforming to the existing naming conventions. Additionally, support enum literals in config header options values.
2023-02-05 16:44:03 -07:00
std.Build: do not expect server protocol for tests using immature backends For instance, when running a Zig test using the self-hosted aarch64 backend, this logic was previously expecting `std.zig.Server` to be used, but the default test runner intentionally does not do this because the backend is too immature to handle it. On 'master', this is causing sporadic failures; on this branch, they became consistent failures.
2025-09-13 16:16:11 +01:00
const test_server_mode: bool = s: {
if (exe.test_runner) |r| break :s r.mode == .server;
if (exe.use_llvm == false) {
// The default test runner does not use the server protocol if the selected backend
// is too immature to support it. Keep this logic in sync with `need_simple` in the
// default test runner implementation.
switch (exe.rootModuleTarget().cpu.arch) {
// stage2_aarch64
.aarch64,
.aarch64_be,
// stage2_powerpc
.powerpc,
.powerpcle,
.powerpc64,
.powerpc64le,
// stage2_riscv64
.riscv64,
=> break :s false,
else => {},
}
}
break :s true;
};
if (test_server_mode) {
run_step.enableTestRunnerMode();
} else if (exe.test_runner == null) {
// If a test runner does not use the `std.zig.Server` protocol, it can instead
// communicate failure via its exit code.
run_step.expectExitCode(0);
}
build: inherit setExecCmd from test compile steps when creating run steps This should fix #17756
2024-04-13 15:30:03 +02:00
} else {
run_step.addArtifactArg(exe);
std.Build: support running build artifacts from packages Deprecate CompileStep.run. The problem with this function is that it does the RunStep with the same build.zig context as the CompileStep, but this is not desirable when running an executable that is provided by a dependency package. Instead, users should use `b.addRunArtifact`. This has the additional benefit of conforming to the existing naming conventions. Additionally, support enum literals in config header options values.
2023-02-05 16:44:03 -07:00
}
return run_step;
}
std.Build: enhancements to ConfigHeaderStep Breaking API change to std.Build.addConfigHeader. It now uses an options struct. Introduce std.Build.CompileStep.installConfigHeader which also accepts an options struct. This is used to add a generated config file into the set of installed header files for a particular compilation artifact. std.Build.ConfigHeaderStep now additionally supports a "blank" style where a header is generated from scratch. It no longer exposes `output_dir`. Instead it exposes a FileSource via `output_file`. It now additionally accepts an `include_path` option which affects the include path of CompileStep when using the `#include` directive, as well as affecting the default installation subdirectory for header installation purposes. The hash used for the directory to store the generated config file now includes the contents of the generated file. This fixes possible race conditions when generating multiple header files simultaneously. The values hash table is now an array hash map, to preserve order for the "blank" use case. I also took the opportunity to remove output_dir from TranslateCStep and WriteFileStep. This is technically a breaking change, but it was always naughty to access these fields.
2023-02-04 22:44:21 -07:00
/// Using the `values` provided, produces a C header file, possibly based on a
/// template input file (e.g. config.h.in).
/// When an input template file is provided, this function will fail the build
/// when an option not found in the input file is provided in `values`, and
/// when an option found in the input file is missing from `values`.
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
pub fn addConfigHeader(
b: *Build,
std.Build: use Step.* instead of *Step Follow up to 13eb7251d37759bd47403db304c6120c706fe353
2023-05-03 11:49:55 +03:00
options: Step.ConfigHeader.Options,
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
values: anytype,
std.Build: use Step.* instead of *Step Follow up to 13eb7251d37759bd47403db304c6120c706fe353
2023-05-03 11:49:55 +03:00
) *Step.ConfigHeader {
std.Build: improve debugging of misconfigured steps * Step.init() now takes an options struct * Step.init() now captures a small stack trace and stores it in the Step so that it can be accessed when printing user-friendly debugging information, including the lines of code that created the step in question.
2023-02-14 12:47:45 -07:00
var options_copy = options;
if (options_copy.first_ret_addr == null)
options_copy.first_ret_addr = @returnAddress();
std.Build: use Step.* instead of *Step Follow up to 13eb7251d37759bd47403db304c6120c706fe353
2023-05-03 11:49:55 +03:00
const config_header_step = Step.ConfigHeader.create(b, options_copy);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
config_header_step.addValues(values);
return config_header_step;
}
/// Allocator.dupe without the need to handle out of memory.
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
pub fn dupe(b: *Build, bytes: []const u8) []u8 {
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
return dupeInner(b.allocator, bytes);
}
pub fn dupeInner(allocator: std.mem.Allocator, bytes: []const u8) []u8 {
return allocator.dupe(u8, bytes) catch @panic("OOM");
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
/// Duplicates an array of strings without the need to handle out of memory.
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
pub fn dupeStrings(b: *Build, strings: []const []const u8) [][]u8 {
const array = b.allocator.alloc([]u8, strings.len) catch @panic("OOM");
for (array, strings) |*dest, source| dest.* = b.dupe(source);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
return array;
}
/// Duplicates a path and converts all slashes to the OS's canonical path separator.
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
pub fn dupePath(b: *Build, bytes: []const u8) []u8 {
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
return dupePathInner(b.allocator, bytes);
}
fn dupePathInner(allocator: std.mem.Allocator, bytes: []const u8) []u8 {
const the_copy = dupeInner(allocator, bytes);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
for (the_copy) |*byte| {
switch (byte.*) {
'/', '\\' => byte.* = fs.path.sep,
else => {},
}
}
return the_copy;
}
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
pub fn addWriteFile(b: *Build, file_path: []const u8, data: []const u8) *Step.WriteFile {
const write_file_step = b.addWriteFiles();
Fixes `WriteFile.getFileSource` failure on Windows (#15730)
2023-05-24 14:26:07 -07:00
_ = write_file_step.add(file_path, data);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
return write_file_step;
}
Build: add namedWriteFiles to Build
2023-10-22 16:10:01 +02:00
pub fn addNamedWriteFiles(b: *Build, name: []const u8) *Step.WriteFile {
const wf = Step.WriteFile.create(b);
b.named_writefiles.put(b.dupe(name), wf) catch @panic("OOM");
return wf;
}
std.Build: allow packages to expose arbitrary LazyPaths by name
2024-09-11 09:06:54 +01:00
pub fn addNamedLazyPath(b: *Build, name: []const u8, lp: LazyPath) void {
b.named_lazy_paths.put(b.dupe(name), lp.dupe(b)) catch @panic("OOM");
}
std.Build: use Step.* instead of *Step Follow up to 13eb7251d37759bd47403db304c6120c706fe353
2023-05-03 11:49:55 +03:00
pub fn addWriteFiles(b: *Build) *Step.WriteFile {
return Step.WriteFile.create(b);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
std.Build.Step.WriteFile: extract UpdateSourceFiles This has been planned for quite some time; this commit finally does it. Also implements file system watching integration in the make() implementation for UpdateSourceFiles and fixes the reporting of step caching for both. WriteFile does not yet have file system watching integration.
2024-07-09 21:47:26 -07:00
pub fn addUpdateSourceFiles(b: *Build) *Step.UpdateSourceFiles {
return Step.UpdateSourceFiles.create(b);
}
make more build steps integrate with the watch system
2024-07-09 21:08:20 -07:00
pub fn addRemoveDirTree(b: *Build, dir_path: LazyPath) *Step.RemoveDir {
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
return Step.RemoveDir.create(b, dir_path);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
std.Build: Add Step.Fail and addFail() function. Closes #15373.
2024-06-16 04:42:58 +02:00
pub fn addFail(b: *Build, error_msg: []const u8) *Step.Fail {
return Step.Fail.create(b, error_msg);
}
std.Build: use Step.* instead of *Step Follow up to 13eb7251d37759bd47403db304c6120c706fe353
2023-05-03 11:49:55 +03:00
pub fn addFmt(b: *Build, options: Step.Fmt.Options) *Step.Fmt {
return Step.Fmt.create(b, options);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
pub fn addTranslateC(b: *Build, options: Step.TranslateC.Options) *Step.TranslateC {
return Step.TranslateC.create(b, options);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
pub fn getInstallStep(b: *Build) *Step {
return &b.install_tls.step;
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
pub fn getUninstallStep(b: *Build) *Step {
return &b.uninstall_tls.step;
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
make zig compiler processes live across rebuilds Changes the `make` function signature to take an options struct, which additionally includes `watch: bool`. I intentionally am not exposing this information to configure phase logic. Also adds global zig cache to the compiler cache prefixes. Closes #20600
2024-07-14 19:48:08 -07:00
fn makeUninstall(uninstall_step: *Step, options: Step.MakeOptions) anyerror!void {
_ = options;
Update uses of `@fieldParentPtr` to use RLS
2024-03-19 12:46:38 +01:00
const uninstall_tls: *TopLevelStep = @fieldParentPtr("step", uninstall_step);
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
const b: *Build = @fieldParentPtr("uninstall_tls", uninstall_tls);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
std.Build: remove the "push installed file" mechanism Tracked by #14943
2024-07-05 13:05:56 -07:00
_ = b;
@panic("TODO implement https://github.com/ziglang/zig/issues/14943");
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
zig build: add doc comments for functions related to options closes #18204
2024-01-18 21:31:45 -07:00
/// Creates a configuration option to be passed to the build.zig script.
/// When a user directly runs `zig build`, they can set these options with `-D` arguments.
/// When a project depends on a Zig package as a dependency, it programmatically sets
/// these options when calling the dependency's build.zig script as a function.
/// `null` is returned when an option is left to default.
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
pub fn option(b: *Build, comptime T: type, name_raw: []const u8, description_raw: []const u8) ?T {
const name = b.dupe(name_raw);
const description = b.dupe(description_raw);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
const type_id = comptime typeToEnum(T);
Add support for []enum in Build.option
2024-06-06 06:02:42 +02:00
const enum_options = if (type_id == .@"enum" or type_id == .enum_list) blk: {
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
const EnumType = if (type_id == .enum_list) @typeInfo(T).pointer.child else T;
Add support for []enum in Build.option
2024-06-06 06:02:42 +02:00
const fields = comptime std.meta.fields(EnumType);
std.ArrayList: make unmanaged the default
2025-07-31 21:54:07 -07:00
var options = std.array_list.Managed([]const u8).initCapacity(b.allocator, fields.len) catch @panic("OOM");
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
inline for (fields) |field| {
options.appendAssumeCapacity(field.name);
}
std.Build: avoid use of catch unreachable Usage of `catch unreachable` in build scripts is completely harmless because build scripts are always run in Debug mode, however, it sets a poor example for beginners to learn from.
2023-01-31 14:02:32 -07:00
break :blk options.toOwnedSlice() catch @panic("OOM");
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
} else null;
const available_option = AvailableOption{
.name = name,
.type_id = type_id,
.description = description,
.enum_options = enum_options,
};
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
if ((b.available_options_map.fetchPut(name, available_option) catch @panic("OOM")) != null) {
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
panic("Option '{s}' declared twice", .{name});
}
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
b.available_options_list.append(available_option) catch @panic("OOM");
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
const option_ptr = b.user_input_options.getPtr(name) orelse return null;
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
option_ptr.used = true;
switch (type_id) {
.bool => switch (option_ptr.value) {
.flag => return true,
.scalar => |s| {
if (mem.eql(u8, s, "true")) {
return true;
} else if (mem.eql(u8, s, "false")) {
return false;
} else {
tweaks to --build-id * build.zig: the result of b.option() can be assigned directly in many cases thanks to the return type being an optional * std.Build: make the build system aware of the std.Build.Step.Compile.BuildId type when used as an option. - remove extraneous newlines in error logs * simplify caching logic * simplify hexstring parsing tests and use a doc test * simplify hashing logic. don't use an optional when the `none` tag already provides this meaning. * CLI: fix incorrect linker arg parsing
2023-05-16 20:00:47 -07:00
log.err("Expected -D{s} to be a boolean, but received '{s}'", .{ name, s });
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
b.markInvalidUserInput();
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
return null;
}
},
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
.list, .map, .lazy_path, .lazy_path_list => {
tweaks to --build-id * build.zig: the result of b.option() can be assigned directly in many cases thanks to the return type being an optional * std.Build: make the build system aware of the std.Build.Step.Compile.BuildId type when used as an option. - remove extraneous newlines in error logs * simplify caching logic * simplify hexstring parsing tests and use a doc test * simplify hashing logic. don't use an optional when the `none` tag already provides this meaning. * CLI: fix incorrect linker arg parsing
2023-05-16 20:00:47 -07:00
log.err("Expected -D{s} to be a boolean, but received a {s}.", .{
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
name, @tagName(option_ptr.value),
});
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
b.markInvalidUserInput();
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
return null;
},
},
.int => switch (option_ptr.value) {
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
.flag, .list, .map, .lazy_path, .lazy_path_list => {
tweaks to --build-id * build.zig: the result of b.option() can be assigned directly in many cases thanks to the return type being an optional * std.Build: make the build system aware of the std.Build.Step.Compile.BuildId type when used as an option. - remove extraneous newlines in error logs * simplify caching logic * simplify hexstring parsing tests and use a doc test * simplify hashing logic. don't use an optional when the `none` tag already provides this meaning. * CLI: fix incorrect linker arg parsing
2023-05-16 20:00:47 -07:00
log.err("Expected -D{s} to be an integer, but received a {s}.", .{
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
name, @tagName(option_ptr.value),
});
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
b.markInvalidUserInput();
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
return null;
},
.scalar => |s| {
const n = std.fmt.parseInt(T, s, 10) catch |err| switch (err) {
error.Overflow => {
tweaks to --build-id * build.zig: the result of b.option() can be assigned directly in many cases thanks to the return type being an optional * std.Build: make the build system aware of the std.Build.Step.Compile.BuildId type when used as an option. - remove extraneous newlines in error logs * simplify caching logic * simplify hexstring parsing tests and use a doc test * simplify hashing logic. don't use an optional when the `none` tag already provides this meaning. * CLI: fix incorrect linker arg parsing
2023-05-16 20:00:47 -07:00
log.err("-D{s} value {s} cannot fit into type {s}.", .{ name, s, @typeName(T) });
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
b.markInvalidUserInput();
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
return null;
},
else => {
tweaks to --build-id * build.zig: the result of b.option() can be assigned directly in many cases thanks to the return type being an optional * std.Build: make the build system aware of the std.Build.Step.Compile.BuildId type when used as an option. - remove extraneous newlines in error logs * simplify caching logic * simplify hexstring parsing tests and use a doc test * simplify hashing logic. don't use an optional when the `none` tag already provides this meaning. * CLI: fix incorrect linker arg parsing
2023-05-16 20:00:47 -07:00
log.err("Expected -D{s} to be an integer of type {s}.", .{ name, @typeName(T) });
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
b.markInvalidUserInput();
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
return null;
},
};
return n;
},
},
.float => switch (option_ptr.value) {
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
.flag, .map, .list, .lazy_path, .lazy_path_list => {
tweaks to --build-id * build.zig: the result of b.option() can be assigned directly in many cases thanks to the return type being an optional * std.Build: make the build system aware of the std.Build.Step.Compile.BuildId type when used as an option. - remove extraneous newlines in error logs * simplify caching logic * simplify hexstring parsing tests and use a doc test * simplify hashing logic. don't use an optional when the `none` tag already provides this meaning. * CLI: fix incorrect linker arg parsing
2023-05-16 20:00:47 -07:00
log.err("Expected -D{s} to be a float, but received a {s}.", .{
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
name, @tagName(option_ptr.value),
});
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
b.markInvalidUserInput();
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
return null;
},
.scalar => |s| {
const n = std.fmt.parseFloat(T, s) catch {
tweaks to --build-id * build.zig: the result of b.option() can be assigned directly in many cases thanks to the return type being an optional * std.Build: make the build system aware of the std.Build.Step.Compile.BuildId type when used as an option. - remove extraneous newlines in error logs * simplify caching logic * simplify hexstring parsing tests and use a doc test * simplify hashing logic. don't use an optional when the `none` tag already provides this meaning. * CLI: fix incorrect linker arg parsing
2023-05-16 20:00:47 -07:00
log.err("Expected -D{s} to be a float of type {s}.", .{ name, @typeName(T) });
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
b.markInvalidUserInput();
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
return null;
};
return n;
},
},
.@"enum" => switch (option_ptr.value) {
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
.flag, .map, .list, .lazy_path, .lazy_path_list => {
tweaks to --build-id * build.zig: the result of b.option() can be assigned directly in many cases thanks to the return type being an optional * std.Build: make the build system aware of the std.Build.Step.Compile.BuildId type when used as an option. - remove extraneous newlines in error logs * simplify caching logic * simplify hexstring parsing tests and use a doc test * simplify hashing logic. don't use an optional when the `none` tag already provides this meaning. * CLI: fix incorrect linker arg parsing
2023-05-16 20:00:47 -07:00
log.err("Expected -D{s} to be an enum, but received a {s}.", .{
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
name, @tagName(option_ptr.value),
});
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
b.markInvalidUserInput();
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
return null;
},
.scalar => |s| {
if (std.meta.stringToEnum(T, s)) |enum_lit| {
return enum_lit;
} else {
tweaks to --build-id * build.zig: the result of b.option() can be assigned directly in many cases thanks to the return type being an optional * std.Build: make the build system aware of the std.Build.Step.Compile.BuildId type when used as an option. - remove extraneous newlines in error logs * simplify caching logic * simplify hexstring parsing tests and use a doc test * simplify hashing logic. don't use an optional when the `none` tag already provides this meaning. * CLI: fix incorrect linker arg parsing
2023-05-16 20:00:47 -07:00
log.err("Expected -D{s} to be of type {s}.", .{ name, @typeName(T) });
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
b.markInvalidUserInput();
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
return null;
}
},
},
.string => switch (option_ptr.value) {
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
.flag, .list, .map, .lazy_path, .lazy_path_list => {
tweaks to --build-id * build.zig: the result of b.option() can be assigned directly in many cases thanks to the return type being an optional * std.Build: make the build system aware of the std.Build.Step.Compile.BuildId type when used as an option. - remove extraneous newlines in error logs * simplify caching logic * simplify hexstring parsing tests and use a doc test * simplify hashing logic. don't use an optional when the `none` tag already provides this meaning. * CLI: fix incorrect linker arg parsing
2023-05-16 20:00:47 -07:00
log.err("Expected -D{s} to be a string, but received a {s}.", .{
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
name, @tagName(option_ptr.value),
});
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
b.markInvalidUserInput();
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
return null;
},
.scalar => |s| return s,
},
tweaks to --build-id * build.zig: the result of b.option() can be assigned directly in many cases thanks to the return type being an optional * std.Build: make the build system aware of the std.Build.Step.Compile.BuildId type when used as an option. - remove extraneous newlines in error logs * simplify caching logic * simplify hexstring parsing tests and use a doc test * simplify hashing logic. don't use an optional when the `none` tag already provides this meaning. * CLI: fix incorrect linker arg parsing
2023-05-16 20:00:47 -07:00
.build_id => switch (option_ptr.value) {
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
.flag, .map, .list, .lazy_path, .lazy_path_list => {
tweaks to --build-id * build.zig: the result of b.option() can be assigned directly in many cases thanks to the return type being an optional * std.Build: make the build system aware of the std.Build.Step.Compile.BuildId type when used as an option. - remove extraneous newlines in error logs * simplify caching logic * simplify hexstring parsing tests and use a doc test * simplify hashing logic. don't use an optional when the `none` tag already provides this meaning. * CLI: fix incorrect linker arg parsing
2023-05-16 20:00:47 -07:00
log.err("Expected -D{s} to be an enum, but received a {s}.", .{
name, @tagName(option_ptr.value),
});
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
b.markInvalidUserInput();
tweaks to --build-id * build.zig: the result of b.option() can be assigned directly in many cases thanks to the return type being an optional * std.Build: make the build system aware of the std.Build.Step.Compile.BuildId type when used as an option. - remove extraneous newlines in error logs * simplify caching logic * simplify hexstring parsing tests and use a doc test * simplify hashing logic. don't use an optional when the `none` tag already provides this meaning. * CLI: fix incorrect linker arg parsing
2023-05-16 20:00:47 -07:00
return null;
},
.scalar => |s| {
zig build system: change target, compilation, and module APIs Introduce the concept of "target query" and "resolved target". A target query is what the user specifies, with some things left to default. A resolved target has the default things discovered and populated. In the future, std.zig.CrossTarget will be rename to std.Target.Query. Introduces `std.Build.resolveTargetQuery` to get from one to the other. The concept of `main_mod_path` is gone, no longer supported. You have to put the root source file at the module root now. * remove deprecated API * update build.zig for the breaking API changes in this branch * move std.Build.Step.Compile.BuildId to std.zig.BuildId * add more options to std.Build.ExecutableOptions, std.Build.ObjectOptions, std.Build.SharedLibraryOptions, std.Build.StaticLibraryOptions, and std.Build.TestOptions. * remove `std.Build.constructCMacro`. There is no use for this API. * deprecate `std.Build.Step.Compile.defineCMacro`. Instead, `std.Build.Module.addCMacro` is provided. - remove `std.Build.Step.Compile.defineCMacroRaw`. * deprecate `std.Build.Step.Compile.linkFrameworkNeeded` - use `std.Build.Module.linkFramework` * deprecate `std.Build.Step.Compile.linkFrameworkWeak` - use `std.Build.Module.linkFramework` * move more logic into `std.Build.Module` * allow `target` and `optimize` to be `null` when creating a Module. Along with other fields, those unspecified options will be inherited from parent `Module` when inserted into an import table. * the `target` field of `addExecutable` is now required. pass `b.host` to get the host target.
2023-12-02 21:51:34 -07:00
if (std.zig.BuildId.parse(s)) |build_id| {
tweaks to --build-id * build.zig: the result of b.option() can be assigned directly in many cases thanks to the return type being an optional * std.Build: make the build system aware of the std.Build.Step.Compile.BuildId type when used as an option. - remove extraneous newlines in error logs * simplify caching logic * simplify hexstring parsing tests and use a doc test * simplify hashing logic. don't use an optional when the `none` tag already provides this meaning. * CLI: fix incorrect linker arg parsing
2023-05-16 20:00:47 -07:00
return build_id;
} else |err| {
log.err("unable to parse option '-D{s}': {s}", .{ name, @errorName(err) });
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
b.markInvalidUserInput();
tweaks to --build-id * build.zig: the result of b.option() can be assigned directly in many cases thanks to the return type being an optional * std.Build: make the build system aware of the std.Build.Step.Compile.BuildId type when used as an option. - remove extraneous newlines in error logs * simplify caching logic * simplify hexstring parsing tests and use a doc test * simplify hashing logic. don't use an optional when the `none` tag already provides this meaning. * CLI: fix incorrect linker arg parsing
2023-05-16 20:00:47 -07:00
return null;
}
},
},
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
.list => switch (option_ptr.value) {
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
.flag, .map, .lazy_path, .lazy_path_list => {
tweaks to --build-id * build.zig: the result of b.option() can be assigned directly in many cases thanks to the return type being an optional * std.Build: make the build system aware of the std.Build.Step.Compile.BuildId type when used as an option. - remove extraneous newlines in error logs * simplify caching logic * simplify hexstring parsing tests and use a doc test * simplify hashing logic. don't use an optional when the `none` tag already provides this meaning. * CLI: fix incorrect linker arg parsing
2023-05-16 20:00:47 -07:00
log.err("Expected -D{s} to be a list, but received a {s}.", .{
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
name, @tagName(option_ptr.value),
});
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
b.markInvalidUserInput();
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
return null;
},
.scalar => |s| {
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
return b.allocator.dupe([]const u8, &[_][]const u8{s}) catch @panic("OOM");
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
},
.list => |lst| return lst.items,
},
Add support for []enum in Build.option
2024-06-06 06:02:42 +02:00
.enum_list => switch (option_ptr.value) {
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
.flag, .map, .lazy_path, .lazy_path_list => {
Add support for []enum in Build.option
2024-06-06 06:02:42 +02:00
log.err("Expected -D{s} to be a list, but received a {s}.", .{
name, @tagName(option_ptr.value),
});
b.markInvalidUserInput();
return null;
},
.scalar => |s| {
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
const Child = @typeInfo(T).pointer.child;
Add support for []enum in Build.option
2024-06-06 06:02:42 +02:00
const value = std.meta.stringToEnum(Child, s) orelse {
log.err("Expected -D{s} to be of type {s}.", .{ name, @typeName(Child) });
b.markInvalidUserInput();
return null;
};
return b.allocator.dupe(Child, &[_]Child{value}) catch @panic("OOM");
},
.list => |lst| {
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
const Child = @typeInfo(T).pointer.child;
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
const new_list = b.allocator.alloc(Child, lst.items.len) catch @panic("OOM");
for (new_list, lst.items) |*new_item, str| {
new_item.* = std.meta.stringToEnum(Child, str) orelse {
Add support for []enum in Build.option
2024-06-06 06:02:42 +02:00
log.err("Expected -D{s} to be of type {s}.", .{ name, @typeName(Child) });
b.markInvalidUserInput();
b.allocator.free(new_list);
return null;
};
}
return new_list;
},
},
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
.lazy_path => switch (option_ptr.value) {
.scalar => |s| return .{ .cwd_relative = s },
.lazy_path => |lp| return lp,
.flag, .map, .list, .lazy_path_list => {
log.err("Expected -D{s} to be a path, but received a {s}.", .{
name, @tagName(option_ptr.value),
});
b.markInvalidUserInput();
return null;
},
},
.lazy_path_list => switch (option_ptr.value) {
.scalar => |s| return b.allocator.dupe(LazyPath, &[_]LazyPath{.{ .cwd_relative = s }}) catch @panic("OOM"),
.lazy_path => |lp| return b.allocator.dupe(LazyPath, &[_]LazyPath{lp}) catch @panic("OOM"),
.list => |lst| {
const new_list = b.allocator.alloc(LazyPath, lst.items.len) catch @panic("OOM");
for (new_list, lst.items) |*new_item, str| {
new_item.* = .{ .cwd_relative = str };
}
return new_list;
},
.lazy_path_list => |lp_list| return lp_list.items,
.flag, .map => {
log.err("Expected -D{s} to be a path, but received a {s}.", .{
name, @tagName(option_ptr.value),
});
b.markInvalidUserInput();
return null;
},
},
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
}
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
pub fn step(b: *Build, name: []const u8, description: []const u8) *Step {
const step_info = b.allocator.create(TopLevelStep) catch @panic("OOM");
zig build: many enhancements related to parallel building Rework std.Build.Step to have an `owner: *Build` field. This simplified the implementation of installation steps, as well as provided some much-needed common API for the new parallelized build system. --verbose is now defined very concretely: it prints to stderr just before spawning a child process. Child process execution is updated to conform to the new parallel-friendly make() function semantics. DRY up the failWithCacheError handling code. It now integrates properly with the step graph instead of incorrectly dumping to stderr and calling process exit. In the main CLI, fix `zig fmt` crash when there are no errors and stdin is used. Deleted steps: * EmulatableRunStep - this entire thing can be removed in favor of a flag added to std.Build.RunStep called `skip_foreign_checks`. * LogStep - this doesn't really fit with a multi-threaded build runner and is effectively superseded by the new build summary output. build runner: * add -fsummary and -fno-summary to override the default behavior, which is to print a summary if any of the build steps fail. * print the dep prefix when emitting error messages for steps. std.Build.FmtStep: * This step now supports exclude paths as well as a check flag. * The check flag decides between two modes, modify mode, and check mode. These can be used to update source files in place, or to fail the build, respectively. Zig's own build.zig: * The `test-fmt` step will do all the `zig fmt` checking that we expect to be done. Since the `test` step depends on this one, we can simply remove the explicit call to `zig fmt` in the CI. * The new `fmt` step will actually perform `zig fmt` and update source files in place. std.Build.RunStep: * expose max_stdio_size is a field (previously an unchangeable hard-coded value). * rework the API. Instead of configuring each stream independently, there is a `stdio` field where you can choose between `infer_from_args`, `inherit`, or `check`. These determine whether the RunStep is considered to have side-effects or not. The previous field, `condition` is gone. * when stdio mode is set to `check` there is a slice of any number of checks to make, which include things like exit code, stderr matching, or stdout matching. * remove the ill-defined `print` field. * when adding an output arg, it takes the opportunity to give itself a better name. * The flag `skip_foreign_checks` is added. If this is true, a RunStep which is configured to check the output of the executed binary will not fail the build if the binary cannot be executed due to being for a foreign binary to the host system which is running the build graph. Command-line arguments such as -fqemu and -fwasmtime may affect whether a binary is detected as foreign, as well as system configuration such as Rosetta (macOS) and binfmt_misc (Linux). - This makes EmulatableRunStep no longer needed. * Fix the child process handling to properly integrate with the new bulid API and to avoid deadlocks in stdout/stderr streams by polling if necessary. std.Build.RemoveDirStep now uses the open build_root directory handle instead of an absolute path.
2023-03-01 22:56:37 -07:00
step_info.* = .{
fix build runner
2025-07-02 11:16:20 -07:00
.step = .init(.{
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
.id = TopLevelStep.base_id,
std.Build: improve debugging of misconfigured steps * Step.init() now takes an options struct * Step.init() now captures a small stack trace and stores it in the Step so that it can be accessed when printing user-friendly debugging information, including the lines of code that created the step in question.
2023-02-14 12:47:45 -07:00
.name = name,
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
.owner = b,
std.Build: improve debugging of misconfigured steps * Step.init() now takes an options struct * Step.init() now captures a small stack trace and stores it in the Step so that it can be accessed when printing user-friendly debugging information, including the lines of code that created the step in question.
2023-02-14 12:47:45 -07:00
}),
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
.description = b.dupe(description),
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
};
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
const gop = b.top_level_steps.getOrPut(b.allocator, name) catch @panic("OOM");
std.Build: detect and disallow top-level step name clashes
2023-03-10 13:03:40 +11:00
if (gop.found_existing) std.debug.panic("A top-level step with name \"{s}\" already exists", .{name});
gop.key_ptr.* = step_info.step.name;
gop.value_ptr.* = step_info;
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
return &step_info.step;
}
pub const StandardOptimizeOptionOptions = struct {
change uses of std.builtin.Mode to OptimizeMode (#16745) std.builtin.Mode is deprecated.
2023-08-09 13:39:34 -05:00
preferred_optimize_mode: ?std.builtin.OptimizeMode = null,
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
};
build system: implement --release[=mode] This allows a `zig build` command to specify intention to create a release build, regardless of what per-project options exist. It also allows the command to specify a "preferred optimization mode", which is chosen if the project itself does not choose one (in other words, the project gets first choice). If neither the build command nor the project specify a preferred release mode, an error occurs.
2024-02-01 20:17:07 -07:00
pub fn standardOptimizeOption(b: *Build, options: StandardOptimizeOptionOptions) std.builtin.OptimizeMode {
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
if (options.preferred_optimize_mode) |mode| {
build system: implement --release[=mode] This allows a `zig build` command to specify intention to create a release build, regardless of what per-project options exist. It also allows the command to specify a "preferred optimization mode", which is chosen if the project itself does not choose one (in other words, the project gets first choice). If neither the build command nor the project specify a preferred release mode, an error occurs.
2024-02-01 20:17:07 -07:00
if (b.option(bool, "release", "optimize for end users") orelse (b.release_mode != .off)) {
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
return mode;
} else {
return .Debug;
}
}
build system: implement --release[=mode] This allows a `zig build` command to specify intention to create a release build, regardless of what per-project options exist. It also allows the command to specify a "preferred optimization mode", which is chosen if the project itself does not choose one (in other words, the project gets first choice). If neither the build command nor the project specify a preferred release mode, an error occurs.
2024-02-01 20:17:07 -07:00
if (b.option(
std.builtin.OptimizeMode,
"optimize",
build system: implement --system [dir] This prevents package fetching and enables system_package_mode in the build system which flips the defaults for system integrations.
2024-02-01 22:43:41 -07:00
"Prioritize performance, safety, or binary size",
build system: implement --release[=mode] This allows a `zig build` command to specify intention to create a release build, regardless of what per-project options exist. It also allows the command to specify a "preferred optimization mode", which is chosen if the project itself does not choose one (in other words, the project gets first choice). If neither the build command nor the project specify a preferred release mode, an error occurs.
2024-02-01 20:17:07 -07:00
)) |mode| {
return mode;
}
return switch (b.release_mode) {
.off => .Debug,
.any => {
std.debug.print("the project does not declare a preferred optimization mode. choose: --release=fast, --release=safe, or --release=small\n", .{});
process.exit(1);
},
.fast => .ReleaseFast,
.safe => .ReleaseSafe,
.small => .ReleaseSmall,
};
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
pub const StandardTargetOptionsArgs = struct {
rename std.zig.CrossTarget to std.Target.Query
2023-12-04 12:35:04 -07:00
whitelist: ?[]const Target.Query = null,
default_target: Target.Query = .{},
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
};
zig build system: change target, compilation, and module APIs Introduce the concept of "target query" and "resolved target". A target query is what the user specifies, with some things left to default. A resolved target has the default things discovered and populated. In the future, std.zig.CrossTarget will be rename to std.Target.Query. Introduces `std.Build.resolveTargetQuery` to get from one to the other. The concept of `main_mod_path` is gone, no longer supported. You have to put the root source file at the module root now. * remove deprecated API * update build.zig for the breaking API changes in this branch * move std.Build.Step.Compile.BuildId to std.zig.BuildId * add more options to std.Build.ExecutableOptions, std.Build.ObjectOptions, std.Build.SharedLibraryOptions, std.Build.StaticLibraryOptions, and std.Build.TestOptions. * remove `std.Build.constructCMacro`. There is no use for this API. * deprecate `std.Build.Step.Compile.defineCMacro`. Instead, `std.Build.Module.addCMacro` is provided. - remove `std.Build.Step.Compile.defineCMacroRaw`. * deprecate `std.Build.Step.Compile.linkFrameworkNeeded` - use `std.Build.Module.linkFramework` * deprecate `std.Build.Step.Compile.linkFrameworkWeak` - use `std.Build.Module.linkFramework` * move more logic into `std.Build.Module` * allow `target` and `optimize` to be `null` when creating a Module. Along with other fields, those unspecified options will be inherited from parent `Module` when inserted into an import table. * the `target` field of `addExecutable` is now required. pass `b.host` to get the host target.
2023-12-02 21:51:34 -07:00
/// Exposes standard `zig build` options for choosing a target and additionally
/// resolves the target query.
pub fn standardTargetOptions(b: *Build, args: StandardTargetOptionsArgs) ResolvedTarget {
const query = b.standardTargetOptionsQueryOnly(args);
return b.resolveTargetQuery(query);
}
std.Build: fix wrong variable used in `parseTargetQuery` Also address clobbering diagnostics field with an assert and doc comment to use the Target.Query.parse function themselves. Fixes #18876
2024-02-13 21:08:13 +01:00
/// Obtain a target query from a string, reporting diagnostics to stderr if the
/// parsing failed.
/// Asserts that the `diagnostics` field of `options` is `null`. This use case
/// is handled instead by calling `std.Target.Query.parse` directly.
std.Build: implement --host-target, --host-cpu, --host-dynamic-linker This also makes a long-overdue change of extracting common state from Build into a shared Graph object. Getting the semantics right for these flags turned out to be quite tricky. In the end it works like this: * The override only happens when the target is fully native, with no additional query parameters, such as versions or CPU features added. * The override affects the resolved Target but leaves the original Query unmodified. * The "is native?" detection logic operates on the original, unmodified query. This makes it possible to provide invalid host target information, causing confusing errors to occur. Don't do that. There are some minor breaking changes to std.Build API such as the fact that `b.zig_exe` is now moved to `b.graph.zig_exe`, as well as a handful of other similar flags.
2024-02-01 15:44:44 -07:00
pub fn parseTargetQuery(options: std.Target.Query.ParseOptions) error{ParseFailed}!std.Target.Query {
std.Build: fix wrong variable used in `parseTargetQuery` Also address clobbering diagnostics field with an assert and doc comment to use the Target.Query.parse function themselves. Fixes #18876
2024-02-13 21:08:13 +01:00
assert(options.diagnostics == null);
rename std.zig.CrossTarget to std.Target.Query
2023-12-04 12:35:04 -07:00
var diags: Target.Query.ParseOptions.Diagnostics = .{};
std.Build: implement --host-target, --host-cpu, --host-dynamic-linker This also makes a long-overdue change of extracting common state from Build into a shared Graph object. Getting the semantics right for these flags turned out to be quite tricky. In the end it works like this: * The override only happens when the target is fully native, with no additional query parameters, such as versions or CPU features added. * The override affects the resolved Target but leaves the original Query unmodified. * The "is native?" detection logic operates on the original, unmodified query. This makes it possible to provide invalid host target information, causing confusing errors to occur. Don't do that. There are some minor breaking changes to std.Build API such as the fact that `b.zig_exe` is now moved to `b.graph.zig_exe`, as well as a handful of other similar flags.
2024-02-01 15:44:44 -07:00
var opts_copy = options;
opts_copy.diagnostics = &diags;
std.Build: fix wrong variable used in `parseTargetQuery` Also address clobbering diagnostics field with an assert and doc comment to use the Target.Query.parse function themselves. Fixes #18876
2024-02-13 21:08:13 +01:00
return std.Target.Query.parse(opts_copy) catch |err| switch (err) {
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
error.UnknownCpuModel => {
std.Build: implement --host-target, --host-cpu, --host-dynamic-linker This also makes a long-overdue change of extracting common state from Build into a shared Graph object. Getting the semantics right for these flags turned out to be quite tricky. In the end it works like this: * The override only happens when the target is fully native, with no additional query parameters, such as versions or CPU features added. * The override affects the resolved Target but leaves the original Query unmodified. * The "is native?" detection logic operates on the original, unmodified query. This makes it possible to provide invalid host target information, causing confusing errors to occur. Don't do that. There are some minor breaking changes to std.Build API such as the fact that `b.zig_exe` is now moved to `b.graph.zig_exe`, as well as a handful of other similar flags.
2024-02-01 15:44:44 -07:00
std.debug.print("unknown CPU: '{s}'\navailable CPUs for architecture '{s}':\n", .{
diags.cpu_name.?, @tagName(diags.arch.?),
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
});
for (diags.arch.?.allCpuModels()) |cpu| {
std.Build: implement --host-target, --host-cpu, --host-dynamic-linker This also makes a long-overdue change of extracting common state from Build into a shared Graph object. Getting the semantics right for these flags turned out to be quite tricky. In the end it works like this: * The override only happens when the target is fully native, with no additional query parameters, such as versions or CPU features added. * The override affects the resolved Target but leaves the original Query unmodified. * The "is native?" detection logic operates on the original, unmodified query. This makes it possible to provide invalid host target information, causing confusing errors to occur. Don't do that. There are some minor breaking changes to std.Build API such as the fact that `b.zig_exe` is now moved to `b.graph.zig_exe`, as well as a handful of other similar flags.
2024-02-01 15:44:44 -07:00
std.debug.print(" {s}\n", .{cpu.name});
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
std.Build: implement --host-target, --host-cpu, --host-dynamic-linker This also makes a long-overdue change of extracting common state from Build into a shared Graph object. Getting the semantics right for these flags turned out to be quite tricky. In the end it works like this: * The override only happens when the target is fully native, with no additional query parameters, such as versions or CPU features added. * The override affects the resolved Target but leaves the original Query unmodified. * The "is native?" detection logic operates on the original, unmodified query. This makes it possible to provide invalid host target information, causing confusing errors to occur. Don't do that. There are some minor breaking changes to std.Build API such as the fact that `b.zig_exe` is now moved to `b.graph.zig_exe`, as well as a handful of other similar flags.
2024-02-01 15:44:44 -07:00
return error.ParseFailed;
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
},
error.UnknownCpuFeature => {
std.Build: implement --host-target, --host-cpu, --host-dynamic-linker This also makes a long-overdue change of extracting common state from Build into a shared Graph object. Getting the semantics right for these flags turned out to be quite tricky. In the end it works like this: * The override only happens when the target is fully native, with no additional query parameters, such as versions or CPU features added. * The override affects the resolved Target but leaves the original Query unmodified. * The "is native?" detection logic operates on the original, unmodified query. This makes it possible to provide invalid host target information, causing confusing errors to occur. Don't do that. There are some minor breaking changes to std.Build API such as the fact that `b.zig_exe` is now moved to `b.graph.zig_exe`, as well as a handful of other similar flags.
2024-02-01 15:44:44 -07:00
std.debug.print(
\\unknown CPU feature: '{s}'
\\available CPU features for architecture '{s}':
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
\\
, .{
diags.unknown_feature_name.?,
@tagName(diags.arch.?),
});
for (diags.arch.?.allFeaturesList()) |feature| {
std.Build: implement --host-target, --host-cpu, --host-dynamic-linker This also makes a long-overdue change of extracting common state from Build into a shared Graph object. Getting the semantics right for these flags turned out to be quite tricky. In the end it works like this: * The override only happens when the target is fully native, with no additional query parameters, such as versions or CPU features added. * The override affects the resolved Target but leaves the original Query unmodified. * The "is native?" detection logic operates on the original, unmodified query. This makes it possible to provide invalid host target information, causing confusing errors to occur. Don't do that. There are some minor breaking changes to std.Build API such as the fact that `b.zig_exe` is now moved to `b.graph.zig_exe`, as well as a handful of other similar flags.
2024-02-01 15:44:44 -07:00
std.debug.print(" {s}: {s}\n", .{ feature.name, feature.description });
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
std.Build: implement --host-target, --host-cpu, --host-dynamic-linker This also makes a long-overdue change of extracting common state from Build into a shared Graph object. Getting the semantics right for these flags turned out to be quite tricky. In the end it works like this: * The override only happens when the target is fully native, with no additional query parameters, such as versions or CPU features added. * The override affects the resolved Target but leaves the original Query unmodified. * The "is native?" detection logic operates on the original, unmodified query. This makes it possible to provide invalid host target information, causing confusing errors to occur. Don't do that. There are some minor breaking changes to std.Build API such as the fact that `b.zig_exe` is now moved to `b.graph.zig_exe`, as well as a handful of other similar flags.
2024-02-01 15:44:44 -07:00
return error.ParseFailed;
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
},
error.UnknownOperatingSystem => {
std.Build: implement --host-target, --host-cpu, --host-dynamic-linker This also makes a long-overdue change of extracting common state from Build into a shared Graph object. Getting the semantics right for these flags turned out to be quite tricky. In the end it works like this: * The override only happens when the target is fully native, with no additional query parameters, such as versions or CPU features added. * The override affects the resolved Target but leaves the original Query unmodified. * The "is native?" detection logic operates on the original, unmodified query. This makes it possible to provide invalid host target information, causing confusing errors to occur. Don't do that. There are some minor breaking changes to std.Build API such as the fact that `b.zig_exe` is now moved to `b.graph.zig_exe`, as well as a handful of other similar flags.
2024-02-01 15:44:44 -07:00
std.debug.print(
\\unknown OS: '{s}'
\\available operating systems:
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
\\
, .{diags.os_name.?});
rename std.zig.CrossTarget to std.Target.Query
2023-12-04 12:35:04 -07:00
inline for (std.meta.fields(Target.Os.Tag)) |field| {
std.Build: implement --host-target, --host-cpu, --host-dynamic-linker This also makes a long-overdue change of extracting common state from Build into a shared Graph object. Getting the semantics right for these flags turned out to be quite tricky. In the end it works like this: * The override only happens when the target is fully native, with no additional query parameters, such as versions or CPU features added. * The override affects the resolved Target but leaves the original Query unmodified. * The "is native?" detection logic operates on the original, unmodified query. This makes it possible to provide invalid host target information, causing confusing errors to occur. Don't do that. There are some minor breaking changes to std.Build API such as the fact that `b.zig_exe` is now moved to `b.graph.zig_exe`, as well as a handful of other similar flags.
2024-02-01 15:44:44 -07:00
std.debug.print(" {s}\n", .{field.name});
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
std.Build: implement --host-target, --host-cpu, --host-dynamic-linker This also makes a long-overdue change of extracting common state from Build into a shared Graph object. Getting the semantics right for these flags turned out to be quite tricky. In the end it works like this: * The override only happens when the target is fully native, with no additional query parameters, such as versions or CPU features added. * The override affects the resolved Target but leaves the original Query unmodified. * The "is native?" detection logic operates on the original, unmodified query. This makes it possible to provide invalid host target information, causing confusing errors to occur. Don't do that. There are some minor breaking changes to std.Build API such as the fact that `b.zig_exe` is now moved to `b.graph.zig_exe`, as well as a handful of other similar flags.
2024-02-01 15:44:44 -07:00
return error.ParseFailed;
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
},
else => |e| {
std.Build: implement --host-target, --host-cpu, --host-dynamic-linker This also makes a long-overdue change of extracting common state from Build into a shared Graph object. Getting the semantics right for these flags turned out to be quite tricky. In the end it works like this: * The override only happens when the target is fully native, with no additional query parameters, such as versions or CPU features added. * The override affects the resolved Target but leaves the original Query unmodified. * The "is native?" detection logic operates on the original, unmodified query. This makes it possible to provide invalid host target information, causing confusing errors to occur. Don't do that. There are some minor breaking changes to std.Build API such as the fact that `b.zig_exe` is now moved to `b.graph.zig_exe`, as well as a handful of other similar flags.
2024-02-01 15:44:44 -07:00
std.debug.print("unable to parse target '{s}': {s}\n", .{
options.arch_os_abi, @errorName(e),
});
return error.ParseFailed;
},
};
}
/// Exposes standard `zig build` options for choosing a target.
pub fn standardTargetOptionsQueryOnly(b: *Build, args: StandardTargetOptionsArgs) Target.Query {
const maybe_triple = b.option(
[]const u8,
"target",
"The CPU architecture, OS, and ABI to build for",
);
const mcpu = b.option(
[]const u8,
"cpu",
"Target CPU features to add or subtract",
);
std.Build: Make ofmt part of standardTargetOptions().
2025-01-24 08:11:16 +01:00
const ofmt = b.option(
[]const u8,
"ofmt",
"Target object format",
);
std.Build: implement --host-target, --host-cpu, --host-dynamic-linker This also makes a long-overdue change of extracting common state from Build into a shared Graph object. Getting the semantics right for these flags turned out to be quite tricky. In the end it works like this: * The override only happens when the target is fully native, with no additional query parameters, such as versions or CPU features added. * The override affects the resolved Target but leaves the original Query unmodified. * The "is native?" detection logic operates on the original, unmodified query. This makes it possible to provide invalid host target information, causing confusing errors to occur. Don't do that. There are some minor breaking changes to std.Build API such as the fact that `b.zig_exe` is now moved to `b.graph.zig_exe`, as well as a handful of other similar flags.
2024-02-01 15:44:44 -07:00
const dynamic_linker = b.option(
[]const u8,
"dynamic-linker",
"Path to interpreter on the target system",
);
std.Build: Make ofmt part of standardTargetOptions().
2025-01-24 08:11:16 +01:00
if (maybe_triple == null and mcpu == null and ofmt == null and dynamic_linker == null)
std.Build: implement --host-target, --host-cpu, --host-dynamic-linker This also makes a long-overdue change of extracting common state from Build into a shared Graph object. Getting the semantics right for these flags turned out to be quite tricky. In the end it works like this: * The override only happens when the target is fully native, with no additional query parameters, such as versions or CPU features added. * The override affects the resolved Target but leaves the original Query unmodified. * The "is native?" detection logic operates on the original, unmodified query. This makes it possible to provide invalid host target information, causing confusing errors to occur. Don't do that. There are some minor breaking changes to std.Build API such as the fact that `b.zig_exe` is now moved to `b.graph.zig_exe`, as well as a handful of other similar flags.
2024-02-01 15:44:44 -07:00
return args.default_target;
const triple = maybe_triple orelse "native";
const selected_target = parseTargetQuery(.{
.arch_os_abi = triple,
.cpu_features = mcpu,
std.Build: Make ofmt part of standardTargetOptions().
2025-01-24 08:11:16 +01:00
.object_format = ofmt,
std.Build: implement --host-target, --host-cpu, --host-dynamic-linker This also makes a long-overdue change of extracting common state from Build into a shared Graph object. Getting the semantics right for these flags turned out to be quite tricky. In the end it works like this: * The override only happens when the target is fully native, with no additional query parameters, such as versions or CPU features added. * The override affects the resolved Target but leaves the original Query unmodified. * The "is native?" detection logic operates on the original, unmodified query. This makes it possible to provide invalid host target information, causing confusing errors to occur. Don't do that. There are some minor breaking changes to std.Build API such as the fact that `b.zig_exe` is now moved to `b.graph.zig_exe`, as well as a handful of other similar flags.
2024-02-01 15:44:44 -07:00
.dynamic_linker = dynamic_linker,
}) catch |err| switch (err) {
error.ParseFailed => {
std.Target.Query: remove deprecated API These functions have been doomed for a long time. Finally I figured out what the proper relationship between this API and std.Target is.
2023-12-04 20:30:32 -07:00
b.markInvalidUserInput();
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
return args.default_target;
},
};
std.Target.Query: remove deprecated API These functions have been doomed for a long time. Finally I figured out what the proper relationship between this API and std.Target is.
2023-12-04 20:30:32 -07:00
const whitelist = args.whitelist orelse return selected_target;
// Make sure it's a match of one of the list.
for (whitelist) |q| {
if (q.eql(selected_target))
return selected_target;
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
std.Target.Query: remove deprecated API These functions have been doomed for a long time. Finally I figured out what the proper relationship between this API and std.Target is.
2023-12-04 20:30:32 -07:00
for (whitelist) |q| {
log.info("allowed target: -Dtarget={s} -Dcpu={s}", .{
q.zigTriple(b.allocator) catch @panic("OOM"),
q.serializeCpuAlloc(b.allocator) catch @panic("OOM"),
});
}
log.err("chosen target '{s}' does not match one of the allowed targets", .{
selected_target.zigTriple(b.allocator) catch @panic("OOM"),
});
b.markInvalidUserInput();
return args.default_target;
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
std.Build: add more explicit error sets to some functions Signed-off-by: Eric Joldasov <bratishkaerik@landless-city.net>
2024-12-26 00:17:56 +05:00
pub fn addUserInputOption(b: *Build, name_raw: []const u8, value_raw: []const u8) error{OutOfMemory}!bool {
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
const name = b.dupe(name_raw);
const value = b.dupe(value_raw);
const gop = try b.user_input_options.getOrPut(name);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
if (!gop.found_existing) {
gop.value_ptr.* = UserInputOption{
.name = name,
.value = .{ .scalar = value },
.used = false,
};
return false;
}
// option already exists
switch (gop.value_ptr.value) {
.scalar => |s| {
// turn it into a list
std.ArrayList: make unmanaged the default
2025-07-31 21:54:07 -07:00
var list = std.array_list.Managed([]const u8).init(b.allocator);
std.Build: avoid use of catch unreachable Usage of `catch unreachable` in build scripts is completely harmless because build scripts are always run in Debug mode, however, it sets a poor example for beginners to learn from.
2023-01-31 14:02:32 -07:00
try list.append(s);
try list.append(value);
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
try b.user_input_options.put(name, .{
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
.name = name,
.value = .{ .list = list },
.used = false,
std.Build: avoid use of catch unreachable Usage of `catch unreachable` in build scripts is completely harmless because build scripts are always run in Debug mode, however, it sets a poor example for beginners to learn from.
2023-01-31 14:02:32 -07:00
});
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
},
.list => |*list| {
// append to the list
std.Build: avoid use of catch unreachable Usage of `catch unreachable` in build scripts is completely harmless because build scripts are always run in Debug mode, however, it sets a poor example for beginners to learn from.
2023-01-31 14:02:32 -07:00
try list.append(value);
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
try b.user_input_options.put(name, .{
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
.name = name,
.value = .{ .list = list.* },
.used = false,
std.Build: avoid use of catch unreachable Usage of `catch unreachable` in build scripts is completely harmless because build scripts are always run in Debug mode, however, it sets a poor example for beginners to learn from.
2023-01-31 14:02:32 -07:00
});
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
},
.flag => {
build system: introduce system library integration * New --help section * Add b.systemLibraryOption * Rework the build runner CLI logic a bit
2024-01-31 22:02:27 -07:00
log.warn("option '-D{s}={s}' conflicts with flag '-D{s}'.", .{ name, value, name });
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
return true;
},
.map => |*map| {
_ = map;
log.warn("TODO maps as command line arguments is not implemented yet.", .{});
return true;
},
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
.lazy_path, .lazy_path_list => {
std.fmt: breaking API changes added adapter to AnyWriter and GenericWriter to help bridge the gap between old and new API make std.testing.expectFmt work at compile-time std.fmt no longer has a dependency on std.unicode. Formatted printing was never properly unicode-aware. Now it no longer pretends to be. Breakage/deprecations: * std.fs.File.reader -> std.fs.File.deprecatedReader * std.fs.File.writer -> std.fs.File.deprecatedWriter * std.io.GenericReader -> std.io.Reader * std.io.GenericWriter -> std.io.Writer * std.io.AnyReader -> std.io.Reader * std.io.AnyWriter -> std.io.Writer * std.fmt.format -> std.fmt.deprecatedFormat * std.fmt.fmtSliceEscapeLower -> std.ascii.hexEscape * std.fmt.fmtSliceEscapeUpper -> std.ascii.hexEscape * std.fmt.fmtSliceHexLower -> {x} * std.fmt.fmtSliceHexUpper -> {X} * std.fmt.fmtIntSizeDec -> {B} * std.fmt.fmtIntSizeBin -> {Bi} * std.fmt.fmtDuration -> {D} * std.fmt.fmtDurationSigned -> {D} * {} -> {f} when there is a format method * format method signature - anytype -> *std.io.Writer - inferred error set -> error{WriteFailed} - options -> (deleted) * std.fmt.Formatted - now takes context type explicitly - no fmt string
2025-06-27 20:05:22 -07:00
log.warn("the lazy path value type isn't added from the CLI, but somehow '{s}' is a .{f}", .{ name, std.zig.fmtId(@tagName(gop.value_ptr.value)) });
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
return true;
},
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
return false;
}
std.Build: add more explicit error sets to some functions Signed-off-by: Eric Joldasov <bratishkaerik@landless-city.net>
2024-12-26 00:17:56 +05:00
pub fn addUserInputFlag(b: *Build, name_raw: []const u8) error{OutOfMemory}!bool {
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
const name = b.dupe(name_raw);
const gop = try b.user_input_options.getOrPut(name);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
if (!gop.found_existing) {
gop.value_ptr.* = .{
.name = name,
.value = .{ .flag = {} },
.used = false,
};
return false;
}
// option already exists
switch (gop.value_ptr.value) {
.scalar => |s| {
log.err("Flag '-D{s}' conflicts with option '-D{s}={s}'.", .{ name, name, s });
return true;
},
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
.list, .map, .lazy_path_list => {
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
log.err("Flag '-D{s}' conflicts with multiple options of the same name.", .{name});
return true;
},
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
.lazy_path => |lp| {
log.err("Flag '-D{s}' conflicts with option '-D{s}={s}'.", .{ name, name, lp.getDisplayName() });
return true;
},
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
.flag => {},
}
return false;
}
fn typeToEnum(comptime T: type) TypeId {
tweaks to --build-id * build.zig: the result of b.option() can be assigned directly in many cases thanks to the return type being an optional * std.Build: make the build system aware of the std.Build.Step.Compile.BuildId type when used as an option. - remove extraneous newlines in error logs * simplify caching logic * simplify hexstring parsing tests and use a doc test * simplify hashing logic. don't use an optional when the `none` tag already provides this meaning. * CLI: fix incorrect linker arg parsing
2023-05-16 20:00:47 -07:00
return switch (T) {
zig build system: change target, compilation, and module APIs Introduce the concept of "target query" and "resolved target". A target query is what the user specifies, with some things left to default. A resolved target has the default things discovered and populated. In the future, std.zig.CrossTarget will be rename to std.Target.Query. Introduces `std.Build.resolveTargetQuery` to get from one to the other. The concept of `main_mod_path` is gone, no longer supported. You have to put the root source file at the module root now. * remove deprecated API * update build.zig for the breaking API changes in this branch * move std.Build.Step.Compile.BuildId to std.zig.BuildId * add more options to std.Build.ExecutableOptions, std.Build.ObjectOptions, std.Build.SharedLibraryOptions, std.Build.StaticLibraryOptions, and std.Build.TestOptions. * remove `std.Build.constructCMacro`. There is no use for this API. * deprecate `std.Build.Step.Compile.defineCMacro`. Instead, `std.Build.Module.addCMacro` is provided. - remove `std.Build.Step.Compile.defineCMacroRaw`. * deprecate `std.Build.Step.Compile.linkFrameworkNeeded` - use `std.Build.Module.linkFramework` * deprecate `std.Build.Step.Compile.linkFrameworkWeak` - use `std.Build.Module.linkFramework` * move more logic into `std.Build.Module` * allow `target` and `optimize` to be `null` when creating a Module. Along with other fields, those unspecified options will be inherited from parent `Module` when inserted into an import table. * the `target` field of `addExecutable` is now required. pass `b.host` to get the host target.
2023-12-02 21:51:34 -07:00
std.zig.BuildId => .build_id,
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
LazyPath => .lazy_path,
tweaks to --build-id * build.zig: the result of b.option() can be assigned directly in many cases thanks to the return type being an optional * std.Build: make the build system aware of the std.Build.Step.Compile.BuildId type when used as an option. - remove extraneous newlines in error logs * simplify caching logic * simplify hexstring parsing tests and use a doc test * simplify hashing logic. don't use an optional when the `none` tag already provides this meaning. * CLI: fix incorrect linker arg parsing
2023-05-16 20:00:47 -07:00
else => return switch (@typeInfo(T)) {
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.int => .int,
.float => .float,
.bool => .bool,
.@"enum" => .@"enum",
.pointer => |pointer| switch (pointer.child) {
Add support for []enum in Build.option
2024-06-06 06:02:42 +02:00
u8 => .string,
[]const u8 => .list,
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
LazyPath => .lazy_path_list,
Add support for []enum in Build.option
2024-06-06 06:02:42 +02:00
else => switch (@typeInfo(pointer.child)) {
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.@"enum" => .enum_list,
Add support for []enum in Build.option
2024-06-06 06:02:42 +02:00
else => @compileError("Unsupported type: " ++ @typeName(T)),
},
tweaks to --build-id * build.zig: the result of b.option() can be assigned directly in many cases thanks to the return type being an optional * std.Build: make the build system aware of the std.Build.Step.Compile.BuildId type when used as an option. - remove extraneous newlines in error logs * simplify caching logic * simplify hexstring parsing tests and use a doc test * simplify hashing logic. don't use an optional when the `none` tag already provides this meaning. * CLI: fix incorrect linker arg parsing
2023-05-16 20:00:47 -07:00
},
Add support for []enum in Build.option
2024-06-06 06:02:42 +02:00
else => @compileError("Unsupported type: " ++ @typeName(T)),
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
},
};
}
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
fn markInvalidUserInput(b: *Build) void {
b.invalid_user_input = true;
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
build system: introduce system library integration * New --help section * Add b.systemLibraryOption * Rework the build runner CLI logic a bit
2024-01-31 22:02:27 -07:00
pub fn validateUserInputDidItFail(b: *Build) bool {
// Make sure all args are used.
var it = b.user_input_options.iterator();
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
while (it.next()) |entry| {
if (!entry.value_ptr.used) {
build system: introduce system library integration * New --help section * Add b.systemLibraryOption * Rework the build runner CLI logic a bit
2024-01-31 22:02:27 -07:00
log.err("invalid option: -D{s}", .{entry.key_ptr.*});
b.markInvalidUserInput();
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
}
build system: introduce system library integration * New --help section * Add b.systemLibraryOption * Rework the build runner CLI logic a bit
2024-01-31 22:02:27 -07:00
return b.invalid_user_input;
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
build system: follow-up enhancements regarding LazyPath * introduce LazyPath.cwd_relative variant and use it for --zig-lib-dir. closes #12685 * move overrideZigLibDir and setMainPkgPath to options fields set once and then never mutated. * avoid introducing Build/util.zig * use doc comments for deprecation notices so that they show up in generated documentation. * introduce InstallArtifact.Options, accept it as a parameter to addInstallArtifact, and move override_dest_dir into it. Instead of configuring the installation via Compile step, configure the installation via the InstallArtifact step. In retrospect this is obvious. * remove calls to pushInstalledFile in InstallArtifact. See #14943 * rewrite InstallArtifact to not incorrectly observe whether a Compile step has any generated outputs. InstallArtifact is meant to trigger output generation. * fix child process evaluation code handling of `-fno-emit-bin`. * don't store out_h_filename, out_ll_filename, etc., pointlessly. these are all just simple extensions appended to the root name. * make emit_directory optional. It's possible to have nothing outputted, for example, if you're just type-checking. * avoid passing -femit-foo/-fno-emit-foo when it is the default * rename ConfigHeader.getTemplate to getOutput * deprecate addOptionArtifact * update the random number seed of Options step caching. * avoid using `inline for` pointlessly * avoid using `override_Dest_dir` pointlessly * avoid emitting an executable pointlessly in test cases Removes forceBuild and forceEmit. Let's consider these additions separately. Nearly all of the usage sites were suspicious.
2023-07-29 23:57:52 -07:00
/// This creates the install step and adds it to the dependencies of the
/// top-level install step, using all the default options.
/// See `addInstallArtifact` for a more flexible function.
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
pub fn installArtifact(b: *Build, artifact: *Step.Compile) void {
b.getInstallStep().dependOn(&b.addInstallArtifact(artifact, .{}).step);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
build system: follow-up enhancements regarding LazyPath * introduce LazyPath.cwd_relative variant and use it for --zig-lib-dir. closes #12685 * move overrideZigLibDir and setMainPkgPath to options fields set once and then never mutated. * avoid introducing Build/util.zig * use doc comments for deprecation notices so that they show up in generated documentation. * introduce InstallArtifact.Options, accept it as a parameter to addInstallArtifact, and move override_dest_dir into it. Instead of configuring the installation via Compile step, configure the installation via the InstallArtifact step. In retrospect this is obvious. * remove calls to pushInstalledFile in InstallArtifact. See #14943 * rewrite InstallArtifact to not incorrectly observe whether a Compile step has any generated outputs. InstallArtifact is meant to trigger output generation. * fix child process evaluation code handling of `-fno-emit-bin`. * don't store out_h_filename, out_ll_filename, etc., pointlessly. these are all just simple extensions appended to the root name. * make emit_directory optional. It's possible to have nothing outputted, for example, if you're just type-checking. * avoid passing -femit-foo/-fno-emit-foo when it is the default * rename ConfigHeader.getTemplate to getOutput * deprecate addOptionArtifact * update the random number seed of Options step caching. * avoid using `inline for` pointlessly * avoid using `override_Dest_dir` pointlessly * avoid emitting an executable pointlessly in test cases Removes forceBuild and forceEmit. Let's consider these additions separately. Nearly all of the usage sites were suspicious.
2023-07-29 23:57:52 -07:00
/// This merely creates the step; it does not add it to the dependencies of the
/// top-level install step.
pub fn addInstallArtifact(
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
b: *Build,
build system: follow-up enhancements regarding LazyPath * introduce LazyPath.cwd_relative variant and use it for --zig-lib-dir. closes #12685 * move overrideZigLibDir and setMainPkgPath to options fields set once and then never mutated. * avoid introducing Build/util.zig * use doc comments for deprecation notices so that they show up in generated documentation. * introduce InstallArtifact.Options, accept it as a parameter to addInstallArtifact, and move override_dest_dir into it. Instead of configuring the installation via Compile step, configure the installation via the InstallArtifact step. In retrospect this is obvious. * remove calls to pushInstalledFile in InstallArtifact. See #14943 * rewrite InstallArtifact to not incorrectly observe whether a Compile step has any generated outputs. InstallArtifact is meant to trigger output generation. * fix child process evaluation code handling of `-fno-emit-bin`. * don't store out_h_filename, out_ll_filename, etc., pointlessly. these are all just simple extensions appended to the root name. * make emit_directory optional. It's possible to have nothing outputted, for example, if you're just type-checking. * avoid passing -femit-foo/-fno-emit-foo when it is the default * rename ConfigHeader.getTemplate to getOutput * deprecate addOptionArtifact * update the random number seed of Options step caching. * avoid using `inline for` pointlessly * avoid using `override_Dest_dir` pointlessly * avoid emitting an executable pointlessly in test cases Removes forceBuild and forceEmit. Let's consider these additions separately. Nearly all of the usage sites were suspicious.
2023-07-29 23:57:52 -07:00
artifact: *Step.Compile,
options: Step.InstallArtifact.Options,
) *Step.InstallArtifact {
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
return Step.InstallArtifact.create(b, artifact, options);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
///`dest_rel_path` is relative to prefix path
remove deprecated LazyPath.path union tag
2024-04-11 14:02:47 -07:00
pub fn installFile(b: *Build, src_path: []const u8, dest_rel_path: []const u8) void {
b.getInstallStep().dependOn(&b.addInstallFileWithDir(b.path(src_path), .prefix, dest_rel_path).step);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
remove deprecated LazyPath.path union tag
2024-04-11 14:02:47 -07:00
pub fn installDirectory(b: *Build, options: Step.InstallDir.Options) void {
b.getInstallStep().dependOn(&b.addInstallDirectory(options).step);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
///`dest_rel_path` is relative to bin path
remove deprecated LazyPath.path union tag
2024-04-11 14:02:47 -07:00
pub fn installBinFile(b: *Build, src_path: []const u8, dest_rel_path: []const u8) void {
b.getInstallStep().dependOn(&b.addInstallFileWithDir(b.path(src_path), .bin, dest_rel_path).step);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
///`dest_rel_path` is relative to lib path
remove deprecated LazyPath.path union tag
2024-04-11 14:02:47 -07:00
pub fn installLibFile(b: *Build, src_path: []const u8, dest_rel_path: []const u8) void {
b.getInstallStep().dependOn(&b.addInstallFileWithDir(b.path(src_path), .lib, dest_rel_path).step);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
Build.zig rename orgy (aka: #16353). Renames FileSource to LazyPath and removes functions that take literal paths instead of LazyPath.
2023-07-19 10:49:34 +02:00
pub fn addObjCopy(b: *Build, source: LazyPath, options: Step.ObjCopy.Options) *Step.ObjCopy {
std.Build: use Step.* instead of *Step Follow up to 13eb7251d37759bd47403db304c6120c706fe353
2023-05-03 11:49:55 +03:00
return Step.ObjCopy.create(b, source, options);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
Document added/updated functions Also renames `addHeaders` to `addHeadersDirectory` for clarity.
2024-03-10 12:17:33 +01:00
/// `dest_rel_path` is relative to install prefix path
Update `addInstallHeaderFile` to take a `LazyPath`
2024-03-02 23:32:44 +01:00
pub fn addInstallFile(b: *Build, source: LazyPath, dest_rel_path: []const u8) *Step.InstallFile {
return b.addInstallFileWithDir(source, .prefix, dest_rel_path);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
Document added/updated functions Also renames `addHeaders` to `addHeadersDirectory` for clarity.
2024-03-10 12:17:33 +01:00
/// `dest_rel_path` is relative to bin path
Update `addInstallHeaderFile` to take a `LazyPath`
2024-03-02 23:32:44 +01:00
pub fn addInstallBinFile(b: *Build, source: LazyPath, dest_rel_path: []const u8) *Step.InstallFile {
return b.addInstallFileWithDir(source, .bin, dest_rel_path);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
Document added/updated functions Also renames `addHeaders` to `addHeadersDirectory` for clarity.
2024-03-10 12:17:33 +01:00
/// `dest_rel_path` is relative to lib path
Update `addInstallHeaderFile` to take a `LazyPath`
2024-03-02 23:32:44 +01:00
pub fn addInstallLibFile(b: *Build, source: LazyPath, dest_rel_path: []const u8) *Step.InstallFile {
return b.addInstallFileWithDir(source, .lib, dest_rel_path);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
Document added/updated functions Also renames `addHeaders` to `addHeadersDirectory` for clarity.
2024-03-10 12:17:33 +01:00
/// `dest_rel_path` is relative to header path
Update `addInstallHeaderFile` to take a `LazyPath`
2024-03-02 23:32:44 +01:00
pub fn addInstallHeaderFile(b: *Build, source: LazyPath, dest_rel_path: []const u8) *Step.InstallFile {
return b.addInstallFileWithDir(source, .header, dest_rel_path);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
pub fn addInstallFileWithDir(
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
b: *Build,
Build.zig rename orgy (aka: #16353). Renames FileSource to LazyPath and removes functions that take literal paths instead of LazyPath.
2023-07-19 10:49:34 +02:00
source: LazyPath,
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
install_dir: InstallDir,
dest_rel_path: []const u8,
std.Build: use Step.* instead of *Step Follow up to 13eb7251d37759bd47403db304c6120c706fe353
2023-05-03 11:49:55 +03:00
) *Step.InstallFile {
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
return Step.InstallFile.create(b, source, install_dir, dest_rel_path);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
pub fn addInstallDirectory(b: *Build, options: Step.InstallDir.Options) *Step.InstallDir {
return Step.InstallDir.create(b, options);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
re-enable CLI tests CLI tests are now ported over to the new std.Build API and thus work properly with concurrency. * add `std.Build.addCheckFile` for creating a `std.Build.CheckFileStep`. * add `std.Build.makeTempPath`. This function is intended to be called in the `configure` phase only. It returns an absolute directory path, which is potentially going to be a source of API breakage in the future, so keep that in mind when using this function. * add `std.Build.CheckFileStep.setName`. * `std.Build.CheckFileStep`: better error message when reading the input file fails. * `std.Build.RunStep`: add a `has_side_effects` flag for when you need to override the autodetection. * `std.Build.RunStep`: add the ability to obtain a FileSource for the directory that contains the written files. * `std.Build.WriteFileStep`: add a way to write bytes to an arbitrary path - absolute or relative to the package root. Be careful with this because it updates source files. This should not be used as part of the normal build process, but as a utility occasionally run by a developer with intent to modify source files and then commit those changes to version control. A file added this way is not available with `getFileSource`.
2023-03-06 22:44:36 -07:00
pub fn addCheckFile(
b: *Build,
Build.zig rename orgy (aka: #16353). Renames FileSource to LazyPath and removes functions that take literal paths instead of LazyPath.
2023-07-19 10:49:34 +02:00
file_source: LazyPath,
std.Build: use Step.* instead of *Step Follow up to 13eb7251d37759bd47403db304c6120c706fe353
2023-05-03 11:49:55 +03:00
options: Step.CheckFile.Options,
) *Step.CheckFile {
return Step.CheckFile.create(b, file_source, options);
re-enable CLI tests CLI tests are now ported over to the new std.Build API and thus work properly with concurrency. * add `std.Build.addCheckFile` for creating a `std.Build.CheckFileStep`. * add `std.Build.makeTempPath`. This function is intended to be called in the `configure` phase only. It returns an absolute directory path, which is potentially going to be a source of API breakage in the future, so keep that in mind when using this function. * add `std.Build.CheckFileStep.setName`. * `std.Build.CheckFileStep`: better error message when reading the input file fails. * `std.Build.RunStep`: add a `has_side_effects` flag for when you need to override the autodetection. * `std.Build.RunStep`: add the ability to obtain a FileSource for the directory that contains the written files. * `std.Build.WriteFileStep`: add a way to write bytes to an arbitrary path - absolute or relative to the package root. Be careful with this because it updates source files. This should not be used as part of the normal build process, but as a utility occasionally run by a developer with intent to modify source files and then commit those changes to version control. A file added this way is not available with `getFileSource`.
2023-03-06 22:44:36 -07:00
}
std.Build: add more explicit error sets to some functions Signed-off-by: Eric Joldasov <bratishkaerik@landless-city.net>
2024-12-26 00:17:56 +05:00
pub fn truncateFile(b: *Build, dest_path: []const u8) (fs.Dir.MakeError || fs.Dir.StatFileError)!void {
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
if (b.verbose) {
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
log.info("truncate {s}", .{dest_path});
}
const cwd = fs.cwd();
var src_file = cwd.createFile(dest_path, .{}) catch |err| switch (err) {
error.FileNotFound => blk: {
if (fs.path.dirname(dest_path)) |dirname| {
try cwd.makePath(dirname);
}
break :blk try cwd.createFile(dest_path, .{});
},
else => |e| return e,
};
src_file.close();
}
introduce std.Build.path; deprecate LazyPath.relative This adds the *std.Build owner to LazyPath so that lazy paths returned from a dependency can be used in the application without friction or footguns. closes #19313
2024-04-09 18:23:48 -07:00
/// References a file or directory relative to the source root.
pub fn path(b: *Build, sub_path: []const u8) LazyPath {
remove deprecated LazyPath.path union tag
2024-04-11 14:02:47 -07:00
if (fs.path.isAbsolute(sub_path)) {
std.debug.panic("sub_path is expected to be relative to the build root, but was this absolute path: '{s}'. It is best avoid absolute paths, but if you must, it is supported by LazyPath.cwd_relative", .{
sub_path,
});
}
introduce std.Build.path; deprecate LazyPath.relative This adds the *std.Build owner to LazyPath so that lazy paths returned from a dependency can be used in the application without friction or footguns. closes #19313
2024-04-09 18:23:48 -07:00
return .{ .src_path = .{
.owner = b,
.sub_path = sub_path,
} };
}
/// This is low-level implementation details of the build system, not meant to
/// be called by users' build scripts. Even in the build system itself it is a
/// code smell to call this function.
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
pub fn pathFromRoot(b: *Build, sub_path: []const u8) []u8 {
return b.pathResolve(&.{ b.build_root.path orelse ".", sub_path });
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
fn pathFromCwd(b: *Build, sub_path: []const u8) []u8 {
std.Build.LazyPath: fix resolution of cwd_relative The callsites of getPath rely on the result being absolute so that they can pass the path to a child process with the cwd set to the build root.
2023-07-30 18:19:39 -07:00
const cwd = process.getCwdAlloc(b.allocator) catch @panic("OOM");
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
return b.pathResolve(&.{ cwd, sub_path });
std.Build.LazyPath: fix resolution of cwd_relative The callsites of getPath rely on the result being absolute so that they can pass the path to a child process with the cwd set to the build root.
2023-07-30 18:19:39 -07:00
}
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
pub fn pathJoin(b: *Build, paths: []const []const u8) []u8 {
return fs.path.join(b.allocator, paths) catch @panic("OOM");
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
pub fn pathResolve(b: *Build, paths: []const []const u8) []u8 {
return fs.path.resolve(b.allocator, paths) catch @panic("OOM");
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
pub fn fmt(b: *Build, comptime format: []const u8, args: anytype) []u8 {
return std.fmt.allocPrint(b.allocator, format, args) catch @panic("OOM");
}
std.Build.findProgram(): Try with and without the Windows executable extensions. I renamed std.process.Child.CreateProcessSupportedExtension to WindowsExtension and made it public to avoid duplicating the list of extensions. While here, I also improved it to not misreport OOM from std.fs.realpathAlloc() as a generic failure to find the program, but instead panic like the rest of the build system does for OOM. Closes #20314.
2024-06-18 07:08:12 +02:00
fn supportedWindowsProgramExtension(ext: []const u8) bool {
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
inline for (@typeInfo(std.process.Child.WindowsExtension).@"enum".fields) |field| {
std.Build.findProgram(): Try with and without the Windows executable extensions. I renamed std.process.Child.CreateProcessSupportedExtension to WindowsExtension and made it public to avoid duplicating the list of extensions. While here, I also improved it to not misreport OOM from std.fs.realpathAlloc() as a generic failure to find the program, but instead panic like the rest of the build system does for OOM. Closes #20314.
2024-06-18 07:08:12 +02:00
if (std.ascii.eqlIgnoreCase(ext, "." ++ field.name)) return true;
}
return false;
}
fn tryFindProgram(b: *Build, full_path: []const u8) ?[]const u8 {
if (fs.realpathAlloc(b.allocator, full_path)) |p| {
return p;
} else |err| switch (err) {
error.OutOfMemory => @panic("OOM"),
else => {},
}
if (builtin.os.tag == .windows) {
if (b.graph.env_map.get("PATHEXT")) |PATHEXT| {
var it = mem.tokenizeScalar(u8, PATHEXT, fs.path.delimiter);
while (it.next()) |ext| {
if (!supportedWindowsProgramExtension(ext)) continue;
return fs.realpathAlloc(b.allocator, b.fmt("{s}{s}", .{ full_path, ext })) catch |err| switch (err) {
error.OutOfMemory => @panic("OOM"),
else => continue,
};
}
}
}
return null;
}
std.Build: add more explicit error sets to some functions Signed-off-by: Eric Joldasov <bratishkaerik@landless-city.net>
2024-12-26 00:17:56 +05:00
pub fn findProgram(b: *Build, names: []const []const u8, paths: []const []const u8) error{FileNotFound}![]const u8 {
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
// TODO report error for ambiguous situations
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
for (b.search_prefixes.items) |search_prefix| {
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
for (names) |name| {
if (fs.path.isAbsolute(name)) {
return name;
}
std.Build.findProgram(): Try with and without the Windows executable extensions. I renamed std.process.Child.CreateProcessSupportedExtension to WindowsExtension and made it public to avoid duplicating the list of extensions. While here, I also improved it to not misreport OOM from std.fs.realpathAlloc() as a generic failure to find the program, but instead panic like the rest of the build system does for OOM. Closes #20314.
2024-06-18 07:08:12 +02:00
return tryFindProgram(b, b.pathJoin(&.{ search_prefix, "bin", name })) orelse continue;
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
}
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
if (b.graph.env_map.get("PATH")) |PATH| {
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
for (names) |name| {
if (fs.path.isAbsolute(name)) {
return name;
}
Update all std.mem.tokenize calls to their appropriate function Everywhere that can now use `tokenizeScalar` should get a nice little performance boost.
2023-05-04 18:05:40 -07:00
var it = mem.tokenizeScalar(u8, PATH, fs.path.delimiter);
introduce std.Build.path; deprecate LazyPath.relative This adds the *std.Build owner to LazyPath so that lazy paths returned from a dependency can be used in the application without friction or footguns. closes #19313
2024-04-09 18:23:48 -07:00
while (it.next()) |p| {
std.Build.findProgram(): Try with and without the Windows executable extensions. I renamed std.process.Child.CreateProcessSupportedExtension to WindowsExtension and made it public to avoid duplicating the list of extensions. While here, I also improved it to not misreport OOM from std.fs.realpathAlloc() as a generic failure to find the program, but instead panic like the rest of the build system does for OOM. Closes #20314.
2024-06-18 07:08:12 +02:00
return tryFindProgram(b, b.pathJoin(&.{ p, name })) orelse continue;
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
}
}
for (names) |name| {
if (fs.path.isAbsolute(name)) {
return name;
}
introduce std.Build.path; deprecate LazyPath.relative This adds the *std.Build owner to LazyPath so that lazy paths returned from a dependency can be used in the application without friction or footguns. closes #19313
2024-04-09 18:23:48 -07:00
for (paths) |p| {
std.Build.findProgram(): Try with and without the Windows executable extensions. I renamed std.process.Child.CreateProcessSupportedExtension to WindowsExtension and made it public to avoid duplicating the list of extensions. While here, I also improved it to not misreport OOM from std.fs.realpathAlloc() as a generic failure to find the program, but instead panic like the rest of the build system does for OOM. Closes #20314.
2024-06-18 07:08:12 +02:00
return tryFindProgram(b, b.pathJoin(&.{ p, name })) orelse continue;
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
}
return error.FileNotFound;
}
child_process + Build: rename exec to run + all related code Justification: exec, execv etc are unix concepts and portable version should be called differently. Do no touch non-Zig code. Adjust error names as well, if associated. Closes #5853.
2023-10-19 22:36:11 +02:00
pub fn runAllowFail(
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
b: *Build,
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
argv: []const []const u8,
out_code: *u8,
std: restructure child process namespace
2024-05-23 11:25:41 -07:00
stderr_behavior: std.process.Child.StdIo,
child_process + Build: rename exec to run + all related code Justification: exec, execv etc are unix concepts and portable version should be called differently. Do no touch non-Zig code. Adjust error names as well, if associated. Closes #5853.
2023-10-19 22:36:11 +02:00
) RunError![]u8 {
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
assert(argv.len != 0);
std.Build: improve debugging of misconfigured steps * Step.init() now takes an options struct * Step.init() now captures a small stack trace and stores it in the Step so that it can be accessed when printing user-friendly debugging information, including the lines of code that created the step in question.
2023-02-14 12:47:45 -07:00
if (!process.can_spawn)
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
return error.ExecNotSupported;
std: updating to std.Io interface got the build runner compiling
2025-10-07 22:31:06 -07:00
const io = b.graph.io;
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
const max_output_size = 400 * 1024;
std: restructure child process namespace
2024-05-23 11:25:41 -07:00
var child = std.process.Child.init(argv, b.allocator);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
child.stdin_behavior = .Ignore;
child.stdout_behavior = .Pipe;
child.stderr_behavior = stderr_behavior;
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
child.env_map = &b.graph.env_map;
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
fix merge conflict from previous commit
2024-08-23 21:46:36 -07:00
try Step.handleVerbose2(b, null, child.env_map, argv);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
try child.spawn();
std: updating to std.Io interface got the build runner compiling
2025-10-07 22:31:06 -07:00
var stdout_reader = child.stdout.?.readerStreaming(io, &.{});
std.Io: delete GenericReader and delete deprecated alias std.io
2025-08-27 21:20:18 -07:00
const stdout = stdout_reader.interface.allocRemaining(b.allocator, .limited(max_output_size)) catch {
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
return error.ReadFailure;
};
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
errdefer b.allocator.free(stdout);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
const term = try child.wait();
switch (term) {
.Exited => |code| {
if (code != 0) {
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
out_code.* = @as(u8, @truncate(code));
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
return error.ExitCodeFailure;
}
return stdout;
},
.Signal, .Stopped, .Unknown => |code| {
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
out_code.* = @as(u8, @truncate(code));
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
return error.ProcessTerminated;
},
}
}
build system: capture stderr and report it later Instead of dumping directly to stderr. This prevents processes running simultaneously from racing their stderr against each other. For now it only reports at the end, but an improvement would be to report as soon as a failed step occurs.
2023-02-14 02:53:05 -07:00
/// This is a helper function to be called from build.zig scripts, *not* from
/// inside step make() functions. If any errors occur, it fails the build with
/// a helpful message.
child_process + Build: rename exec to run + all related code Justification: exec, execv etc are unix concepts and portable version should be called differently. Do no touch non-Zig code. Adjust error names as well, if associated. Closes #5853.
2023-10-19 22:36:11 +02:00
pub fn run(b: *Build, argv: []const []const u8) []u8 {
std.Build: improve debugging of misconfigured steps * Step.init() now takes an options struct * Step.init() now captures a small stack trace and stores it in the Step so that it can be accessed when printing user-friendly debugging information, including the lines of code that created the step in question.
2023-02-14 12:47:45 -07:00
if (!process.can_spawn) {
std.Build.CompileStep: obtain the build output dir from protocol Now building successfully works again.
2023-02-28 17:15:06 -07:00
std.debug.print("unable to spawn the following command: cannot spawn child process\n{s}\n", .{
std.Build: separate errors from failed commands Recording the command in a separate field will give the build runner more freedom to choose how and when the command should be printed.
2025-08-26 16:28:42 +01:00
try Step.allocPrintCmd(b.allocator, null, argv),
build system: capture stderr and report it later Instead of dumping directly to stderr. This prevents processes running simultaneously from racing their stderr against each other. For now it only reports at the end, but an improvement would be to report as soon as a failed step occurs.
2023-02-14 02:53:05 -07:00
});
process.exit(1);
}
var code: u8 = undefined;
child_process + Build: rename exec to run + all related code Justification: exec, execv etc are unix concepts and portable version should be called differently. Do no touch non-Zig code. Adjust error names as well, if associated. Closes #5853.
2023-10-19 22:36:11 +02:00
return b.runAllowFail(argv, &code, .Inherit) catch |err| {
std.Build: separate errors from failed commands Recording the command in a separate field will give the build runner more freedom to choose how and when the command should be printed.
2025-08-26 16:28:42 +01:00
const printed_cmd = Step.allocPrintCmd(b.allocator, null, argv) catch @panic("OOM");
std.Build.CompileStep: obtain the build output dir from protocol Now building successfully works again.
2023-02-28 17:15:06 -07:00
std.debug.print("unable to spawn the following command: {s}\n{s}\n", .{
build system: capture stderr and report it later Instead of dumping directly to stderr. This prevents processes running simultaneously from racing their stderr against each other. For now it only reports at the end, but an improvement would be to report as soon as a failed step occurs.
2023-02-14 02:53:05 -07:00
@errorName(err), printed_cmd,
});
process.exit(1);
};
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
std.Build: implement --host-target, --host-cpu, --host-dynamic-linker This also makes a long-overdue change of extracting common state from Build into a shared Graph object. Getting the semantics right for these flags turned out to be quite tricky. In the end it works like this: * The override only happens when the target is fully native, with no additional query parameters, such as versions or CPU features added. * The override affects the resolved Target but leaves the original Query unmodified. * The "is native?" detection logic operates on the original, unmodified query. This makes it possible to provide invalid host target information, causing confusing errors to occur. Don't do that. There are some minor breaking changes to std.Build API such as the fact that `b.zig_exe` is now moved to `b.graph.zig_exe`, as well as a handful of other similar flags.
2024-02-01 15:44:44 -07:00
pub fn addSearchPrefix(b: *Build, search_prefix: []const u8) void {
b.search_prefixes.append(b.allocator, b.dupePath(search_prefix)) catch @panic("OOM");
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
pub fn getInstallPath(b: *Build, dir: InstallDir, dest_rel_path: []const u8) []const u8 {
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
assert(!fs.path.isAbsolute(dest_rel_path)); // Install paths must be relative to the prefix
const base_dir = switch (dir) {
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
.prefix => b.install_path,
.bin => b.exe_dir,
.lib => b.lib_dir,
.header => b.h_dir,
.custom => |p| b.pathJoin(&.{ b.install_path, p }),
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
};
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
return b.pathResolve(&.{ base_dir, dest_rel_path });
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
pub const Dependency = struct {
builder: *Build,
std.Build: use Step.* instead of *Step Follow up to 13eb7251d37759bd47403db304c6120c706fe353
2023-05-03 11:49:55 +03:00
pub fn artifact(d: *Dependency, name: []const u8) *Step.Compile {
var found: ?*Step.Compile = null;
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
for (d.builder.install_tls.step.dependencies.items) |dep_step| {
std.Build: use Step.* instead of *Step Follow up to 13eb7251d37759bd47403db304c6120c706fe353
2023-05-03 11:49:55 +03:00
const inst = dep_step.cast(Step.InstallArtifact) orelse continue;
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
if (mem.eql(u8, inst.artifact.name, name)) {
if (found != null) panic("artifact name '{s}' is ambiguous", .{name});
found = inst.artifact;
}
}
return found orelse {
for (d.builder.install_tls.step.dependencies.items) |dep_step| {
std.Build: use Step.* instead of *Step Follow up to 13eb7251d37759bd47403db304c6120c706fe353
2023-05-03 11:49:55 +03:00
const inst = dep_step.cast(Step.InstallArtifact) orelse continue;
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
log.info("available artifact: '{s}'", .{inst.artifact.name});
}
panic("unable to find artifact '{s}'", .{name});
};
}
std.Build: support exposing and depending on zig modules New API introduced: std.Build.addModule This function exposes a zig module with the given name, which can be used by packages that depend on this one via std.Build.Dependency.module. std.Build.Pkg and related functionality is deleted. Every use case has a straightforward upgrade path using the new Module struct. std.Build.OptionsStep.getPackage is replaced by std.Build.OptionsStep.createModule. std.Build.CompileStep.addPackagePath is replaced by std.Build.CompileStep.addAnonymousModule. This partially addresses #14307 by renaming some of the instances of "package" to "module". Closes #14278
2023-02-03 17:22:31 -07:00
pub fn module(d: *Dependency, name: []const u8) *Module {
return d.builder.modules.get(name) orelse {
panic("unable to find module '{s}'", .{name});
};
}
Support non zig dependencies Dependencies no longer require a build.zig file. Adds path function to Dependency struct which returns a LazyPath into a dependency.
2023-09-17 19:38:19 +02:00
Build: add namedWriteFiles to Build
2023-10-22 16:10:01 +02:00
pub fn namedWriteFiles(d: *Dependency, name: []const u8) *Step.WriteFile {
return d.builder.named_writefiles.get(name) orelse {
panic("unable to find named writefiles '{s}'", .{name});
};
}
std.Build: allow packages to expose arbitrary LazyPaths by name
2024-09-11 09:06:54 +01:00
pub fn namedLazyPath(d: *Dependency, name: []const u8) LazyPath {
return d.builder.named_lazy_paths.get(name) orelse {
panic("unable to find named lazypath '{s}'", .{name});
};
}
Support non zig dependencies Dependencies no longer require a build.zig file. Adds path function to Dependency struct which returns a LazyPath into a dependency.
2023-09-17 19:38:19 +02:00
pub fn path(d: *Dependency, sub_path: []const u8) LazyPath {
return .{
.dependency = .{
.dependency = d,
.sub_path = sub_path,
},
};
}
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
};
build system: implement lazy dependencies, part 1 Build manifest files support `lazy: true` for dependency sections. This causes the auto-generated dependencies.zig to have 2 more possibilities: 1. It communicates whether a dependency is lazy or not. 2. The dependency might be acknowledged, but missing due to being lazy and not fetched. Lazy dependencies are not fetched by default, but if they are already fetched then they are provided to the build script. The build runner reports the set of missing lazy dependenices that are required to the parent process via stdout and indicates the situation with exit code 3. std.Build now has a `lazyDependency` function. I'll let the doc comments speak for themselves: When this function is called, it means that the current build does, in fact, require this dependency. If the dependency is already fetched, it proceeds in the same manner as `dependency`. However if the dependency was not fetched, then when the build script is finished running, the build will not proceed to the make phase. Instead, the parent process will additionally fetch all the lazy dependencies that were actually required by running the build script, rebuild the build script, and then run it again. In other words, if this function returns `null` it means that the only purpose of completing the configure phase is to find out all the other lazy dependencies that are also required. It is allowed to use this function for non-lazy dependencies, in which case it will never return `null`. This allows toggling laziness via build.zig.zon without changing build.zig logic. The CLI for `zig build` detects this situation, but the logic for then redoing the build process with these extra dependencies fetched is not yet implemented.
2024-02-02 14:42:29 -07:00
fn findPkgHashOrFatal(b: *Build, name: []const u8) []const u8 {
for (b.available_deps) |dep| {
if (mem.eql(u8, dep[0], name)) return dep[1];
}
const full_path = b.pathFromRoot("build.zig.zon");
std.debug.panic("no dependency named '{s}' in '{s}'. All packages used in build.zig must be declared in this file", .{ name, full_path });
}
std.Build: add `lazyImport` (`@import` for lazy dependencies)
2024-02-18 19:56:34 +01:00
inline fn findImportPkgHashOrFatal(b: *Build, comptime asking_build_zig: type, comptime dep_name: []const u8) []const u8 {
const build_runner = @import("root");
const deps = build_runner.dependencies;
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
const b_pkg_hash, const b_pkg_deps = comptime for (@typeInfo(deps.packages).@"struct".decls) |decl| {
std.Build: add `lazyImport` (`@import` for lazy dependencies)
2024-02-18 19:56:34 +01:00
const pkg_hash = decl.name;
const pkg = @field(deps.packages, pkg_hash);
if (@hasDecl(pkg, "build_zig") and pkg.build_zig == asking_build_zig) break .{ pkg_hash, pkg.deps };
} else .{ "", deps.root_deps };
if (!std.mem.eql(u8, b_pkg_hash, b.pkg_hash)) {
std.debug.panic("'{}' is not the struct that corresponds to '{s}'", .{ asking_build_zig, b.pathFromRoot("build.zig") });
}
comptime for (b_pkg_deps) |dep| {
if (std.mem.eql(u8, dep[0], dep_name)) return dep[1];
};
const full_path = b.pathFromRoot("build.zig.zon");
std.debug.panic("no dependency named '{s}' in '{s}'. All packages used in build.zig must be declared in this file", .{ dep_name, full_path });
}
build system: implement lazy dependencies, part 1 Build manifest files support `lazy: true` for dependency sections. This causes the auto-generated dependencies.zig to have 2 more possibilities: 1. It communicates whether a dependency is lazy or not. 2. The dependency might be acknowledged, but missing due to being lazy and not fetched. Lazy dependencies are not fetched by default, but if they are already fetched then they are provided to the build script. The build runner reports the set of missing lazy dependenices that are required to the parent process via stdout and indicates the situation with exit code 3. std.Build now has a `lazyDependency` function. I'll let the doc comments speak for themselves: When this function is called, it means that the current build does, in fact, require this dependency. If the dependency is already fetched, it proceeds in the same manner as `dependency`. However if the dependency was not fetched, then when the build script is finished running, the build will not proceed to the make phase. Instead, the parent process will additionally fetch all the lazy dependencies that were actually required by running the build script, rebuild the build script, and then run it again. In other words, if this function returns `null` it means that the only purpose of completing the configure phase is to find out all the other lazy dependencies that are also required. It is allowed to use this function for non-lazy dependencies, in which case it will never return `null`. This allows toggling laziness via build.zig.zon without changing build.zig logic. The CLI for `zig build` detects this situation, but the logic for then redoing the build process with these extra dependencies fetched is not yet implemented.
2024-02-02 14:42:29 -07:00
fn markNeededLazyDep(b: *Build, pkg_hash: []const u8) void {
b.graph.needed_lazy_dependencies.put(b.graph.arena, pkg_hash, {}) catch @panic("OOM");
}
/// When this function is called, it means that the current build does, in
/// fact, require this dependency. If the dependency is already fetched, it
/// proceeds in the same manner as `dependency`. However if the dependency was
/// not fetched, then when the build script is finished running, the build will
/// not proceed to the make phase. Instead, the parent process will
/// additionally fetch all the lazy dependencies that were actually required by
/// running the build script, rebuild the build script, and then run it again.
/// In other words, if this function returns `null` it means that the only
/// purpose of completing the configure phase is to find out all the other lazy
/// dependencies that are also required.
/// It is allowed to use this function for non-lazy dependencies, in which case
/// it will never return `null`. This allows toggling laziness via
/// build.zig.zon without changing build.zig logic.
pub fn lazyDependency(b: *Build, name: []const u8, args: anytype) ?*Dependency {
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
const build_runner = @import("root");
const deps = build_runner.dependencies;
build system: implement lazy dependencies, part 1 Build manifest files support `lazy: true` for dependency sections. This causes the auto-generated dependencies.zig to have 2 more possibilities: 1. It communicates whether a dependency is lazy or not. 2. The dependency might be acknowledged, but missing due to being lazy and not fetched. Lazy dependencies are not fetched by default, but if they are already fetched then they are provided to the build script. The build runner reports the set of missing lazy dependenices that are required to the parent process via stdout and indicates the situation with exit code 3. std.Build now has a `lazyDependency` function. I'll let the doc comments speak for themselves: When this function is called, it means that the current build does, in fact, require this dependency. If the dependency is already fetched, it proceeds in the same manner as `dependency`. However if the dependency was not fetched, then when the build script is finished running, the build will not proceed to the make phase. Instead, the parent process will additionally fetch all the lazy dependencies that were actually required by running the build script, rebuild the build script, and then run it again. In other words, if this function returns `null` it means that the only purpose of completing the configure phase is to find out all the other lazy dependencies that are also required. It is allowed to use this function for non-lazy dependencies, in which case it will never return `null`. This allows toggling laziness via build.zig.zon without changing build.zig logic. The CLI for `zig build` detects this situation, but the logic for then redoing the build process with these extra dependencies fetched is not yet implemented.
2024-02-02 14:42:29 -07:00
const pkg_hash = findPkgHashOrFatal(b, name);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
inline for (@typeInfo(deps.packages).@"struct".decls) |decl| {
build system: implement lazy dependencies, part 1 Build manifest files support `lazy: true` for dependency sections. This causes the auto-generated dependencies.zig to have 2 more possibilities: 1. It communicates whether a dependency is lazy or not. 2. The dependency might be acknowledged, but missing due to being lazy and not fetched. Lazy dependencies are not fetched by default, but if they are already fetched then they are provided to the build script. The build runner reports the set of missing lazy dependenices that are required to the parent process via stdout and indicates the situation with exit code 3. std.Build now has a `lazyDependency` function. I'll let the doc comments speak for themselves: When this function is called, it means that the current build does, in fact, require this dependency. If the dependency is already fetched, it proceeds in the same manner as `dependency`. However if the dependency was not fetched, then when the build script is finished running, the build will not proceed to the make phase. Instead, the parent process will additionally fetch all the lazy dependencies that were actually required by running the build script, rebuild the build script, and then run it again. In other words, if this function returns `null` it means that the only purpose of completing the configure phase is to find out all the other lazy dependencies that are also required. It is allowed to use this function for non-lazy dependencies, in which case it will never return `null`. This allows toggling laziness via build.zig.zon without changing build.zig logic. The CLI for `zig build` detects this situation, but the logic for then redoing the build process with these extra dependencies fetched is not yet implemented.
2024-02-02 14:42:29 -07:00
if (mem.eql(u8, decl.name, pkg_hash)) {
const pkg = @field(deps.packages, decl.name);
const available = !@hasDecl(pkg, "available") or pkg.available;
if (!available) {
markNeededLazyDep(b, pkg_hash);
return null;
}
std.Build: add `lazyImport` (`@import` for lazy dependencies)
2024-02-18 19:56:34 +01:00
return dependencyInner(b, name, pkg.build_root, if (@hasDecl(pkg, "build_zig")) pkg.build_zig else null, pkg_hash, pkg.deps, args);
build system: implement lazy dependencies, part 1 Build manifest files support `lazy: true` for dependency sections. This causes the auto-generated dependencies.zig to have 2 more possibilities: 1. It communicates whether a dependency is lazy or not. 2. The dependency might be acknowledged, but missing due to being lazy and not fetched. Lazy dependencies are not fetched by default, but if they are already fetched then they are provided to the build script. The build runner reports the set of missing lazy dependenices that are required to the parent process via stdout and indicates the situation with exit code 3. std.Build now has a `lazyDependency` function. I'll let the doc comments speak for themselves: When this function is called, it means that the current build does, in fact, require this dependency. If the dependency is already fetched, it proceeds in the same manner as `dependency`. However if the dependency was not fetched, then when the build script is finished running, the build will not proceed to the make phase. Instead, the parent process will additionally fetch all the lazy dependencies that were actually required by running the build script, rebuild the build script, and then run it again. In other words, if this function returns `null` it means that the only purpose of completing the configure phase is to find out all the other lazy dependencies that are also required. It is allowed to use this function for non-lazy dependencies, in which case it will never return `null`. This allows toggling laziness via build.zig.zon without changing build.zig logic. The CLI for `zig build` detects this situation, but the logic for then redoing the build process with these extra dependencies fetched is not yet implemented.
2024-02-02 14:42:29 -07:00
}
}
unreachable; // Bad @dependencies source
}
pub fn dependency(b: *Build, name: []const u8, args: anytype) *Dependency {
const build_runner = @import("root");
const deps = build_runner.dependencies;
const pkg_hash = findPkgHashOrFatal(b, name);
package manager: write deps in a flat format, eliminating the FQN concept The new `@depedencies` module contains generated code like the following (where strings like "abc123" represent hashes): ```zig pub const root_deps = [_]struct { []const u8, []const u8 }{ .{ "foo", "abc123" }, }; pub const packages = struct { pub const abc123 = struct { pub const build_root = "/home/mlugg/.cache/zig/blah/abc123"; pub const build_zig = @import("abc123"); pub const deps = [_]struct { []const u8, []const u8 }{ .{ "bar", "abc123" }, .{ "name", "ghi789" }, }; }; }; ``` Each package contains a build root string, the build.zig import, and a mapping from dependency names to package hashes. There is also such a mapping for the root package dependencies. In theory, we could now remove the `dep_prefix` field from `std.Build`, since its main purpose is now handled differently. I believe this is a desirable goal, as it doesn't really make sense to assign a single FQN to any package (because it may appear in many different places in the package hierarchy). This commit does not remove that field, as it's used non-trivially in a few places in the build runner and compiler tests: this will be a future enhancement. Resolves: #16354 Resolves: #17135
2023-09-13 10:46:25 +01:00
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
inline for (@typeInfo(deps.packages).@"struct".decls) |decl| {
package manager: write deps in a flat format, eliminating the FQN concept The new `@depedencies` module contains generated code like the following (where strings like "abc123" represent hashes): ```zig pub const root_deps = [_]struct { []const u8, []const u8 }{ .{ "foo", "abc123" }, }; pub const packages = struct { pub const abc123 = struct { pub const build_root = "/home/mlugg/.cache/zig/blah/abc123"; pub const build_zig = @import("abc123"); pub const deps = [_]struct { []const u8, []const u8 }{ .{ "bar", "abc123" }, .{ "name", "ghi789" }, }; }; }; ``` Each package contains a build root string, the build.zig import, and a mapping from dependency names to package hashes. There is also such a mapping for the root package dependencies. In theory, we could now remove the `dep_prefix` field from `std.Build`, since its main purpose is now handled differently. I believe this is a desirable goal, as it doesn't really make sense to assign a single FQN to any package (because it may appear in many different places in the package hierarchy). This commit does not remove that field, as it's used non-trivially in a few places in the build runner and compiler tests: this will be a future enhancement. Resolves: #16354 Resolves: #17135
2023-09-13 10:46:25 +01:00
if (mem.eql(u8, decl.name, pkg_hash)) {
const pkg = @field(deps.packages, decl.name);
build system: implement lazy dependencies, part 1 Build manifest files support `lazy: true` for dependency sections. This causes the auto-generated dependencies.zig to have 2 more possibilities: 1. It communicates whether a dependency is lazy or not. 2. The dependency might be acknowledged, but missing due to being lazy and not fetched. Lazy dependencies are not fetched by default, but if they are already fetched then they are provided to the build script. The build runner reports the set of missing lazy dependenices that are required to the parent process via stdout and indicates the situation with exit code 3. std.Build now has a `lazyDependency` function. I'll let the doc comments speak for themselves: When this function is called, it means that the current build does, in fact, require this dependency. If the dependency is already fetched, it proceeds in the same manner as `dependency`. However if the dependency was not fetched, then when the build script is finished running, the build will not proceed to the make phase. Instead, the parent process will additionally fetch all the lazy dependencies that were actually required by running the build script, rebuild the build script, and then run it again. In other words, if this function returns `null` it means that the only purpose of completing the configure phase is to find out all the other lazy dependencies that are also required. It is allowed to use this function for non-lazy dependencies, in which case it will never return `null`. This allows toggling laziness via build.zig.zon without changing build.zig logic. The CLI for `zig build` detects this situation, but the logic for then redoing the build process with these extra dependencies fetched is not yet implemented.
2024-02-02 14:42:29 -07:00
if (@hasDecl(pkg, "available")) {
std.Build: use a runtime panic for wrong dependency API This makes it easier to debug and avoids a false positive compile error in the build script.
2024-02-02 20:35:14 -07:00
std.debug.panic("dependency '{s}{s}' is marked as lazy in build.zig.zon which means it must use the lazyDependency function instead", .{ b.dep_prefix, name });
build system: implement lazy dependencies, part 1 Build manifest files support `lazy: true` for dependency sections. This causes the auto-generated dependencies.zig to have 2 more possibilities: 1. It communicates whether a dependency is lazy or not. 2. The dependency might be acknowledged, but missing due to being lazy and not fetched. Lazy dependencies are not fetched by default, but if they are already fetched then they are provided to the build script. The build runner reports the set of missing lazy dependenices that are required to the parent process via stdout and indicates the situation with exit code 3. std.Build now has a `lazyDependency` function. I'll let the doc comments speak for themselves: When this function is called, it means that the current build does, in fact, require this dependency. If the dependency is already fetched, it proceeds in the same manner as `dependency`. However if the dependency was not fetched, then when the build script is finished running, the build will not proceed to the make phase. Instead, the parent process will additionally fetch all the lazy dependencies that were actually required by running the build script, rebuild the build script, and then run it again. In other words, if this function returns `null` it means that the only purpose of completing the configure phase is to find out all the other lazy dependencies that are also required. It is allowed to use this function for non-lazy dependencies, in which case it will never return `null`. This allows toggling laziness via build.zig.zon without changing build.zig logic. The CLI for `zig build` detects this situation, but the logic for then redoing the build process with these extra dependencies fetched is not yet implemented.
2024-02-02 14:42:29 -07:00
}
std.Build: add `lazyImport` (`@import` for lazy dependencies)
2024-02-18 19:56:34 +01:00
return dependencyInner(b, name, pkg.build_root, if (@hasDecl(pkg, "build_zig")) pkg.build_zig else null, pkg_hash, pkg.deps, args);
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
}
package manager: write deps in a flat format, eliminating the FQN concept The new `@depedencies` module contains generated code like the following (where strings like "abc123" represent hashes): ```zig pub const root_deps = [_]struct { []const u8, []const u8 }{ .{ "foo", "abc123" }, }; pub const packages = struct { pub const abc123 = struct { pub const build_root = "/home/mlugg/.cache/zig/blah/abc123"; pub const build_zig = @import("abc123"); pub const deps = [_]struct { []const u8, []const u8 }{ .{ "bar", "abc123" }, .{ "name", "ghi789" }, }; }; }; ``` Each package contains a build root string, the build.zig import, and a mapping from dependency names to package hashes. There is also such a mapping for the root package dependencies. In theory, we could now remove the `dep_prefix` field from `std.Build`, since its main purpose is now handled differently. I believe this is a desirable goal, as it doesn't really make sense to assign a single FQN to any package (because it may appear in many different places in the package hierarchy). This commit does not remove that field, as it's used non-trivially in a few places in the build runner and compiler tests: this will be a future enhancement. Resolves: #16354 Resolves: #17135
2023-09-13 10:46:25 +01:00
unreachable; // Bad @dependencies source
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
std.Build: add `lazyImport` (`@import` for lazy dependencies)
2024-02-18 19:56:34 +01:00
/// In a build.zig file, this function is to `@import` what `lazyDependency` is to `dependency`.
/// If the dependency is lazy and has not yet been fetched, it instructs the parent process to fetch
/// that dependency after the build script has finished running, then returns `null`.
/// If the dependency is lazy but has already been fetched, or if it is eager, it returns
/// the build.zig struct of that dependency, just like a regular `@import`.
pub inline fn lazyImport(
b: *Build,
/// The build.zig struct of the package importing the dependency.
/// When calling this function from the `build` function of a build.zig file's, you normally
/// pass `@This()`.
comptime asking_build_zig: type,
comptime dep_name: []const u8,
) ?type {
const build_runner = @import("root");
const deps = build_runner.dependencies;
const pkg_hash = findImportPkgHashOrFatal(b, asking_build_zig, dep_name);
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
inline for (@typeInfo(deps.packages).@"struct".decls) |decl| {
std.Build: add `lazyImport` (`@import` for lazy dependencies)
2024-02-18 19:56:34 +01:00
if (comptime mem.eql(u8, decl.name, pkg_hash)) {
const pkg = @field(deps.packages, decl.name);
const available = !@hasDecl(pkg, "available") or pkg.available;
if (!available) {
markNeededLazyDep(b, pkg_hash);
return null;
}
return if (@hasDecl(pkg, "build_zig"))
pkg.build_zig
else
@compileError("dependency '" ++ dep_name ++ "' does not have a build.zig");
}
}
comptime unreachable; // Bad @dependencies source
}
std.Build: add dependencyFromBuildZig
2024-02-13 00:02:52 +01:00
pub fn dependencyFromBuildZig(
b: *Build,
/// The build.zig struct of the dependency, normally obtained by `@import` of the dependency.
/// If called from the build.zig file itself, use `@This` to obtain a reference to the struct.
comptime build_zig: type,
args: anytype,
) *Dependency {
const build_runner = @import("root");
const deps = build_runner.dependencies;
find_dep: {
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
const pkg, const pkg_hash = inline for (@typeInfo(deps.packages).@"struct".decls) |decl| {
std.Build: add dependencyFromBuildZig
2024-02-13 00:02:52 +01:00
const pkg_hash = decl.name;
const pkg = @field(deps.packages, pkg_hash);
if (@hasDecl(pkg, "build_zig") and pkg.build_zig == build_zig) break .{ pkg, pkg_hash };
} else break :find_dep;
const dep_name = for (b.available_deps) |dep| {
if (mem.eql(u8, dep[1], pkg_hash)) break dep[1];
} else break :find_dep;
std: fix and add test for Build.dependencyFromBuildZig
2024-04-18 03:07:44 -07:00
return dependencyInner(b, dep_name, pkg.build_root, pkg.build_zig, pkg_hash, pkg.deps, args);
std.Build: add dependencyFromBuildZig
2024-02-13 00:02:52 +01:00
}
const full_path = b.pathFromRoot("build.zig.zon");
std: fix typos (#20560)
2024-07-10 00:25:42 +03:00
debug.panic("'{}' is not a build.zig struct of a dependency in '{s}'", .{ build_zig, full_path });
std.Build: add dependencyFromBuildZig
2024-02-13 00:02:52 +01:00
}
Compare user input for multiple dependency build variants (#16600)
2023-08-10 15:32:55 -07:00
fn userValuesAreSame(lhs: UserValue, rhs: UserValue) bool {
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
if (std.meta.activeTag(lhs) != rhs) return false;
Compare user input for multiple dependency build variants (#16600)
2023-08-10 15:32:55 -07:00
switch (lhs) {
.flag => {},
.scalar => |lhs_scalar| {
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
const rhs_scalar = rhs.scalar;
Compare user input for multiple dependency build variants (#16600)
2023-08-10 15:32:55 -07:00
if (!std.mem.eql(u8, lhs_scalar, rhs_scalar))
return false;
},
.list => |lhs_list| {
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
const rhs_list = rhs.list;
Compare user input for multiple dependency build variants (#16600)
2023-08-10 15:32:55 -07:00
if (lhs_list.items.len != rhs_list.items.len)
return false;
for (lhs_list.items, rhs_list.items) |lhs_list_entry, rhs_list_entry| {
if (!std.mem.eql(u8, lhs_list_entry, rhs_list_entry))
return false;
}
},
.map => |lhs_map| {
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
const rhs_map = rhs.map;
Compare user input for multiple dependency build variants (#16600)
2023-08-10 15:32:55 -07:00
if (lhs_map.count() != rhs_map.count())
return false;
var lhs_it = lhs_map.iterator();
while (lhs_it.next()) |lhs_entry| {
const rhs_value = rhs_map.get(lhs_entry.key_ptr.*) orelse return false;
if (!userValuesAreSame(lhs_entry.value_ptr.*.*, rhs_value.*))
return false;
}
},
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
.lazy_path => |lhs_lp| {
const rhs_lp = rhs.lazy_path;
return userLazyPathsAreTheSame(lhs_lp, rhs_lp);
},
.lazy_path_list => |lhs_lp_list| {
const rhs_lp_list = rhs.lazy_path_list;
if (lhs_lp_list.items.len != rhs_lp_list.items.len) return false;
for (lhs_lp_list.items, rhs_lp_list.items) |lhs_lp, rhs_lp| {
if (!userLazyPathsAreTheSame(lhs_lp, rhs_lp)) return false;
}
return true;
},
Compare user input for multiple dependency build variants (#16600)
2023-08-10 15:32:55 -07:00
}
return true;
}
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
fn userLazyPathsAreTheSame(lhs_lp: LazyPath, rhs_lp: LazyPath) bool {
if (std.meta.activeTag(lhs_lp) != rhs_lp) return false;
switch (lhs_lp) {
.src_path => |lhs_sp| {
const rhs_sp = rhs_lp.src_path;
if (lhs_sp.owner != rhs_sp.owner) return false;
if (std.mem.eql(u8, lhs_sp.sub_path, rhs_sp.sub_path)) return false;
},
.generated => |lhs_gen| {
const rhs_gen = rhs_lp.generated;
if (lhs_gen.file != rhs_gen.file) return false;
if (lhs_gen.up != rhs_gen.up) return false;
if (std.mem.eql(u8, lhs_gen.sub_path, rhs_gen.sub_path)) return false;
},
.cwd_relative => |lhs_rel_path| {
const rhs_rel_path = rhs_lp.cwd_relative;
if (!std.mem.eql(u8, lhs_rel_path, rhs_rel_path)) return false;
},
.dependency => |lhs_dep| {
const rhs_dep = rhs_lp.dependency;
if (lhs_dep.dependency != rhs_dep.dependency) return false;
if (!std.mem.eql(u8, lhs_dep.sub_path, rhs_dep.sub_path)) return false;
},
}
return true;
}
Make `std.Build.dependencyInner` private
2024-02-17 17:51:16 +01:00
fn dependencyInner(
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
b: *Build,
name: []const u8,
std.Build: start using the cache system with RunStep * Use std.Build.Cache.Directory instead of a string for storing the cache roots and build roots. * Set up a std.Build.Cache in build_runner.zig and use it in std.Build.RunStep for avoiding redundant work.
2023-02-09 10:01:01 -07:00
build_root_string: []const u8,
Support non zig dependencies Dependencies no longer require a build.zig file. Adds path function to Dependency struct which returns a LazyPath into a dependency.
2023-09-17 19:38:19 +02:00
comptime build_zig: ?type,
std.Build: add `lazyImport` (`@import` for lazy dependencies)
2024-02-18 19:56:34 +01:00
pkg_hash: []const u8,
package manager: write deps in a flat format, eliminating the FQN concept The new `@depedencies` module contains generated code like the following (where strings like "abc123" represent hashes): ```zig pub const root_deps = [_]struct { []const u8, []const u8 }{ .{ "foo", "abc123" }, }; pub const packages = struct { pub const abc123 = struct { pub const build_root = "/home/mlugg/.cache/zig/blah/abc123"; pub const build_zig = @import("abc123"); pub const deps = [_]struct { []const u8, []const u8 }{ .{ "bar", "abc123" }, .{ "name", "ghi789" }, }; }; }; ``` Each package contains a build root string, the build.zig import, and a mapping from dependency names to package hashes. There is also such a mapping for the root package dependencies. In theory, we could now remove the `dep_prefix` field from `std.Build`, since its main purpose is now handled differently. I believe this is a desirable goal, as it doesn't really make sense to assign a single FQN to any package (because it may appear in many different places in the package hierarchy). This commit does not remove that field, as it's used non-trivially in a few places in the build runner and compiler tests: this will be a future enhancement. Resolves: #16354 Resolves: #17135
2023-09-13 10:46:25 +01:00
pkg_deps: AvailableDeps,
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
args: anytype,
) *Dependency {
Compare user input for multiple dependency build variants (#16600)
2023-08-10 15:32:55 -07:00
const user_input_options = userInputOptionsFromArgs(b.allocator, args);
build: make dependency cache hash map unmanaged Allows Build.Graph to initialize dependency_cache with a default value.
2024-09-27 09:44:44 -06:00
if (b.graph.dependency_cache.getContext(.{
Compare user input for multiple dependency build variants (#16600)
2023-08-10 15:32:55 -07:00
.build_root_string = build_root_string,
.user_input_options = user_input_options,
build: make dependency cache hash map unmanaged Allows Build.Graph to initialize dependency_cache with a default value.
2024-09-27 09:44:44 -06:00
}, .{ .allocator = b.graph.arena })) |dep|
Deduplicate uses of the same package across dependencies
2023-04-22 18:15:19 +01:00
return dep;
std.Build: start using the cache system with RunStep * Use std.Build.Cache.Directory instead of a string for storing the cache roots and build roots. * Set up a std.Build.Cache in build_runner.zig and use it in std.Build.RunStep for avoiding redundant work.
2023-02-09 10:01:01 -07:00
const build_root: std.Build.Cache.Directory = .{
.path = build_root_string,
introduce std.Build.path; deprecate LazyPath.relative This adds the *std.Build owner to LazyPath so that lazy paths returned from a dependency can be used in the application without friction or footguns. closes #19313
2024-04-09 18:23:48 -07:00
.handle = fs.cwd().openDir(build_root_string, .{}) catch |err| {
std.Build: start using the cache system with RunStep * Use std.Build.Cache.Directory instead of a string for storing the cache roots and build roots. * Set up a std.Build.Cache in build_runner.zig and use it in std.Build.RunStep for avoiding redundant work.
2023-02-09 10:01:01 -07:00
std.debug.print("unable to open '{s}': {s}\n", .{
build_root_string, @errorName(err),
});
std.Build: improve debugging of misconfigured steps * Step.init() now takes an options struct * Step.init() now captures a small stack trace and stores it in the Step so that it can be accessed when printing user-friendly debugging information, including the lines of code that created the step in question.
2023-02-14 12:47:45 -07:00
process.exit(1);
std.Build: start using the cache system with RunStep * Use std.Build.Cache.Directory instead of a string for storing the cache roots and build roots. * Set up a std.Build.Cache in build_runner.zig and use it in std.Build.RunStep for avoiding redundant work.
2023-02-09 10:01:01 -07:00
},
};
Support non zig dependencies Dependencies no longer require a build.zig file. Adds path function to Dependency struct which returns a LazyPath into a dependency.
2023-09-17 19:38:19 +02:00
std.Build: add `lazyImport` (`@import` for lazy dependencies)
2024-02-18 19:56:34 +01:00
const sub_builder = b.createChild(name, build_root, pkg_hash, pkg_deps, user_input_options) catch @panic("unhandled error");
Support non zig dependencies Dependencies no longer require a build.zig file. Adds path function to Dependency struct which returns a LazyPath into a dependency.
2023-09-17 19:38:19 +02:00
if (build_zig) |bz| {
sub_builder.runBuild(bz) catch @panic("unhandled error");
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
Support non zig dependencies Dependencies no longer require a build.zig file. Adds path function to Dependency struct which returns a LazyPath into a dependency.
2023-09-17 19:38:19 +02:00
if (sub_builder.validateUserInputDidItFail()) {
replace usages of old std.debug APIs src/crash_handler.zig is still TODO though, i am planning bigger changes there
2025-09-05 20:40:11 +01:00
std.debug.dumpCurrentStackTrace(.{ .first_address = @returnAddress() });
Support non zig dependencies Dependencies no longer require a build.zig file. Adds path function to Dependency struct which returns a LazyPath into a dependency.
2023-09-17 19:38:19 +02:00
}
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
std.Build: avoid use of catch unreachable Usage of `catch unreachable` in build scripts is completely harmless because build scripts are always run in Debug mode, however, it sets a poor example for beginners to learn from.
2023-01-31 14:02:32 -07:00
const dep = b.allocator.create(Dependency) catch @panic("OOM");
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
dep.* = .{ .builder = sub_builder };
Deduplicate uses of the same package across dependencies
2023-04-22 18:15:19 +01:00
build: make dependency cache hash map unmanaged Allows Build.Graph to initialize dependency_cache with a default value.
2024-09-27 09:44:44 -06:00
b.graph.dependency_cache.putContext(b.graph.arena, .{
Compare user input for multiple dependency build variants (#16600)
2023-08-10 15:32:55 -07:00
.build_root_string = build_root_string,
.user_input_options = user_input_options,
build: make dependency cache hash map unmanaged Allows Build.Graph to initialize dependency_cache with a default value.
2024-09-27 09:44:44 -06:00
}, dep, .{ .allocator = b.graph.arena }) catch @panic("OOM");
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
return dep;
}
pub fn runBuild(b: *Build, build_zig: anytype) anyerror!void {
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
switch (@typeInfo(@typeInfo(@TypeOf(build_zig.build)).@"fn".return_type.?)) {
.void => build_zig.build(b),
.error_union => try build_zig.build(b),
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
else => @compileError("expected return type of build to be 'void' or '!void'"),
}
}
/// A file that is generated by a build step.
/// This struct is an interface that is meant to be used with `@fieldParentPtr` to implement the actual path logic.
pub const GeneratedFile = struct {
/// The step that generates the file
step: *Step,
std.Build: resolved generated paths are cwd-relative The doc comment here agreed with the implementation, but not with *any* `Step` which populates a `GeneratedFile`, where they are treated as cwd-relative. This is the obvious correct choice, because these paths usually come from joining onto a cache root, and those are cwd-relative if not absolute. This was a pre-existing bug, but #23836 caused it to trigger more often, because the compiler now commonly passes the local cache directory to the build runner process as a relative path where it was previously an absolute path. Resolves: #23954
2025-05-22 03:26:11 +01:00
/// The path to the generated file. Must be either absolute or relative to the build runner cwd.
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
/// This value must be set in the `fn make()` of the `step` and must not be `null` afterwards.
path: ?[]const u8 = null,
Build: add install commands to `--verbose` output
2025-06-13 12:01:59 -04:00
/// Deprecated, see `getPath2`.
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
pub fn getPath(gen: GeneratedFile) []const u8 {
std.Build: resolved generated paths are cwd-relative The doc comment here agreed with the implementation, but not with *any* `Step` which populates a `GeneratedFile`, where they are treated as cwd-relative. This is the obvious correct choice, because these paths usually come from joining onto a cache root, and those are cwd-relative if not absolute. This was a pre-existing bug, but #23836 caused it to trigger more often, because the compiler now commonly passes the local cache directory to the build runner process as a relative path where it was previously an absolute path. Resolves: #23954
2025-05-22 03:26:11 +01:00
return gen.step.owner.pathFromCwd(gen.path orelse std.debug.panic(
std.Build: improve debugging of misconfigured steps * Step.init() now takes an options struct * Step.init() now captures a small stack trace and stores it in the Step so that it can be accessed when printing user-friendly debugging information, including the lines of code that created the step in question.
2023-02-14 12:47:45 -07:00
"getPath() was called on a GeneratedFile that wasn't built yet. Is there a missing Step dependency on step '{s}'?",
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
.{gen.step.name},
));
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
Build: add install commands to `--verbose` output
2025-06-13 12:01:59 -04:00
pub fn getPath2(gen: GeneratedFile, src_builder: *Build, asking_step: ?*Step) []const u8 {
return gen.path orelse {
std.debug.lockStderrWriter: also return ttyconf `std.Io.tty.Config.detect` may be an expensive check (e.g. involving syscalls), and doing it every time we need to print isn't really necessary; under normal usage, we can compute the value once and cache it for the whole program's execution. Since anyone outputting to stderr may reasonably want this information (in fact they are very likely to), it makes sense to cache it and return it from `lockStderrWriter`. Call sites who do not need it will experience no significant overhead, and can just ignore the TTY config with a `const w, _` destructure.
2025-10-28 12:42:05 +00:00
const w, const ttyconf = debug.lockStderrWriter(&.{});
dumpBadGetPathHelp(gen.step, w, ttyconf, src_builder, asking_step) catch {};
fix build runner
2025-07-02 11:16:20 -07:00
debug.unlockStderrWriter();
Build: add install commands to `--verbose` output
2025-06-13 12:01:59 -04:00
@panic("misconfigured build script");
};
}
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
};
build/LazyPath: Add dirname (#18371) Adds a variant to the LazyPath union representing a parent directory of a generated path. ```zig const LazyPath = union(enum) { generated_dirname: struct { generated: *const GeneratedFile, up: usize, }, // ... } ``` These can be constructed with the new method: ```zig pub fn dirname(self: LazyPath) LazyPath ``` For the cases where the LazyPath is already known (`.path`, `.cwd_relative`, and `dependency`) this is evaluated right away. For dirnames of generated files and their dirnames, this is evaluated at getPath time. dirname calls can be chained, but for safety, they are not allowed to escape outside a root defined for each case: - path: This is relative to the build root, so dirname can't escape outside the build root. - generated: Can't escape the zig-cache. - cwd_relative: This can be a relative or absolute path. If relative, can't escape the current directory, and if absolute, can't go beyond root (/). - dependency: Can't escape the dependency's root directory. Testing: I've included a standalone case for many of the happy cases. I couldn't find an easy way to test the negatives, though, because tests cannot yet expect panics.
2024-01-04 15:47:28 -08:00
// dirnameAllowEmpty is a variant of fs.path.dirname
// that allows "" to refer to the root for relative paths.
//
// For context, dirname("foo") and dirname("") are both null.
// However, for relative paths, we want dirname("foo") to be ""
// so that we can join it with another path (e.g. build root, cache root, etc.)
//
// dirname("") should still be null, because we can't go up any further.
introduce std.Build.path; deprecate LazyPath.relative This adds the *std.Build owner to LazyPath so that lazy paths returned from a dependency can be used in the application without friction or footguns. closes #19313
2024-04-09 18:23:48 -07:00
fn dirnameAllowEmpty(full_path: []const u8) ?[]const u8 {
return fs.path.dirname(full_path) orelse {
if (fs.path.isAbsolute(full_path) or full_path.len == 0) return null;
build/LazyPath: Add dirname (#18371) Adds a variant to the LazyPath union representing a parent directory of a generated path. ```zig const LazyPath = union(enum) { generated_dirname: struct { generated: *const GeneratedFile, up: usize, }, // ... } ``` These can be constructed with the new method: ```zig pub fn dirname(self: LazyPath) LazyPath ``` For the cases where the LazyPath is already known (`.path`, `.cwd_relative`, and `dependency`) this is evaluated right away. For dirnames of generated files and their dirnames, this is evaluated at getPath time. dirname calls can be chained, but for safety, they are not allowed to escape outside a root defined for each case: - path: This is relative to the build root, so dirname can't escape outside the build root. - generated: Can't escape the zig-cache. - cwd_relative: This can be a relative or absolute path. If relative, can't escape the current directory, and if absolute, can't go beyond root (/). - dependency: Can't escape the dependency's root directory. Testing: I've included a standalone case for many of the happy cases. I couldn't find an easy way to test the negatives, though, because tests cannot yet expect panics.
2024-01-04 15:47:28 -08:00
return "";
};
}
test dirnameAllowEmpty {
try std.testing.expectEqualStrings(
"foo",
dirnameAllowEmpty("foo" ++ fs.path.sep_str ++ "bar") orelse @panic("unexpected null"),
);
try std.testing.expectEqualStrings(
"",
dirnameAllowEmpty("foo") orelse @panic("unexpected null"),
);
try std.testing.expect(dirnameAllowEmpty("") == null);
}
Build.zig rename orgy (aka: #16353). Renames FileSource to LazyPath and removes functions that take literal paths instead of LazyPath.
2023-07-19 10:49:34 +02:00
/// A reference to an existing or future path.
pub const LazyPath = union(enum) {
introduce std.Build.path; deprecate LazyPath.relative This adds the *std.Build owner to LazyPath so that lazy paths returned from a dependency can be used in the application without friction or footguns. closes #19313
2024-04-09 18:23:48 -07:00
/// A source file path relative to build root.
src_path: struct {
owner: *std.Build,
sub_path: []const u8,
},
Run: add output directory arguments This allows running commands that take an output directory argument. The main thing that was needed for this feature was generated file subpaths, to allow access to the files in a generated directory. Additionally, a minor change was required to so that the correct directory is created for output directory args.
2024-05-04 15:12:24 -04:00
generated: struct {
file: *const GeneratedFile,
build/LazyPath: Add dirname (#18371) Adds a variant to the LazyPath union representing a parent directory of a generated path. ```zig const LazyPath = union(enum) { generated_dirname: struct { generated: *const GeneratedFile, up: usize, }, // ... } ``` These can be constructed with the new method: ```zig pub fn dirname(self: LazyPath) LazyPath ``` For the cases where the LazyPath is already known (`.path`, `.cwd_relative`, and `dependency`) this is evaluated right away. For dirnames of generated files and their dirnames, this is evaluated at getPath time. dirname calls can be chained, but for safety, they are not allowed to escape outside a root defined for each case: - path: This is relative to the build root, so dirname can't escape outside the build root. - generated: Can't escape the zig-cache. - cwd_relative: This can be a relative or absolute path. If relative, can't escape the current directory, and if absolute, can't go beyond root (/). - dependency: Can't escape the dependency's root directory. Testing: I've included a standalone case for many of the happy cases. I couldn't find an easy way to test the negatives, though, because tests cannot yet expect panics.
2024-01-04 15:47:28 -08:00
/// The number of parent directories to go up.
Run: add output directory arguments This allows running commands that take an output directory argument. The main thing that was needed for this feature was generated file subpaths, to allow access to the files in a generated directory. Additionally, a minor change was required to so that the correct directory is created for output directory args.
2024-05-04 15:12:24 -04:00
/// 0 means the generated file itself.
/// 1 means the directory of the generated file.
/// 2 means the parent of that directory, and so on.
up: usize = 0,
/// Applied after `up`.
sub_path: []const u8 = "",
build/LazyPath: Add dirname (#18371) Adds a variant to the LazyPath union representing a parent directory of a generated path. ```zig const LazyPath = union(enum) { generated_dirname: struct { generated: *const GeneratedFile, up: usize, }, // ... } ``` These can be constructed with the new method: ```zig pub fn dirname(self: LazyPath) LazyPath ``` For the cases where the LazyPath is already known (`.path`, `.cwd_relative`, and `dependency`) this is evaluated right away. For dirnames of generated files and their dirnames, this is evaluated at getPath time. dirname calls can be chained, but for safety, they are not allowed to escape outside a root defined for each case: - path: This is relative to the build root, so dirname can't escape outside the build root. - generated: Can't escape the zig-cache. - cwd_relative: This can be a relative or absolute path. If relative, can't escape the current directory, and if absolute, can't go beyond root (/). - dependency: Can't escape the dependency's root directory. Testing: I've included a standalone case for many of the happy cases. I couldn't find an easy way to test the negatives, though, because tests cannot yet expect panics.
2024-01-04 15:47:28 -08:00
},
build system: follow-up enhancements regarding LazyPath * introduce LazyPath.cwd_relative variant and use it for --zig-lib-dir. closes #12685 * move overrideZigLibDir and setMainPkgPath to options fields set once and then never mutated. * avoid introducing Build/util.zig * use doc comments for deprecation notices so that they show up in generated documentation. * introduce InstallArtifact.Options, accept it as a parameter to addInstallArtifact, and move override_dest_dir into it. Instead of configuring the installation via Compile step, configure the installation via the InstallArtifact step. In retrospect this is obvious. * remove calls to pushInstalledFile in InstallArtifact. See #14943 * rewrite InstallArtifact to not incorrectly observe whether a Compile step has any generated outputs. InstallArtifact is meant to trigger output generation. * fix child process evaluation code handling of `-fno-emit-bin`. * don't store out_h_filename, out_ll_filename, etc., pointlessly. these are all just simple extensions appended to the root name. * make emit_directory optional. It's possible to have nothing outputted, for example, if you're just type-checking. * avoid passing -femit-foo/-fno-emit-foo when it is the default * rename ConfigHeader.getTemplate to getOutput * deprecate addOptionArtifact * update the random number seed of Options step caching. * avoid using `inline for` pointlessly * avoid using `override_Dest_dir` pointlessly * avoid emitting an executable pointlessly in test cases Removes forceBuild and forceEmit. Let's consider these additions separately. Nearly all of the usage sites were suspicious.
2023-07-29 23:57:52 -07:00
/// An absolute path or a path relative to the current working directory of
/// the build runner process.
/// This is uncommon but used for system environment paths such as `--zig-lib-dir` which
/// ignore the file system path of build.zig and instead are relative to the directory from
/// which `zig build` was invoked.
/// Use of this tag indicates a dependency on the host system.
cwd_relative: []const u8,
Support non zig dependencies Dependencies no longer require a build.zig file. Adds path function to Dependency struct which returns a LazyPath into a dependency.
2023-09-17 19:38:19 +02:00
dependency: struct {
dependency: *Dependency,
sub_path: []const u8,
},
build/LazyPath: Add dirname (#18371) Adds a variant to the LazyPath union representing a parent directory of a generated path. ```zig const LazyPath = union(enum) { generated_dirname: struct { generated: *const GeneratedFile, up: usize, }, // ... } ``` These can be constructed with the new method: ```zig pub fn dirname(self: LazyPath) LazyPath ``` For the cases where the LazyPath is already known (`.path`, `.cwd_relative`, and `dependency`) this is evaluated right away. For dirnames of generated files and their dirnames, this is evaluated at getPath time. dirname calls can be chained, but for safety, they are not allowed to escape outside a root defined for each case: - path: This is relative to the build root, so dirname can't escape outside the build root. - generated: Can't escape the zig-cache. - cwd_relative: This can be a relative or absolute path. If relative, can't escape the current directory, and if absolute, can't go beyond root (/). - dependency: Can't escape the dependency's root directory. Testing: I've included a standalone case for many of the happy cases. I couldn't find an easy way to test the negatives, though, because tests cannot yet expect panics.
2024-01-04 15:47:28 -08:00
/// Returns a lazy path referring to the directory containing this path.
///
/// The dirname is not allowed to escape the logical root for underlying path.
/// For example, if the path is relative to the build root,
/// the dirname is not allowed to traverse outside of the build root.
/// Similarly, if the path is a generated file inside zig-cache,
/// the dirname is not allowed to traverse outside of zig-cache.
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
pub fn dirname(lazy_path: LazyPath) LazyPath {
return switch (lazy_path) {
introduce std.Build.path; deprecate LazyPath.relative This adds the *std.Build owner to LazyPath so that lazy paths returned from a dependency can be used in the application without friction or footguns. closes #19313
2024-04-09 18:23:48 -07:00
.src_path => |sp| .{ .src_path = .{
.owner = sp.owner,
.sub_path = dirnameAllowEmpty(sp.sub_path) orelse {
dumpBadDirnameHelp(null, null, "dirname() attempted to traverse outside the build root\n", .{}) catch {};
@panic("misconfigured build script");
},
} },
Run: add output directory arguments This allows running commands that take an output directory argument. The main thing that was needed for this feature was generated file subpaths, to allow access to the files in a generated directory. Additionally, a minor change was required to so that the correct directory is created for output directory args.
2024-05-04 15:12:24 -04:00
.generated => |generated| .{ .generated = if (dirnameAllowEmpty(generated.sub_path)) |sub_dirname| .{
.file = generated.file,
.up = generated.up,
.sub_path = sub_dirname,
} else .{
.file = generated.file,
.up = generated.up + 1,
.sub_path = "",
} },
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
.cwd_relative => |rel_path| .{
.cwd_relative = dirnameAllowEmpty(rel_path) orelse {
build/LazyPath: Add dirname (#18371) Adds a variant to the LazyPath union representing a parent directory of a generated path. ```zig const LazyPath = union(enum) { generated_dirname: struct { generated: *const GeneratedFile, up: usize, }, // ... } ``` These can be constructed with the new method: ```zig pub fn dirname(self: LazyPath) LazyPath ``` For the cases where the LazyPath is already known (`.path`, `.cwd_relative`, and `dependency`) this is evaluated right away. For dirnames of generated files and their dirnames, this is evaluated at getPath time. dirname calls can be chained, but for safety, they are not allowed to escape outside a root defined for each case: - path: This is relative to the build root, so dirname can't escape outside the build root. - generated: Can't escape the zig-cache. - cwd_relative: This can be a relative or absolute path. If relative, can't escape the current directory, and if absolute, can't go beyond root (/). - dependency: Can't escape the dependency's root directory. Testing: I've included a standalone case for many of the happy cases. I couldn't find an easy way to test the negatives, though, because tests cannot yet expect panics.
2024-01-04 15:47:28 -08:00
// If we get null, it means one of two things:
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
// - rel_path was absolute, and is now root
// - rel_path was relative, and is now ""
build/LazyPath: Add dirname (#18371) Adds a variant to the LazyPath union representing a parent directory of a generated path. ```zig const LazyPath = union(enum) { generated_dirname: struct { generated: *const GeneratedFile, up: usize, }, // ... } ``` These can be constructed with the new method: ```zig pub fn dirname(self: LazyPath) LazyPath ``` For the cases where the LazyPath is already known (`.path`, `.cwd_relative`, and `dependency`) this is evaluated right away. For dirnames of generated files and their dirnames, this is evaluated at getPath time. dirname calls can be chained, but for safety, they are not allowed to escape outside a root defined for each case: - path: This is relative to the build root, so dirname can't escape outside the build root. - generated: Can't escape the zig-cache. - cwd_relative: This can be a relative or absolute path. If relative, can't escape the current directory, and if absolute, can't go beyond root (/). - dependency: Can't escape the dependency's root directory. Testing: I've included a standalone case for many of the happy cases. I couldn't find an easy way to test the negatives, though, because tests cannot yet expect panics.
2024-01-04 15:47:28 -08:00
// In either case, the build script tried to go too far
// and we should panic.
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
if (fs.path.isAbsolute(rel_path)) {
build/LazyPath: Add dirname (#18371) Adds a variant to the LazyPath union representing a parent directory of a generated path. ```zig const LazyPath = union(enum) { generated_dirname: struct { generated: *const GeneratedFile, up: usize, }, // ... } ``` These can be constructed with the new method: ```zig pub fn dirname(self: LazyPath) LazyPath ``` For the cases where the LazyPath is already known (`.path`, `.cwd_relative`, and `dependency`) this is evaluated right away. For dirnames of generated files and their dirnames, this is evaluated at getPath time. dirname calls can be chained, but for safety, they are not allowed to escape outside a root defined for each case: - path: This is relative to the build root, so dirname can't escape outside the build root. - generated: Can't escape the zig-cache. - cwd_relative: This can be a relative or absolute path. If relative, can't escape the current directory, and if absolute, can't go beyond root (/). - dependency: Can't escape the dependency's root directory. Testing: I've included a standalone case for many of the happy cases. I couldn't find an easy way to test the negatives, though, because tests cannot yet expect panics.
2024-01-04 15:47:28 -08:00
dumpBadDirnameHelp(null, null,
\\dirname() attempted to traverse outside the root.
\\No more directories left to go up.
\\
, .{}) catch {};
@panic("misconfigured build script");
} else {
dumpBadDirnameHelp(null, null,
\\dirname() attempted to traverse outside the current working directory.
\\
, .{}) catch {};
@panic("misconfigured build script");
}
},
},
.dependency => |dep| .{ .dependency = .{
.dependency = dep.dependency,
.sub_path = dirnameAllowEmpty(dep.sub_path) orelse {
dumpBadDirnameHelp(null, null,
\\dirname() attempted to traverse outside the dependency root.
\\
, .{}) catch {};
@panic("misconfigured build script");
},
} },
};
}
Run: add output directory arguments This allows running commands that take an output directory argument. The main thing that was needed for this feature was generated file subpaths, to allow access to the files in a generated directory. Additionally, a minor change was required to so that the correct directory is created for output directory args.
2024-05-04 15:12:24 -04:00
pub fn path(lazy_path: LazyPath, b: *Build, sub_path: []const u8) LazyPath {
introduce a web interface for fuzzing * new .zig-cache subdirectory: 'v' - stores coverage information with filename of hash of PCs that want coverage. This hash is a hex encoding of the 64-bit coverage ID. * build runner * fixed bug in file system inputs when a compile step has an overridden zig_lib_dir field set. * set some std lib options optimized for the build runner - no side channel mitigations - no Transport Layer Security - no crypto fork safety * add a --port CLI arg for choosing the port the fuzzing web interface listens on. it defaults to choosing a random open port. * introduce a web server, and serve a basic single page application - shares wasm code with autodocs - assets are created live on request, for convenient development experience. main.wasm is properly cached if nothing changes. - sources.tar comes from file system inputs (introduced with the `--watch` feature) * receives coverage ID from test runner and sends it on a thread-safe queue to the WebServer. * test runner - takes a zig cache directory argument now, for where to put coverage information. - sends coverage ID to parent process * fuzzer - puts its logs (in debug mode) in .zig-cache/tmp/libfuzzer.log - computes coverage_id and makes it available with `fuzzer_coverage_id` exported function. - the memory-mapped coverage file is now namespaced by the coverage id in hex encoding, in `.zig-cache/v` * tokenizer - add a fuzz test to check that several properties are upheld
2024-07-31 22:54:05 -07:00
return lazy_path.join(b.allocator, sub_path) catch @panic("OOM");
}
pub fn join(lazy_path: LazyPath, arena: Allocator, sub_path: []const u8) Allocator.Error!LazyPath {
Run: add output directory arguments This allows running commands that take an output directory argument. The main thing that was needed for this feature was generated file subpaths, to allow access to the files in a generated directory. Additionally, a minor change was required to so that the correct directory is created for output directory args.
2024-05-04 15:12:24 -04:00
return switch (lazy_path) {
.src_path => |src| .{ .src_path = .{
.owner = src.owner,
introduce a web interface for fuzzing * new .zig-cache subdirectory: 'v' - stores coverage information with filename of hash of PCs that want coverage. This hash is a hex encoding of the 64-bit coverage ID. * build runner * fixed bug in file system inputs when a compile step has an overridden zig_lib_dir field set. * set some std lib options optimized for the build runner - no side channel mitigations - no Transport Layer Security - no crypto fork safety * add a --port CLI arg for choosing the port the fuzzing web interface listens on. it defaults to choosing a random open port. * introduce a web server, and serve a basic single page application - shares wasm code with autodocs - assets are created live on request, for convenient development experience. main.wasm is properly cached if nothing changes. - sources.tar comes from file system inputs (introduced with the `--watch` feature) * receives coverage ID from test runner and sends it on a thread-safe queue to the WebServer. * test runner - takes a zig cache directory argument now, for where to put coverage information. - sends coverage ID to parent process * fuzzer - puts its logs (in debug mode) in .zig-cache/tmp/libfuzzer.log - computes coverage_id and makes it available with `fuzzer_coverage_id` exported function. - the memory-mapped coverage file is now namespaced by the coverage id in hex encoding, in `.zig-cache/v` * tokenizer - add a fuzz test to check that several properties are upheld
2024-07-31 22:54:05 -07:00
.sub_path = try fs.path.resolve(arena, &.{ src.sub_path, sub_path }),
Run: add output directory arguments This allows running commands that take an output directory argument. The main thing that was needed for this feature was generated file subpaths, to allow access to the files in a generated directory. Additionally, a minor change was required to so that the correct directory is created for output directory args.
2024-05-04 15:12:24 -04:00
} },
.generated => |gen| .{ .generated = .{
.file = gen.file,
.up = gen.up,
introduce a web interface for fuzzing * new .zig-cache subdirectory: 'v' - stores coverage information with filename of hash of PCs that want coverage. This hash is a hex encoding of the 64-bit coverage ID. * build runner * fixed bug in file system inputs when a compile step has an overridden zig_lib_dir field set. * set some std lib options optimized for the build runner - no side channel mitigations - no Transport Layer Security - no crypto fork safety * add a --port CLI arg for choosing the port the fuzzing web interface listens on. it defaults to choosing a random open port. * introduce a web server, and serve a basic single page application - shares wasm code with autodocs - assets are created live on request, for convenient development experience. main.wasm is properly cached if nothing changes. - sources.tar comes from file system inputs (introduced with the `--watch` feature) * receives coverage ID from test runner and sends it on a thread-safe queue to the WebServer. * test runner - takes a zig cache directory argument now, for where to put coverage information. - sends coverage ID to parent process * fuzzer - puts its logs (in debug mode) in .zig-cache/tmp/libfuzzer.log - computes coverage_id and makes it available with `fuzzer_coverage_id` exported function. - the memory-mapped coverage file is now namespaced by the coverage id in hex encoding, in `.zig-cache/v` * tokenizer - add a fuzz test to check that several properties are upheld
2024-07-31 22:54:05 -07:00
.sub_path = try fs.path.resolve(arena, &.{ gen.sub_path, sub_path }),
Run: add output directory arguments This allows running commands that take an output directory argument. The main thing that was needed for this feature was generated file subpaths, to allow access to the files in a generated directory. Additionally, a minor change was required to so that the correct directory is created for output directory args.
2024-05-04 15:12:24 -04:00
} },
.cwd_relative => |cwd_relative| .{
introduce a web interface for fuzzing * new .zig-cache subdirectory: 'v' - stores coverage information with filename of hash of PCs that want coverage. This hash is a hex encoding of the 64-bit coverage ID. * build runner * fixed bug in file system inputs when a compile step has an overridden zig_lib_dir field set. * set some std lib options optimized for the build runner - no side channel mitigations - no Transport Layer Security - no crypto fork safety * add a --port CLI arg for choosing the port the fuzzing web interface listens on. it defaults to choosing a random open port. * introduce a web server, and serve a basic single page application - shares wasm code with autodocs - assets are created live on request, for convenient development experience. main.wasm is properly cached if nothing changes. - sources.tar comes from file system inputs (introduced with the `--watch` feature) * receives coverage ID from test runner and sends it on a thread-safe queue to the WebServer. * test runner - takes a zig cache directory argument now, for where to put coverage information. - sends coverage ID to parent process * fuzzer - puts its logs (in debug mode) in .zig-cache/tmp/libfuzzer.log - computes coverage_id and makes it available with `fuzzer_coverage_id` exported function. - the memory-mapped coverage file is now namespaced by the coverage id in hex encoding, in `.zig-cache/v` * tokenizer - add a fuzz test to check that several properties are upheld
2024-07-31 22:54:05 -07:00
.cwd_relative = try fs.path.resolve(arena, &.{ cwd_relative, sub_path }),
Run: add output directory arguments This allows running commands that take an output directory argument. The main thing that was needed for this feature was generated file subpaths, to allow access to the files in a generated directory. Additionally, a minor change was required to so that the correct directory is created for output directory args.
2024-05-04 15:12:24 -04:00
},
.dependency => |dep| .{ .dependency = .{
.dependency = dep.dependency,
introduce a web interface for fuzzing * new .zig-cache subdirectory: 'v' - stores coverage information with filename of hash of PCs that want coverage. This hash is a hex encoding of the 64-bit coverage ID. * build runner * fixed bug in file system inputs when a compile step has an overridden zig_lib_dir field set. * set some std lib options optimized for the build runner - no side channel mitigations - no Transport Layer Security - no crypto fork safety * add a --port CLI arg for choosing the port the fuzzing web interface listens on. it defaults to choosing a random open port. * introduce a web server, and serve a basic single page application - shares wasm code with autodocs - assets are created live on request, for convenient development experience. main.wasm is properly cached if nothing changes. - sources.tar comes from file system inputs (introduced with the `--watch` feature) * receives coverage ID from test runner and sends it on a thread-safe queue to the WebServer. * test runner - takes a zig cache directory argument now, for where to put coverage information. - sends coverage ID to parent process * fuzzer - puts its logs (in debug mode) in .zig-cache/tmp/libfuzzer.log - computes coverage_id and makes it available with `fuzzer_coverage_id` exported function. - the memory-mapped coverage file is now namespaced by the coverage id in hex encoding, in `.zig-cache/v` * tokenizer - add a fuzz test to check that several properties are upheld
2024-07-31 22:54:05 -07:00
.sub_path = try fs.path.resolve(arena, &.{ dep.sub_path, sub_path }),
Run: add output directory arguments This allows running commands that take an output directory argument. The main thing that was needed for this feature was generated file subpaths, to allow access to the files in a generated directory. Additionally, a minor change was required to so that the correct directory is created for output directory args.
2024-05-04 15:12:24 -04:00
} },
};
}
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
/// Returns a string that can be shown to represent the file source.
Run: add output directory arguments This allows running commands that take an output directory argument. The main thing that was needed for this feature was generated file subpaths, to allow access to the files in a generated directory. Additionally, a minor change was required to so that the correct directory is created for output directory args.
2024-05-04 15:12:24 -04:00
/// Either returns the path, `"generated"`, or `"dependency"`.
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
pub fn getDisplayName(lazy_path: LazyPath) []const u8 {
return switch (lazy_path) {
Run: add output directory arguments This allows running commands that take an output directory argument. The main thing that was needed for this feature was generated file subpaths, to allow access to the files in a generated directory. Additionally, a minor change was required to so that the correct directory is created for output directory args.
2024-05-04 15:12:24 -04:00
.src_path => |sp| sp.sub_path,
.cwd_relative => |p| p,
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
.generated => "generated",
Support non zig dependencies Dependencies no longer require a build.zig file. Adds path function to Dependency struct which returns a LazyPath into a dependency.
2023-09-17 19:38:19 +02:00
.dependency => "dependency",
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
};
}
/// Adds dependencies this file source implies to the given step.
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
pub fn addStepDependencies(lazy_path: LazyPath, other_step: *Step) void {
switch (lazy_path) {
Run: add output directory arguments This allows running commands that take an output directory argument. The main thing that was needed for this feature was generated file subpaths, to allow access to the files in a generated directory. Additionally, a minor change was required to so that the correct directory is created for output directory args.
2024-05-04 15:12:24 -04:00
.src_path, .cwd_relative, .dependency => {},
.generated => |gen| other_step.dependOn(gen.file.step),
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
}
std.Build.LazyPath: add getPath3; deprecate getPath2 and getPath The goal is to move towards using `std.Build.Cache.Path` instead of absolute path names. This was helpful for implementing file watching integration to the InstallDir Step
2024-07-09 23:14:18 -07:00
/// Deprecated, see `getPath3`.
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
pub fn getPath(lazy_path: LazyPath, src_builder: *Build) []const u8 {
return getPath2(lazy_path, src_builder, null);
std.Build: further enhance debug message for bad getPath() Now it also shows the step stack trace of the step whose make function is being run.
2023-02-14 13:12:47 -07:00
}
std.Build.LazyPath: add getPath3; deprecate getPath2 and getPath The goal is to move towards using `std.Build.Cache.Path` instead of absolute path names. This was helpful for implementing file watching integration to the InstallDir Step
2024-07-09 23:14:18 -07:00
/// Deprecated, see `getPath3`.
pub fn getPath2(lazy_path: LazyPath, src_builder: *Build, asking_step: ?*Step) []const u8 {
const p = getPath3(lazy_path, src_builder, asking_step);
return src_builder.pathResolve(&.{ p.root_dir.path orelse ".", p.sub_path });
}
build system: follow-up enhancements regarding LazyPath * introduce LazyPath.cwd_relative variant and use it for --zig-lib-dir. closes #12685 * move overrideZigLibDir and setMainPkgPath to options fields set once and then never mutated. * avoid introducing Build/util.zig * use doc comments for deprecation notices so that they show up in generated documentation. * introduce InstallArtifact.Options, accept it as a parameter to addInstallArtifact, and move override_dest_dir into it. Instead of configuring the installation via Compile step, configure the installation via the InstallArtifact step. In retrospect this is obvious. * remove calls to pushInstalledFile in InstallArtifact. See #14943 * rewrite InstallArtifact to not incorrectly observe whether a Compile step has any generated outputs. InstallArtifact is meant to trigger output generation. * fix child process evaluation code handling of `-fno-emit-bin`. * don't store out_h_filename, out_ll_filename, etc., pointlessly. these are all just simple extensions appended to the root name. * make emit_directory optional. It's possible to have nothing outputted, for example, if you're just type-checking. * avoid passing -femit-foo/-fno-emit-foo when it is the default * rename ConfigHeader.getTemplate to getOutput * deprecate addOptionArtifact * update the random number seed of Options step caching. * avoid using `inline for` pointlessly * avoid using `override_Dest_dir` pointlessly * avoid emitting an executable pointlessly in test cases Removes forceBuild and forceEmit. Let's consider these additions separately. Nearly all of the usage sites were suspicious.
2023-07-29 23:57:52 -07:00
/// Intended to be used during the make phase only.
///
/// `asking_step` is only used for debugging purposes; it's the step being
/// run that is asking for the path.
std.Build.LazyPath: add getPath3; deprecate getPath2 and getPath The goal is to move towards using `std.Build.Cache.Path` instead of absolute path names. This was helpful for implementing file watching integration to the InstallDir Step
2024-07-09 23:14:18 -07:00
pub fn getPath3(lazy_path: LazyPath, src_builder: *Build, asking_step: ?*Step) Cache.Path {
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
switch (lazy_path) {
std.Build.LazyPath: add getPath3; deprecate getPath2 and getPath The goal is to move towards using `std.Build.Cache.Path` instead of absolute path names. This was helpful for implementing file watching integration to the InstallDir Step
2024-07-09 23:14:18 -07:00
.src_path => |sp| return .{
.root_dir = sp.owner.build_root,
.sub_path = sp.sub_path,
},
.cwd_relative => |sub_path| return .{
.root_dir = Cache.Directory.cwd(),
.sub_path = sub_path,
},
Run: add output directory arguments This allows running commands that take an output directory argument. The main thing that was needed for this feature was generated file subpaths, to allow access to the files in a generated directory. Additionally, a minor change was required to so that the correct directory is created for output directory args.
2024-05-04 15:12:24 -04:00
.generated => |gen| {
std.Build.LazyPath: add getPath3; deprecate getPath2 and getPath The goal is to move towards using `std.Build.Cache.Path` instead of absolute path names. This was helpful for implementing file watching integration to the InstallDir Step
2024-07-09 23:14:18 -07:00
// TODO make gen.file.path not be absolute and use that as the
// basis for not traversing up too many directories.
var file_path: Cache.Path = .{
fix various issues related to Path handling in the compiler and std A compilation build step for which the binary is not required could not be compiled previously. There were 2 issues that caused this: - The compiler communicated only the results of the emitted binary and did not properly communicate the result if the binary was not emitted. This is fixed by communicating the final hash of the artifact path (the hash of the corresponding /o/<hash> directory) and communicating this instead of the entire path. This changes the zig build --listen protocol to communicate hashes instead of paths, and emit_bin_path is accordingly renamed to emit_digest. - There was an error related to the default llvm object path when CacheUse.Whole was selected. I'm not really sure why this didn't manifest when the binary is also emitted. This was fixed by improving the path handling related to flush() and emitLlvmObject(). In general, this commit also improves some of the path handling throughout the compiler and standard library.
2024-08-18 00:43:33 +02:00
.root_dir = Cache.Directory.cwd(),
std.Build.LazyPath: add getPath3; deprecate getPath2 and getPath The goal is to move towards using `std.Build.Cache.Path` instead of absolute path names. This was helpful for implementing file watching integration to the InstallDir Step
2024-07-09 23:14:18 -07:00
.sub_path = gen.file.path orelse {
std.debug.lockStderrWriter: also return ttyconf `std.Io.tty.Config.detect` may be an expensive check (e.g. involving syscalls), and doing it every time we need to print isn't really necessary; under normal usage, we can compute the value once and cache it for the whole program's execution. Since anyone outputting to stderr may reasonably want this information (in fact they are very likely to), it makes sense to cache it and return it from `lockStderrWriter`. Call sites who do not need it will experience no significant overhead, and can just ignore the TTY config with a `const w, _` destructure.
2025-10-28 12:42:05 +00:00
const w, const ttyconf = debug.lockStderrWriter(&.{});
dumpBadGetPathHelp(gen.file.step, w, ttyconf, src_builder, asking_step) catch {};
fix build runner
2025-07-02 11:16:20 -07:00
debug.unlockStderrWriter();
std.Build.LazyPath: add getPath3; deprecate getPath2 and getPath The goal is to move towards using `std.Build.Cache.Path` instead of absolute path names. This was helpful for implementing file watching integration to the InstallDir Step
2024-07-09 23:14:18 -07:00
@panic("misconfigured build script");
},
};
Run: add output directory arguments This allows running commands that take an output directory argument. The main thing that was needed for this feature was generated file subpaths, to allow access to the files in a generated directory. Additionally, a minor change was required to so that the correct directory is created for output directory args.
2024-05-04 15:12:24 -04:00
if (gen.up > 0) {
const cache_root_path = src_builder.cache_root.path orelse
(src_builder.cache_root.join(src_builder.allocator, &.{"."}) catch @panic("OOM"));
for (0..gen.up) |_| {
std.Build.LazyPath: add getPath3; deprecate getPath2 and getPath The goal is to move towards using `std.Build.Cache.Path` instead of absolute path names. This was helpful for implementing file watching integration to the InstallDir Step
2024-07-09 23:14:18 -07:00
if (mem.eql(u8, file_path.sub_path, cache_root_path)) {
Run: add output directory arguments This allows running commands that take an output directory argument. The main thing that was needed for this feature was generated file subpaths, to allow access to the files in a generated directory. Additionally, a minor change was required to so that the correct directory is created for output directory args.
2024-05-04 15:12:24 -04:00
// If we hit the cache root and there's still more to go,
// the script attempted to go too far.
dumpBadDirnameHelp(gen.file.step, asking_step,
\\dirname() attempted to traverse outside the cache root.
\\This is not allowed.
\\
, .{}) catch {};
@panic("misconfigured build script");
}
// path is absolute.
// dirname will return null only if we're at root.
// Typically, we'll stop well before that at the cache root.
std.Build.LazyPath: add getPath3; deprecate getPath2 and getPath The goal is to move towards using `std.Build.Cache.Path` instead of absolute path names. This was helpful for implementing file watching integration to the InstallDir Step
2024-07-09 23:14:18 -07:00
file_path.sub_path = fs.path.dirname(file_path.sub_path) orelse {
Run: add output directory arguments This allows running commands that take an output directory argument. The main thing that was needed for this feature was generated file subpaths, to allow access to the files in a generated directory. Additionally, a minor change was required to so that the correct directory is created for output directory args.
2024-05-04 15:12:24 -04:00
dumpBadDirnameHelp(gen.file.step, asking_step,
\\dirname() reached root.
\\No more directories left to go up.
\\
, .{}) catch {};
@panic("misconfigured build script");
};
build/LazyPath: Add dirname (#18371) Adds a variant to the LazyPath union representing a parent directory of a generated path. ```zig const LazyPath = union(enum) { generated_dirname: struct { generated: *const GeneratedFile, up: usize, }, // ... } ``` These can be constructed with the new method: ```zig pub fn dirname(self: LazyPath) LazyPath ``` For the cases where the LazyPath is already known (`.path`, `.cwd_relative`, and `dependency`) this is evaluated right away. For dirnames of generated files and their dirnames, this is evaluated at getPath time. dirname calls can be chained, but for safety, they are not allowed to escape outside a root defined for each case: - path: This is relative to the build root, so dirname can't escape outside the build root. - generated: Can't escape the zig-cache. - cwd_relative: This can be a relative or absolute path. If relative, can't escape the current directory, and if absolute, can't go beyond root (/). - dependency: Can't escape the dependency's root directory. Testing: I've included a standalone case for many of the happy cases. I couldn't find an easy way to test the negatives, though, because tests cannot yet expect panics.
2024-01-04 15:47:28 -08:00
}
}
Run: add output directory arguments This allows running commands that take an output directory argument. The main thing that was needed for this feature was generated file subpaths, to allow access to the files in a generated directory. Additionally, a minor change was required to so that the correct directory is created for output directory args.
2024-05-04 15:12:24 -04:00
std.Build.LazyPath: add getPath3; deprecate getPath2 and getPath The goal is to move towards using `std.Build.Cache.Path` instead of absolute path names. This was helpful for implementing file watching integration to the InstallDir Step
2024-07-09 23:14:18 -07:00
return file_path.join(src_builder.allocator, gen.sub_path) catch @panic("OOM");
},
.dependency => |dep| return .{
.root_dir = dep.dependency.builder.build_root,
.sub_path = dep.sub_path,
build/LazyPath: Add dirname (#18371) Adds a variant to the LazyPath union representing a parent directory of a generated path. ```zig const LazyPath = union(enum) { generated_dirname: struct { generated: *const GeneratedFile, up: usize, }, // ... } ``` These can be constructed with the new method: ```zig pub fn dirname(self: LazyPath) LazyPath ``` For the cases where the LazyPath is already known (`.path`, `.cwd_relative`, and `dependency`) this is evaluated right away. For dirnames of generated files and their dirnames, this is evaluated at getPath time. dirname calls can be chained, but for safety, they are not allowed to escape outside a root defined for each case: - path: This is relative to the build root, so dirname can't escape outside the build root. - generated: Can't escape the zig-cache. - cwd_relative: This can be a relative or absolute path. If relative, can't escape the current directory, and if absolute, can't go beyond root (/). - dependency: Can't escape the dependency's root directory. Testing: I've included a standalone case for many of the happy cases. I couldn't find an easy way to test the negatives, though, because tests cannot yet expect panics.
2024-01-04 15:47:28 -08:00
},
std.Build: improve debugging of misconfigured steps * Step.init() now takes an options struct * Step.init() now captures a small stack trace and stores it in the Step so that it can be accessed when printing user-friendly debugging information, including the lines of code that created the step in question.
2023-02-14 12:47:45 -07:00
}
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
Build: add install commands to `--verbose` output
2025-06-13 12:01:59 -04:00
pub fn basename(lazy_path: LazyPath, src_builder: *Build, asking_step: ?*Step) []const u8 {
return fs.path.basename(switch (lazy_path) {
.src_path => |sp| sp.sub_path,
.cwd_relative => |sub_path| sub_path,
.generated => |gen| if (gen.sub_path.len > 0)
gen.sub_path
else
gen.file.getPath2(src_builder, asking_step),
.dependency => |dep| dep.sub_path,
});
}
remove deprecated LazyPath.path union tag
2024-04-11 14:02:47 -07:00
/// Copies the internal strings.
///
/// The `b` parameter is only used for its allocator. All *Build instances
/// share the same allocator.
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
pub fn dupe(lazy_path: LazyPath, b: *Build) LazyPath {
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
return lazy_path.dupeInner(b.allocator);
}
fn dupeInner(lazy_path: LazyPath, allocator: std.mem.Allocator) LazyPath {
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
return switch (lazy_path) {
introduce std.Build.path; deprecate LazyPath.relative This adds the *std.Build owner to LazyPath so that lazy paths returned from a dependency can be used in the application without friction or footguns. closes #19313
2024-04-09 18:23:48 -07:00
.src_path => |sp| .{ .src_path = .{
.owner = sp.owner,
remove deprecated LazyPath.path union tag
2024-04-11 14:02:47 -07:00
.sub_path = sp.owner.dupePath(sp.sub_path),
introduce std.Build.path; deprecate LazyPath.relative This adds the *std.Build owner to LazyPath so that lazy paths returned from a dependency can be used in the application without friction or footguns. closes #19313
2024-04-09 18:23:48 -07:00
} },
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
.cwd_relative => |p| .{ .cwd_relative = dupePathInner(allocator, p) },
Run: add output directory arguments This allows running commands that take an output directory argument. The main thing that was needed for this feature was generated file subpaths, to allow access to the files in a generated directory. Additionally, a minor change was required to so that the correct directory is created for output directory args.
2024-05-04 15:12:24 -04:00
.generated => |gen| .{ .generated = .{
.file = gen.file,
.up = gen.up,
Build: Add `option(LazyPath, ...)` support Also adds support for `[]const LazyPath` in a similar vein, and refactors a few other bits of code.
2024-10-05 00:58:48 +02:00
.sub_path = dupePathInner(allocator, gen.sub_path),
Run: add output directory arguments This allows running commands that take an output directory argument. The main thing that was needed for this feature was generated file subpaths, to allow access to the files in a generated directory. Additionally, a minor change was required to so that the correct directory is created for output directory args.
2024-05-04 15:12:24 -04:00
} },
std.Build: duplicate sub_path for LazyPath's dependency variant
2025-10-07 16:12:16 +01:00
.dependency => |dep| .{ .dependency = .{
.dependency = dep.dependency,
.sub_path = dupePathInner(allocator, dep.sub_path),
} },
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
};
}
};
build/LazyPath: Add dirname (#18371) Adds a variant to the LazyPath union representing a parent directory of a generated path. ```zig const LazyPath = union(enum) { generated_dirname: struct { generated: *const GeneratedFile, up: usize, }, // ... } ``` These can be constructed with the new method: ```zig pub fn dirname(self: LazyPath) LazyPath ``` For the cases where the LazyPath is already known (`.path`, `.cwd_relative`, and `dependency`) this is evaluated right away. For dirnames of generated files and their dirnames, this is evaluated at getPath time. dirname calls can be chained, but for safety, they are not allowed to escape outside a root defined for each case: - path: This is relative to the build root, so dirname can't escape outside the build root. - generated: Can't escape the zig-cache. - cwd_relative: This can be a relative or absolute path. If relative, can't escape the current directory, and if absolute, can't go beyond root (/). - dependency: Can't escape the dependency's root directory. Testing: I've included a standalone case for many of the happy cases. I couldn't find an easy way to test the negatives, though, because tests cannot yet expect panics.
2024-01-04 15:47:28 -08:00
fn dumpBadDirnameHelp(
fail_step: ?*Step,
asking_step: ?*Step,
comptime msg: []const u8,
args: anytype,
) anyerror!void {
std.debug.lockStderrWriter: also return ttyconf `std.Io.tty.Config.detect` may be an expensive check (e.g. involving syscalls), and doing it every time we need to print isn't really necessary; under normal usage, we can compute the value once and cache it for the whole program's execution. Since anyone outputting to stderr may reasonably want this information (in fact they are very likely to), it makes sense to cache it and return it from `lockStderrWriter`. Call sites who do not need it will experience no significant overhead, and can just ignore the TTY config with a `const w, _` destructure.
2025-10-28 12:42:05 +00:00
const w, const tty_config = debug.lockStderrWriter(&.{});
fix build runner
2025-07-02 11:16:20 -07:00
defer debug.unlockStderrWriter();
build/LazyPath: Add dirname (#18371) Adds a variant to the LazyPath union representing a parent directory of a generated path. ```zig const LazyPath = union(enum) { generated_dirname: struct { generated: *const GeneratedFile, up: usize, }, // ... } ``` These can be constructed with the new method: ```zig pub fn dirname(self: LazyPath) LazyPath ``` For the cases where the LazyPath is already known (`.path`, `.cwd_relative`, and `dependency`) this is evaluated right away. For dirnames of generated files and their dirnames, this is evaluated at getPath time. dirname calls can be chained, but for safety, they are not allowed to escape outside a root defined for each case: - path: This is relative to the build root, so dirname can't escape outside the build root. - generated: Can't escape the zig-cache. - cwd_relative: This can be a relative or absolute path. If relative, can't escape the current directory, and if absolute, can't go beyond root (/). - dependency: Can't escape the dependency's root directory. Testing: I've included a standalone case for many of the happy cases. I couldn't find an easy way to test the negatives, though, because tests cannot yet expect panics.
2024-01-04 15:47:28 -08:00
try w.print(msg, args);
if (fail_step) |s| {
tty_config.setColor(w, .red) catch {};
fix build runner
2025-07-02 11:16:20 -07:00
try w.writeAll(" The step was created by this stack trace:\n");
build/LazyPath: Add dirname (#18371) Adds a variant to the LazyPath union representing a parent directory of a generated path. ```zig const LazyPath = union(enum) { generated_dirname: struct { generated: *const GeneratedFile, up: usize, }, // ... } ``` These can be constructed with the new method: ```zig pub fn dirname(self: LazyPath) LazyPath ``` For the cases where the LazyPath is already known (`.path`, `.cwd_relative`, and `dependency`) this is evaluated right away. For dirnames of generated files and their dirnames, this is evaluated at getPath time. dirname calls can be chained, but for safety, they are not allowed to escape outside a root defined for each case: - path: This is relative to the build root, so dirname can't escape outside the build root. - generated: Can't escape the zig-cache. - cwd_relative: This can be a relative or absolute path. If relative, can't escape the current directory, and if absolute, can't go beyond root (/). - dependency: Can't escape the dependency's root directory. Testing: I've included a standalone case for many of the happy cases. I couldn't find an easy way to test the negatives, though, because tests cannot yet expect panics.
2024-01-04 15:47:28 -08:00
tty_config.setColor(w, .reset) catch {};
fix build runner
2025-07-02 11:16:20 -07:00
s.dump(w, tty_config);
build/LazyPath: Add dirname (#18371) Adds a variant to the LazyPath union representing a parent directory of a generated path. ```zig const LazyPath = union(enum) { generated_dirname: struct { generated: *const GeneratedFile, up: usize, }, // ... } ``` These can be constructed with the new method: ```zig pub fn dirname(self: LazyPath) LazyPath ``` For the cases where the LazyPath is already known (`.path`, `.cwd_relative`, and `dependency`) this is evaluated right away. For dirnames of generated files and their dirnames, this is evaluated at getPath time. dirname calls can be chained, but for safety, they are not allowed to escape outside a root defined for each case: - path: This is relative to the build root, so dirname can't escape outside the build root. - generated: Can't escape the zig-cache. - cwd_relative: This can be a relative or absolute path. If relative, can't escape the current directory, and if absolute, can't go beyond root (/). - dependency: Can't escape the dependency's root directory. Testing: I've included a standalone case for many of the happy cases. I couldn't find an easy way to test the negatives, though, because tests cannot yet expect panics.
2024-01-04 15:47:28 -08:00
}
if (asking_step) |as| {
tty_config.setColor(w, .red) catch {};
fix build runner
2025-07-02 11:16:20 -07:00
try w.print(" The step '{s}' that is missing a dependency on the above step was created by this stack trace:\n", .{as.name});
build/LazyPath: Add dirname (#18371) Adds a variant to the LazyPath union representing a parent directory of a generated path. ```zig const LazyPath = union(enum) { generated_dirname: struct { generated: *const GeneratedFile, up: usize, }, // ... } ``` These can be constructed with the new method: ```zig pub fn dirname(self: LazyPath) LazyPath ``` For the cases where the LazyPath is already known (`.path`, `.cwd_relative`, and `dependency`) this is evaluated right away. For dirnames of generated files and their dirnames, this is evaluated at getPath time. dirname calls can be chained, but for safety, they are not allowed to escape outside a root defined for each case: - path: This is relative to the build root, so dirname can't escape outside the build root. - generated: Can't escape the zig-cache. - cwd_relative: This can be a relative or absolute path. If relative, can't escape the current directory, and if absolute, can't go beyond root (/). - dependency: Can't escape the dependency's root directory. Testing: I've included a standalone case for many of the happy cases. I couldn't find an easy way to test the negatives, though, because tests cannot yet expect panics.
2024-01-04 15:47:28 -08:00
tty_config.setColor(w, .reset) catch {};
fix build runner
2025-07-02 11:16:20 -07:00
as.dump(w, tty_config);
build/LazyPath: Add dirname (#18371) Adds a variant to the LazyPath union representing a parent directory of a generated path. ```zig const LazyPath = union(enum) { generated_dirname: struct { generated: *const GeneratedFile, up: usize, }, // ... } ``` These can be constructed with the new method: ```zig pub fn dirname(self: LazyPath) LazyPath ``` For the cases where the LazyPath is already known (`.path`, `.cwd_relative`, and `dependency`) this is evaluated right away. For dirnames of generated files and their dirnames, this is evaluated at getPath time. dirname calls can be chained, but for safety, they are not allowed to escape outside a root defined for each case: - path: This is relative to the build root, so dirname can't escape outside the build root. - generated: Can't escape the zig-cache. - cwd_relative: This can be a relative or absolute path. If relative, can't escape the current directory, and if absolute, can't go beyond root (/). - dependency: Can't escape the dependency's root directory. Testing: I've included a standalone case for many of the happy cases. I couldn't find an easy way to test the negatives, though, because tests cannot yet expect panics.
2024-01-04 15:47:28 -08:00
}
tty_config.setColor(w, .red) catch {};
fix build runner
2025-07-02 11:16:20 -07:00
try w.writeAll(" Hope that helps. Proceeding to panic.\n");
build/LazyPath: Add dirname (#18371) Adds a variant to the LazyPath union representing a parent directory of a generated path. ```zig const LazyPath = union(enum) { generated_dirname: struct { generated: *const GeneratedFile, up: usize, }, // ... } ``` These can be constructed with the new method: ```zig pub fn dirname(self: LazyPath) LazyPath ``` For the cases where the LazyPath is already known (`.path`, `.cwd_relative`, and `dependency`) this is evaluated right away. For dirnames of generated files and their dirnames, this is evaluated at getPath time. dirname calls can be chained, but for safety, they are not allowed to escape outside a root defined for each case: - path: This is relative to the build root, so dirname can't escape outside the build root. - generated: Can't escape the zig-cache. - cwd_relative: This can be a relative or absolute path. If relative, can't escape the current directory, and if absolute, can't go beyond root (/). - dependency: Can't escape the dependency's root directory. Testing: I've included a standalone case for many of the happy cases. I couldn't find an easy way to test the negatives, though, because tests cannot yet expect panics.
2024-01-04 15:47:28 -08:00
tty_config.setColor(w, .reset) catch {};
}
build system: follow-up enhancements regarding LazyPath * introduce LazyPath.cwd_relative variant and use it for --zig-lib-dir. closes #12685 * move overrideZigLibDir and setMainPkgPath to options fields set once and then never mutated. * avoid introducing Build/util.zig * use doc comments for deprecation notices so that they show up in generated documentation. * introduce InstallArtifact.Options, accept it as a parameter to addInstallArtifact, and move override_dest_dir into it. Instead of configuring the installation via Compile step, configure the installation via the InstallArtifact step. In retrospect this is obvious. * remove calls to pushInstalledFile in InstallArtifact. See #14943 * rewrite InstallArtifact to not incorrectly observe whether a Compile step has any generated outputs. InstallArtifact is meant to trigger output generation. * fix child process evaluation code handling of `-fno-emit-bin`. * don't store out_h_filename, out_ll_filename, etc., pointlessly. these are all just simple extensions appended to the root name. * make emit_directory optional. It's possible to have nothing outputted, for example, if you're just type-checking. * avoid passing -femit-foo/-fno-emit-foo when it is the default * rename ConfigHeader.getTemplate to getOutput * deprecate addOptionArtifact * update the random number seed of Options step caching. * avoid using `inline for` pointlessly * avoid using `override_Dest_dir` pointlessly * avoid emitting an executable pointlessly in test cases Removes forceBuild and forceEmit. Let's consider these additions separately. Nearly all of the usage sites were suspicious.
2023-07-29 23:57:52 -07:00
/// In this function the stderr mutex has already been locked.
pub fn dumpBadGetPathHelp(
s: *Step,
std.Io: delete GenericReader and delete deprecated alias std.io
2025-08-27 21:20:18 -07:00
w: *std.Io.Writer,
tty_config: std.Io.tty.Config,
build system: follow-up enhancements regarding LazyPath * introduce LazyPath.cwd_relative variant and use it for --zig-lib-dir. closes #12685 * move overrideZigLibDir and setMainPkgPath to options fields set once and then never mutated. * avoid introducing Build/util.zig * use doc comments for deprecation notices so that they show up in generated documentation. * introduce InstallArtifact.Options, accept it as a parameter to addInstallArtifact, and move override_dest_dir into it. Instead of configuring the installation via Compile step, configure the installation via the InstallArtifact step. In retrospect this is obvious. * remove calls to pushInstalledFile in InstallArtifact. See #14943 * rewrite InstallArtifact to not incorrectly observe whether a Compile step has any generated outputs. InstallArtifact is meant to trigger output generation. * fix child process evaluation code handling of `-fno-emit-bin`. * don't store out_h_filename, out_ll_filename, etc., pointlessly. these are all just simple extensions appended to the root name. * make emit_directory optional. It's possible to have nothing outputted, for example, if you're just type-checking. * avoid passing -femit-foo/-fno-emit-foo when it is the default * rename ConfigHeader.getTemplate to getOutput * deprecate addOptionArtifact * update the random number seed of Options step caching. * avoid using `inline for` pointlessly * avoid using `override_Dest_dir` pointlessly * avoid emitting an executable pointlessly in test cases Removes forceBuild and forceEmit. Let's consider these additions separately. Nearly all of the usage sites were suspicious.
2023-07-29 23:57:52 -07:00
src_builder: *Build,
asking_step: ?*Step,
) anyerror!void {
try w.print(
\\getPath() was called on a GeneratedFile that wasn't built yet.
\\ source package path: {s}
\\ Is there a missing Step dependency on step '{s}'?
\\
, .{
src_builder.build_root.path orelse ".",
s.name,
});
tty_config.setColor(w, .red) catch {};
fix build runner
2025-07-02 11:16:20 -07:00
try w.writeAll(" The step was created by this stack trace:\n");
build system: follow-up enhancements regarding LazyPath * introduce LazyPath.cwd_relative variant and use it for --zig-lib-dir. closes #12685 * move overrideZigLibDir and setMainPkgPath to options fields set once and then never mutated. * avoid introducing Build/util.zig * use doc comments for deprecation notices so that they show up in generated documentation. * introduce InstallArtifact.Options, accept it as a parameter to addInstallArtifact, and move override_dest_dir into it. Instead of configuring the installation via Compile step, configure the installation via the InstallArtifact step. In retrospect this is obvious. * remove calls to pushInstalledFile in InstallArtifact. See #14943 * rewrite InstallArtifact to not incorrectly observe whether a Compile step has any generated outputs. InstallArtifact is meant to trigger output generation. * fix child process evaluation code handling of `-fno-emit-bin`. * don't store out_h_filename, out_ll_filename, etc., pointlessly. these are all just simple extensions appended to the root name. * make emit_directory optional. It's possible to have nothing outputted, for example, if you're just type-checking. * avoid passing -femit-foo/-fno-emit-foo when it is the default * rename ConfigHeader.getTemplate to getOutput * deprecate addOptionArtifact * update the random number seed of Options step caching. * avoid using `inline for` pointlessly * avoid using `override_Dest_dir` pointlessly * avoid emitting an executable pointlessly in test cases Removes forceBuild and forceEmit. Let's consider these additions separately. Nearly all of the usage sites were suspicious.
2023-07-29 23:57:52 -07:00
tty_config.setColor(w, .reset) catch {};
fix build runner
2025-07-02 11:16:20 -07:00
s.dump(w, tty_config);
build system: follow-up enhancements regarding LazyPath * introduce LazyPath.cwd_relative variant and use it for --zig-lib-dir. closes #12685 * move overrideZigLibDir and setMainPkgPath to options fields set once and then never mutated. * avoid introducing Build/util.zig * use doc comments for deprecation notices so that they show up in generated documentation. * introduce InstallArtifact.Options, accept it as a parameter to addInstallArtifact, and move override_dest_dir into it. Instead of configuring the installation via Compile step, configure the installation via the InstallArtifact step. In retrospect this is obvious. * remove calls to pushInstalledFile in InstallArtifact. See #14943 * rewrite InstallArtifact to not incorrectly observe whether a Compile step has any generated outputs. InstallArtifact is meant to trigger output generation. * fix child process evaluation code handling of `-fno-emit-bin`. * don't store out_h_filename, out_ll_filename, etc., pointlessly. these are all just simple extensions appended to the root name. * make emit_directory optional. It's possible to have nothing outputted, for example, if you're just type-checking. * avoid passing -femit-foo/-fno-emit-foo when it is the default * rename ConfigHeader.getTemplate to getOutput * deprecate addOptionArtifact * update the random number seed of Options step caching. * avoid using `inline for` pointlessly * avoid using `override_Dest_dir` pointlessly * avoid emitting an executable pointlessly in test cases Removes forceBuild and forceEmit. Let's consider these additions separately. Nearly all of the usage sites were suspicious.
2023-07-29 23:57:52 -07:00
if (asking_step) |as| {
tty_config.setColor(w, .red) catch {};
fix build runner
2025-07-02 11:16:20 -07:00
try w.print(" The step '{s}' that is missing a dependency on the above step was created by this stack trace:\n", .{as.name});
build system: follow-up enhancements regarding LazyPath * introduce LazyPath.cwd_relative variant and use it for --zig-lib-dir. closes #12685 * move overrideZigLibDir and setMainPkgPath to options fields set once and then never mutated. * avoid introducing Build/util.zig * use doc comments for deprecation notices so that they show up in generated documentation. * introduce InstallArtifact.Options, accept it as a parameter to addInstallArtifact, and move override_dest_dir into it. Instead of configuring the installation via Compile step, configure the installation via the InstallArtifact step. In retrospect this is obvious. * remove calls to pushInstalledFile in InstallArtifact. See #14943 * rewrite InstallArtifact to not incorrectly observe whether a Compile step has any generated outputs. InstallArtifact is meant to trigger output generation. * fix child process evaluation code handling of `-fno-emit-bin`. * don't store out_h_filename, out_ll_filename, etc., pointlessly. these are all just simple extensions appended to the root name. * make emit_directory optional. It's possible to have nothing outputted, for example, if you're just type-checking. * avoid passing -femit-foo/-fno-emit-foo when it is the default * rename ConfigHeader.getTemplate to getOutput * deprecate addOptionArtifact * update the random number seed of Options step caching. * avoid using `inline for` pointlessly * avoid using `override_Dest_dir` pointlessly * avoid emitting an executable pointlessly in test cases Removes forceBuild and forceEmit. Let's consider these additions separately. Nearly all of the usage sites were suspicious.
2023-07-29 23:57:52 -07:00
tty_config.setColor(w, .reset) catch {};
fix build runner
2025-07-02 11:16:20 -07:00
as.dump(w, tty_config);
build system: follow-up enhancements regarding LazyPath * introduce LazyPath.cwd_relative variant and use it for --zig-lib-dir. closes #12685 * move overrideZigLibDir and setMainPkgPath to options fields set once and then never mutated. * avoid introducing Build/util.zig * use doc comments for deprecation notices so that they show up in generated documentation. * introduce InstallArtifact.Options, accept it as a parameter to addInstallArtifact, and move override_dest_dir into it. Instead of configuring the installation via Compile step, configure the installation via the InstallArtifact step. In retrospect this is obvious. * remove calls to pushInstalledFile in InstallArtifact. See #14943 * rewrite InstallArtifact to not incorrectly observe whether a Compile step has any generated outputs. InstallArtifact is meant to trigger output generation. * fix child process evaluation code handling of `-fno-emit-bin`. * don't store out_h_filename, out_ll_filename, etc., pointlessly. these are all just simple extensions appended to the root name. * make emit_directory optional. It's possible to have nothing outputted, for example, if you're just type-checking. * avoid passing -femit-foo/-fno-emit-foo when it is the default * rename ConfigHeader.getTemplate to getOutput * deprecate addOptionArtifact * update the random number seed of Options step caching. * avoid using `inline for` pointlessly * avoid using `override_Dest_dir` pointlessly * avoid emitting an executable pointlessly in test cases Removes forceBuild and forceEmit. Let's consider these additions separately. Nearly all of the usage sites were suspicious.
2023-07-29 23:57:52 -07:00
}
tty_config.setColor(w, .red) catch {};
fix build runner
2025-07-02 11:16:20 -07:00
try w.writeAll(" Hope that helps. Proceeding to panic.\n");
build system: follow-up enhancements regarding LazyPath * introduce LazyPath.cwd_relative variant and use it for --zig-lib-dir. closes #12685 * move overrideZigLibDir and setMainPkgPath to options fields set once and then never mutated. * avoid introducing Build/util.zig * use doc comments for deprecation notices so that they show up in generated documentation. * introduce InstallArtifact.Options, accept it as a parameter to addInstallArtifact, and move override_dest_dir into it. Instead of configuring the installation via Compile step, configure the installation via the InstallArtifact step. In retrospect this is obvious. * remove calls to pushInstalledFile in InstallArtifact. See #14943 * rewrite InstallArtifact to not incorrectly observe whether a Compile step has any generated outputs. InstallArtifact is meant to trigger output generation. * fix child process evaluation code handling of `-fno-emit-bin`. * don't store out_h_filename, out_ll_filename, etc., pointlessly. these are all just simple extensions appended to the root name. * make emit_directory optional. It's possible to have nothing outputted, for example, if you're just type-checking. * avoid passing -femit-foo/-fno-emit-foo when it is the default * rename ConfigHeader.getTemplate to getOutput * deprecate addOptionArtifact * update the random number seed of Options step caching. * avoid using `inline for` pointlessly * avoid using `override_Dest_dir` pointlessly * avoid emitting an executable pointlessly in test cases Removes forceBuild and forceEmit. Let's consider these additions separately. Nearly all of the usage sites were suspicious.
2023-07-29 23:57:52 -07:00
tty_config.setColor(w, .reset) catch {};
}
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
pub const InstallDir = union(enum) {
prefix: void,
lib: void,
bin: void,
header: void,
/// A path relative to the prefix
custom: []const u8,
/// Duplicates the install directory including the path if set to custom.
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
pub fn dupe(dir: InstallDir, builder: *Build) InstallDir {
if (dir == .custom) {
return .{ .custom = builder.dupe(dir.custom) };
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
} else {
Build: cleanup * `doc/langref` formatting * upgrade `.{ .path = "..." }` to `b.path("...")` * avoid using arguments named `self` * make `Build.Step.Id` usage more consistent * add `Build.pathResolve` * use `pathJoin` and `pathResolve` everywhere * make sure `Build.LazyPath.getPath2` returns an absolute path
2024-05-04 14:29:17 -04:00
return dir;
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
}
};
re-enable CLI tests CLI tests are now ported over to the new std.Build API and thus work properly with concurrency. * add `std.Build.addCheckFile` for creating a `std.Build.CheckFileStep`. * add `std.Build.makeTempPath`. This function is intended to be called in the `configure` phase only. It returns an absolute directory path, which is potentially going to be a source of API breakage in the future, so keep that in mind when using this function. * add `std.Build.CheckFileStep.setName`. * `std.Build.CheckFileStep`: better error message when reading the input file fails. * `std.Build.RunStep`: add a `has_side_effects` flag for when you need to override the autodetection. * `std.Build.RunStep`: add the ability to obtain a FileSource for the directory that contains the written files. * `std.Build.WriteFileStep`: add a way to write bytes to an arbitrary path - absolute or relative to the package root. Be careful with this because it updates source files. This should not be used as part of the normal build process, but as a utility occasionally run by a developer with intent to modify source files and then commit those changes to version control. A file added this way is not available with `getFileSource`.
2023-03-06 22:44:36 -07:00
/// This function is intended to be called in the `configure` phase only.
/// It returns an absolute directory path, which is potentially going to be a
/// source of API breakage in the future, so keep that in mind when using this
/// function.
pub fn makeTempPath(b: *Build) []const u8 {
const rand_int = std.crypto.random.int(u64);
add std.fmt.hex converts an unsigned integer into an array
2024-07-19 17:39:55 -07:00
const tmp_dir_sub_path = "tmp" ++ fs.path.sep_str ++ std.fmt.hex(rand_int);
re-enable CLI tests CLI tests are now ported over to the new std.Build API and thus work properly with concurrency. * add `std.Build.addCheckFile` for creating a `std.Build.CheckFileStep`. * add `std.Build.makeTempPath`. This function is intended to be called in the `configure` phase only. It returns an absolute directory path, which is potentially going to be a source of API breakage in the future, so keep that in mind when using this function. * add `std.Build.CheckFileStep.setName`. * `std.Build.CheckFileStep`: better error message when reading the input file fails. * `std.Build.RunStep`: add a `has_side_effects` flag for when you need to override the autodetection. * `std.Build.RunStep`: add the ability to obtain a FileSource for the directory that contains the written files. * `std.Build.WriteFileStep`: add a way to write bytes to an arbitrary path - absolute or relative to the package root. Be careful with this because it updates source files. This should not be used as part of the normal build process, but as a utility occasionally run by a developer with intent to modify source files and then commit those changes to version control. A file added this way is not available with `getFileSource`.
2023-03-06 22:44:36 -07:00
const result_path = b.cache_root.join(b.allocator, &.{tmp_dir_sub_path}) catch @panic("OOM");
fix std.Build.OptionsStep * use the same hash function as the rest of the steps * fix race condition due to a macOS oddity. * fix race condition due to file truncation (rename into place instead) * integrate with marking Step.result_cached. check if the file already exists with fs.access before doing anything else. * use a directory so that the file basename can be "options.zig" instead of a hash digest. * better error reporting in case of file system failures.
2023-03-18 18:32:43 -07:00
b.cache_root.handle.makePath(tmp_dir_sub_path) catch |err| {
re-enable CLI tests CLI tests are now ported over to the new std.Build API and thus work properly with concurrency. * add `std.Build.addCheckFile` for creating a `std.Build.CheckFileStep`. * add `std.Build.makeTempPath`. This function is intended to be called in the `configure` phase only. It returns an absolute directory path, which is potentially going to be a source of API breakage in the future, so keep that in mind when using this function. * add `std.Build.CheckFileStep.setName`. * `std.Build.CheckFileStep`: better error message when reading the input file fails. * `std.Build.RunStep`: add a `has_side_effects` flag for when you need to override the autodetection. * `std.Build.RunStep`: add the ability to obtain a FileSource for the directory that contains the written files. * `std.Build.WriteFileStep`: add a way to write bytes to an arbitrary path - absolute or relative to the package root. Be careful with this because it updates source files. This should not be used as part of the normal build process, but as a utility occasionally run by a developer with intent to modify source files and then commit those changes to version control. A file added this way is not available with `getFileSource`.
2023-03-06 22:44:36 -07:00
std.debug.print("unable to make tmp path '{s}': {s}\n", .{
result_path, @errorName(err),
});
};
return result_path;
}
zig build system: change target, compilation, and module APIs Introduce the concept of "target query" and "resolved target". A target query is what the user specifies, with some things left to default. A resolved target has the default things discovered and populated. In the future, std.zig.CrossTarget will be rename to std.Target.Query. Introduces `std.Build.resolveTargetQuery` to get from one to the other. The concept of `main_mod_path` is gone, no longer supported. You have to put the root source file at the module root now. * remove deprecated API * update build.zig for the breaking API changes in this branch * move std.Build.Step.Compile.BuildId to std.zig.BuildId * add more options to std.Build.ExecutableOptions, std.Build.ObjectOptions, std.Build.SharedLibraryOptions, std.Build.StaticLibraryOptions, and std.Build.TestOptions. * remove `std.Build.constructCMacro`. There is no use for this API. * deprecate `std.Build.Step.Compile.defineCMacro`. Instead, `std.Build.Module.addCMacro` is provided. - remove `std.Build.Step.Compile.defineCMacroRaw`. * deprecate `std.Build.Step.Compile.linkFrameworkNeeded` - use `std.Build.Module.linkFramework` * deprecate `std.Build.Step.Compile.linkFrameworkWeak` - use `std.Build.Module.linkFramework` * move more logic into `std.Build.Module` * allow `target` and `optimize` to be `null` when creating a Module. Along with other fields, those unspecified options will be inherited from parent `Module` when inserted into an import table. * the `target` field of `addExecutable` is now required. pass `b.host` to get the host target.
2023-12-02 21:51:34 -07:00
/// A pair of target query and fully resolved target.
/// This type is generally required by build system API that need to be given a
/// target. The query is kept because the Zig toolchain needs to know which parts
/// of the target are "native". This can apply to the CPU, the OS, or even the ABI.
pub const ResolvedTarget = struct {
rename std.zig.CrossTarget to std.Target.Query
2023-12-04 12:35:04 -07:00
query: Target.Query,
std.Build.ResolvedTarget: rename target field to result This change is seemingly insignificant but I actually agonized over this for three days. Some other things I considered: * (status quo in master branch) make Compile step creation functions accept a Target.Query and delete the ResolvedTarget struct. - downside: redundantly resolve target queries many times * same as before but additionally add a hash map to cache target query resolutions. - downside: now there is a hash map that doesn't actually need to exist, just to make the API more ergonomic. * add is_native_os and is_native_abi fields to std.Target and use it directly as the result of resolving a target query. - downside: they really don't belong there. They would be available as comptime booleans via `@import("builtin")` but they should not be exposed that way. With this change the downsides are: * the option name of addExecutable and friends is `target` instead of `resolved_target` matching the type name. - upside: this does not break compatibility with existing build scripts * you likely end up seeing `target.result.cpu.arch` rather than `target.cpu.arch`. - upside: this is an improvement over `target.target.cpu.arch` which it was before this commit. - downside: `b.host.target` is now `b.host.result`.
2023-12-05 16:09:07 -07:00
result: Target,
zig build system: change target, compilation, and module APIs Introduce the concept of "target query" and "resolved target". A target query is what the user specifies, with some things left to default. A resolved target has the default things discovered and populated. In the future, std.zig.CrossTarget will be rename to std.Target.Query. Introduces `std.Build.resolveTargetQuery` to get from one to the other. The concept of `main_mod_path` is gone, no longer supported. You have to put the root source file at the module root now. * remove deprecated API * update build.zig for the breaking API changes in this branch * move std.Build.Step.Compile.BuildId to std.zig.BuildId * add more options to std.Build.ExecutableOptions, std.Build.ObjectOptions, std.Build.SharedLibraryOptions, std.Build.StaticLibraryOptions, and std.Build.TestOptions. * remove `std.Build.constructCMacro`. There is no use for this API. * deprecate `std.Build.Step.Compile.defineCMacro`. Instead, `std.Build.Module.addCMacro` is provided. - remove `std.Build.Step.Compile.defineCMacroRaw`. * deprecate `std.Build.Step.Compile.linkFrameworkNeeded` - use `std.Build.Module.linkFramework` * deprecate `std.Build.Step.Compile.linkFrameworkWeak` - use `std.Build.Module.linkFramework` * move more logic into `std.Build.Module` * allow `target` and `optimize` to be `null` when creating a Module. Along with other fields, those unspecified options will be inherited from parent `Module` when inserted into an import table. * the `target` field of `addExecutable` is now required. pass `b.host` to get the host target.
2023-12-02 21:51:34 -07:00
};
/// Converts a target query into a fully resolved target that can be passed to
/// various parts of the API.
rename std.zig.CrossTarget to std.Target.Query
2023-12-04 12:35:04 -07:00
pub fn resolveTargetQuery(b: *Build, query: Target.Query) ResolvedTarget {
std.Build.resolveTargetQuery: fix ignoring ofmt for native
2024-02-01 19:22:05 -07:00
if (query.isNative()) {
std.Build: revert --host-target, --host-cpu, --host-dynamic-linker This is a partial revert of 105db13536b4dc2affe130cb8d2eee6c97c89bcd. As we learned from Void Linux packaging, these options are not actually helpful since the distribution package manager may very well want to cross-compile the packages that it is building. So, let's not overcomplicate things. There are already the standard options: -Dtarget, -Dcpu, and -Ddynamic-linker. These options are generally provided when the project generates machine code artifacts, however, there may be a project that does no such thing, in which case it makes sense for these options to be missing. The Zig Build System is a general-purpose build system, after all.
2024-04-17 17:57:03 -07:00
// Hot path. This is faster than querying the native CPU and OS again.
return b.graph.host;
std.Build.resolveTargetQuery: fix ignoring ofmt for native
2024-02-01 19:22:05 -07:00
}
std.zig.system: upgrade to std.Io.Reader
2025-10-06 18:34:51 -07:00
const io = b.graph.io;
zig build system: change target, compilation, and module APIs Introduce the concept of "target query" and "resolved target". A target query is what the user specifies, with some things left to default. A resolved target has the default things discovered and populated. In the future, std.zig.CrossTarget will be rename to std.Target.Query. Introduces `std.Build.resolveTargetQuery` to get from one to the other. The concept of `main_mod_path` is gone, no longer supported. You have to put the root source file at the module root now. * remove deprecated API * update build.zig for the breaking API changes in this branch * move std.Build.Step.Compile.BuildId to std.zig.BuildId * add more options to std.Build.ExecutableOptions, std.Build.ObjectOptions, std.Build.SharedLibraryOptions, std.Build.StaticLibraryOptions, and std.Build.TestOptions. * remove `std.Build.constructCMacro`. There is no use for this API. * deprecate `std.Build.Step.Compile.defineCMacro`. Instead, `std.Build.Module.addCMacro` is provided. - remove `std.Build.Step.Compile.defineCMacroRaw`. * deprecate `std.Build.Step.Compile.linkFrameworkNeeded` - use `std.Build.Module.linkFramework` * deprecate `std.Build.Step.Compile.linkFrameworkWeak` - use `std.Build.Module.linkFramework` * move more logic into `std.Build.Module` * allow `target` and `optimize` to be `null` when creating a Module. Along with other fields, those unspecified options will be inherited from parent `Module` when inserted into an import table. * the `target` field of `addExecutable` is now required. pass `b.host` to get the host target.
2023-12-02 21:51:34 -07:00
return .{
.query = query,
std.zig.system: upgrade to std.Io.Reader
2025-10-06 18:34:51 -07:00
.result = std.zig.system.resolveTargetQuery(io, query) catch
std.Target: add DynamicLinker
2023-12-04 15:26:57 -07:00
@panic("unable to resolve target query"),
zig build system: change target, compilation, and module APIs Introduce the concept of "target query" and "resolved target". A target query is what the user specifies, with some things left to default. A resolved target has the default things discovered and populated. In the future, std.zig.CrossTarget will be rename to std.Target.Query. Introduces `std.Build.resolveTargetQuery` to get from one to the other. The concept of `main_mod_path` is gone, no longer supported. You have to put the root source file at the module root now. * remove deprecated API * update build.zig for the breaking API changes in this branch * move std.Build.Step.Compile.BuildId to std.zig.BuildId * add more options to std.Build.ExecutableOptions, std.Build.ObjectOptions, std.Build.SharedLibraryOptions, std.Build.StaticLibraryOptions, and std.Build.TestOptions. * remove `std.Build.constructCMacro`. There is no use for this API. * deprecate `std.Build.Step.Compile.defineCMacro`. Instead, `std.Build.Module.addCMacro` is provided. - remove `std.Build.Step.Compile.defineCMacroRaw`. * deprecate `std.Build.Step.Compile.linkFrameworkNeeded` - use `std.Build.Module.linkFramework` * deprecate `std.Build.Step.Compile.linkFrameworkWeak` - use `std.Build.Module.linkFramework` * move more logic into `std.Build.Module` * allow `target` and `optimize` to be `null` when creating a Module. Along with other fields, those unspecified options will be inherited from parent `Module` when inserted into an import table. * the `target` field of `addExecutable` is now required. pass `b.host` to get the host target.
2023-12-02 21:51:34 -07:00
};
}
rename std.zig.CrossTarget to std.Target.Query
2023-12-04 12:35:04 -07:00
pub fn wantSharedLibSymLinks(target: Target) bool {
zig build system: change target, compilation, and module APIs Introduce the concept of "target query" and "resolved target". A target query is what the user specifies, with some things left to default. A resolved target has the default things discovered and populated. In the future, std.zig.CrossTarget will be rename to std.Target.Query. Introduces `std.Build.resolveTargetQuery` to get from one to the other. The concept of `main_mod_path` is gone, no longer supported. You have to put the root source file at the module root now. * remove deprecated API * update build.zig for the breaking API changes in this branch * move std.Build.Step.Compile.BuildId to std.zig.BuildId * add more options to std.Build.ExecutableOptions, std.Build.ObjectOptions, std.Build.SharedLibraryOptions, std.Build.StaticLibraryOptions, and std.Build.TestOptions. * remove `std.Build.constructCMacro`. There is no use for this API. * deprecate `std.Build.Step.Compile.defineCMacro`. Instead, `std.Build.Module.addCMacro` is provided. - remove `std.Build.Step.Compile.defineCMacroRaw`. * deprecate `std.Build.Step.Compile.linkFrameworkNeeded` - use `std.Build.Module.linkFramework` * deprecate `std.Build.Step.Compile.linkFrameworkWeak` - use `std.Build.Module.linkFramework` * move more logic into `std.Build.Module` * allow `target` and `optimize` to be `null` when creating a Module. Along with other fields, those unspecified options will be inherited from parent `Module` when inserted into an import table. * the `target` field of `addExecutable` is now required. pass `b.host` to get the host target.
2023-12-02 21:51:34 -07:00
return target.os.tag != .windows;
}
std.Build: make systemIntegrationOption take a default
2024-02-01 23:04:23 -07:00
pub const SystemIntegrationOptionConfig = struct {
/// If left as null, then the default will depend on system_package_mode.
default: ?bool = null,
};
pub fn systemIntegrationOption(
b: *Build,
name: []const u8,
config: SystemIntegrationOptionConfig,
) bool {
std.Build: implement --host-target, --host-cpu, --host-dynamic-linker This also makes a long-overdue change of extracting common state from Build into a shared Graph object. Getting the semantics right for these flags turned out to be quite tricky. In the end it works like this: * The override only happens when the target is fully native, with no additional query parameters, such as versions or CPU features added. * The override affects the resolved Target but leaves the original Query unmodified. * The "is native?" detection logic operates on the original, unmodified query. This makes it possible to provide invalid host target information, causing confusing errors to occur. Don't do that. There are some minor breaking changes to std.Build API such as the fact that `b.zig_exe` is now moved to `b.graph.zig_exe`, as well as a handful of other similar flags.
2024-02-01 15:44:44 -07:00
const gop = b.graph.system_library_options.getOrPut(b.allocator, name) catch @panic("OOM");
build system: introduce system library integration * New --help section * Add b.systemLibraryOption * Rework the build runner CLI logic a bit
2024-01-31 22:02:27 -07:00
if (gop.found_existing) switch (gop.value_ptr.*) {
.user_disabled => {
gop.value_ptr.* = .declared_disabled;
return false;
},
.user_enabled => {
gop.value_ptr.* = .declared_enabled;
return true;
},
.declared_disabled => return false,
.declared_enabled => return true,
} else {
gop.key_ptr.* = b.dupe(name);
std.Build: make systemIntegrationOption take a default
2024-02-01 23:04:23 -07:00
if (config.default orelse b.graph.system_package_mode) {
build system: introduce system library integration * New --help section * Add b.systemLibraryOption * Rework the build runner CLI logic a bit
2024-01-31 22:02:27 -07:00
gop.value_ptr.* = .declared_enabled;
return true;
} else {
gop.value_ptr.* = .declared_disabled;
return false;
}
}
}
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
test {
x86_64: implement enough to pass unicode tests * implement vector comparison * implement reduce for bool vectors * fix `@memcpy` bug * enable passing std tests
2023-10-21 19:30:45 -04:00
_ = Cache;
std.Build: use Step.* instead of *Step Follow up to 13eb7251d37759bd47403db304c6120c706fe353
2023-05-03 11:49:55 +03:00
_ = Step;
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
}
Reference in New Issue Copy Permalink