跳转到内容

std.Build.Configuration

标准库Zig 0.17.0官方原文
源码std/Build/Configuration.zig

第 1 行

字段

string_bytes: []u8
steps: []Step
path_deps: []PathDep
unlazy_deps: []String
system_integrations: []SystemIntegration
available_options: []AvailableOption
search_prefixes: []String
extra: []u32
default_step: Step.Index
generated_files_len: u32
poisoned: bool

std.Build.Configuration.Alignment

容器

第 1970 行

以 2 的幂形式存储,另用一个特殊值表示无。

字段

@"1" = 0
@"2" = 1
@"4" = 2
@"8" = 3
@"16" = 4
@"32" = 5
@"64" = 6
none = std.math.maxInt(u6)
_

std.Build.Configuration.Alignment.init

函数

第 1981 行

pub fn init(optional_alignment: ?std.mem.Alignment) @This()

参数

optional_alignment: ?std.mem.Alignment

std.Build.Configuration.Alignment.toBytes

函数

第 1986 行

pub fn toBytes(a: @This()) ?u64

参数

a: @This()

std.Build.Configuration.Allocator

别名

第 6 行

别名目标 std.mem.Allocator

std.Build.Configuration.assert

别名

第 7 行

别名目标 std.debug.assert

std.Build.Configuration.AvailableOption

容器

第 456 行

字段

name: String
description: String
type: Type
enum_options: OptionalStringList

若 type_id 为 enum 或 enum_list,则提供枚举选项列表

std.Build.Configuration.AvailableOption.Type

容器

第 463 行

字段

bool
int
float
@"enum"
enum_list
string
list
build_id
lazy_path
lazy_path_list

std.Build.Configuration.builtin

常量

第 4 行

std.Build.Configuration.Bytes

容器

第 1959 行

可能包含空字节的任意字节序列。

字段

index: u32

指向 string_bytes 内部。

len: u32

std.Build.Configuration.Bytes.slice

函数

第 1964 行

pub fn slice(bytes: Bytes, c: *const Configuration) []const u8

参数

bytes: Bytes
c: *const Configuration

std.Build.Configuration.Configuration

别名

第 1 行

别名目标 std.Build.Configuration

std.Build.Configuration.CSourceFile

容器

第 2061 行

字段

flags: Flags
file: LazyPath.Index
args: Storage.FlagList(.flags, .args_len, String)

std.Build.Configuration.CSourceFile.Flags

容器

第 2068 行

字段

args_len: u29

C 编译器命令行标志。

lang: OptionalCSourceLanguage

std.Build.Configuration.CSourceFile.Index

类型

第 2066 行

std.Build.Configuration.CSourceFiles

容器

第 2046 行

字段

flags: Flags
root: LazyPath.Index
args: Storage.FlagList(.flags, .args_len, String)
sub_paths: Storage.LengthPrefixedList(String)

std.Build.Configuration.CSourceFiles.Flags

容器

第 2054 行

字段

args_len: u29

C 编译器命令行标志。

lang: OptionalCSourceLanguage

std.Build.Configuration.CSourceFiles.Index

类型

第 2052 行

std.Build.Configuration.DefaultingBool

容器

第 1994 行

字段

false
true
default

std.Build.Configuration.DefaultingBool.init

函数

第 1999 行

pub fn init(b: ?bool) DefaultingBool

参数

b: ?bool

std.Build.Configuration.DefaultingBool.toBool

函数

第 2006 行

pub fn toBool(db: DefaultingBool) ?bool

参数

std.Build.Configuration.Deps

容器

第 1817 行

字段

std.Build.Configuration.Deps.Index

容器

第 1820 行

字段

_

std.Build.Configuration.Deps.Index.get

函数

第 1823 行

pub fn get(this: @This(), c: *const Configuration) Deps

参数

this: @This()
c: *const Configuration

std.Build.Configuration.Deps.Index.slice

函数

第 1827 行

pub fn slice(this: @This(), c: *const Configuration) []const Step.Index

参数

this: @This()
c: *const Configuration

std.Build.Configuration.EnvironMap

容器

第 1833 行

字段

keys: StringList
values: StringList

std.Build.Configuration.EnvironMap.Index

类型

第 1837 行

std.Build.Configuration.extraData

函数

第 3115 行

pub fn extraData(c: *const Configuration, comptime T: type, index: usize) T

参数

c: *const Configuration
T: type
index: usize

std.Build.Configuration.GeneratedFileIndex

容器

第 1583 行

字段

_

std.Build.Configuration.Header

容器

第 25 行

此处字段顺序与 Configuration 一致, 后者说明序列化格式中的顺序。

字段

string_bytes_len: u32
steps_len: u32
path_deps_len: u32
unlazy_deps_len: u32
system_integrations_len: u32
available_options_len: u32
search_prefixes_len: u32
extra_len: u32
default_step: Step.Index
generated_files_len: u32

实际上不为此存储数据;它仅使执行进程能够为这些项目预分配数组。

flags: Flags

std.Build.Configuration.Header.Flags

容器

第 41 行

字段

poisoned: bool
_: u31 = 0

std.Build.Configuration.ImportTable

容器

第 1795 行

字段

std.Build.Configuration.ImportTable.Import

容器

第 1798 行

字段

name: String
module: Module.Index

std.Build.Configuration.ImportTable.Index

容器

第 1804 行

指向 extra 内部。

字段

invalid = max_u32
_

std.Build.Configuration.ImportTable.Index.get

函数

第 1808 行

pub fn get(this: @This(), c: *const Configuration) ImportTable

参数

this: @This()
c: *const Configuration

std.Build.Configuration.IndexType

类型函数

第 3105 行

fn IndexType(comptime T: type) type

参数

T: type

字段

_

std.Build.Configuration.IndexType.get

函数

第 3109 行

pub fn get(this: @This(), c: *const Configuration) T

参数

this: @This()
c: *const Configuration

std.Build.Configuration.InstallDestDir

容器

第 1887 行

字段

none = max_u32 - 4
prefix = max_u32 - 3
lib = max_u32 - 2
bin = max_u32 - 1
header = max_u32
_

相对于前缀的 String 路径。

std.Build.Configuration.InstallDestDir.initCustom

函数

第 1896 行

pub fn initCustom(sub_path: String) InstallDestDir

参数

sub_path: String

std.Build.Configuration.InstallDestDir.unpack

函数

第 1909 行

pub fn unpack(this: @This()) ?Unpacked

参数

this: @This()

std.Build.Configuration.InstallDestDir.Unpacked

容器

第 1901 行

字段

prefix
lib
bin
header
sub_path: String

std.Build.Configuration.Io

别名

第 5 行

别名目标 std.Io

std.Build.Configuration.LazyPath

容器

第 1494 行

字段

source_path: SourcePath
relative: Relative
generated: Generated

std.Build.Configuration.LazyPath.Flags

容器

第 1508 行

字段

tag: Tag
_: u24 = 0

std.Build.Configuration.LazyPath.Generated

容器

第 1540 行

字段

flags: @This().Flags = .{}
index: GeneratedFileIndex
sub_path: String = .empty

在 up 之后应用。

std.Build.Configuration.LazyPath.Generated.Flags

容器

第 1546 行

字段

tag: Tag = .generated
up: u24 = 0

向上遍历父目录的数量。 0 表示生成文件自身。 1 表示生成文件所在目录。 2 表示该目录的父目录,依此类推。

std.Build.Configuration.LazyPath.Index

类型

第 1514 行

extra 的索引。

std.Build.Configuration.LazyPath.OptionalIndex

容器

第 1517 行

extra 中的索引,或 null。

字段

none = max_u32
_

std.Build.Configuration.LazyPath.OptionalIndex.unwrap

函数

第 1521 行

pub fn unwrap(this: @This()) ?Index

参数

this: @This()

std.Build.Configuration.LazyPath.Relative

容器

第 1556 行

字段

flags: @This().Flags
sub_path: String

std.Build.Configuration.LazyPath.Relative.Base

容器

第 1566 行

字段

cwd
local_cache
global_cache
build_root

缺少程序包索引,因此不得与 Relative 配合使用。

zig_exe
zig_lib
install_prefix
install_lib
install_bin
install_include
libc_runtimes

std.Build.Configuration.LazyPath.Relative.Flags

容器

第 1560 行

字段

tag: Tag = .relative
base: Base
_: u16 = 0

std.Build.Configuration.LazyPath.SourcePath

容器

第 1529 行

字段

flags: @This().Flags = .{}
owner: Package.Index
sub_path: String

std.Build.Configuration.LazyPath.SourcePath.Flags

容器

第 1534 行

字段

tag: Tag = .source_path
_: u24 = 0

std.Build.Configuration.LazyPath.Tag

容器

第 1499 行

字段

source_path

相对于构建根目录的源文件路径。

relative

相对于 flags 指示的目录。

generated

仅在所属步骤填充路径后,该路径才可用。

std.Build.Configuration.load

函数

第 3133 行

pub fn load(arena: Allocator, reader: *Io.Reader) LoadError!Configuration

参数

arena: Allocator
reader: *Io.Reader

错误

EndOfStream Error
OutOfMemory Error
ReadFailed Error

详细诊断参见 Reader 的实现。

std.Build.Configuration.loadBits

函数

第 3166 行

value 跨越多个字节时,使用本机字节序加载位。 在大端架构上,bit_offset 使用最高有效位编号为 0 的位编号方式。 在小端架构上,bit_offset 使用最低有效位编号为 0 的位编号方式。 参见 storeBits。

pub fn loadBits(comptime Int: type, buffer: []const Int, bit_offset: usize, comptime Result: type) Result

参数

Int: type
buffer: []const Int
bit_offset: usize
Result: type

std.Build.Configuration.LoadError

错误集合

第 3131 行

错误

EndOfStream Error
OutOfMemory Error
ReadFailed Error

详细诊断参见 Reader 的实现。

std.Build.Configuration.loadFile

函数

第 3122 行

pub fn loadFile(arena: Allocator, io: Io, file: Io.File) LoadFileError!Configuration

参数

arena: Allocator
io: Io
file: Io.File

错误

AccessDenied UnendingError

在 WASI 中,当文件描述符不具有读取 所需的权限时发生此错误。

Canceled Cancelable

调用方请求停止异步操作。

ConnectionResetByPeer UnendingError
EndOfStream
InputOutput UnendingError
IsDir UnendingError

尝试将目录文件描述符当作普通文件读取。

LockViolation UnendingError

由于锁定而无法读取文件。根据 Io 实现的不同,读取已锁定文件可能返回此错误,也可能忽略锁。

NotOpenForReading UnendingError

打开文件时未授予读取能力。

OutOfMemory Error
SocketUnconnected UnendingError
SystemResources UnendingError
Unexpected UnexpectedError

操作系统返回了未记录在文档中的错误码。

理论上不可能出现此错误,但处理 此错误优于触发未定义行为。

观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。

WouldBlock UnendingError

已启用非阻塞模式,且从该文件描述符读取会阻塞。

std.Build.Configuration.LoadFileError

错误集合

第 3120 行

错误

AccessDenied UnendingError

在 WASI 中,当文件描述符不具有读取 所需的权限时发生此错误。

Canceled Cancelable

调用方请求停止异步操作。

ConnectionResetByPeer UnendingError
EndOfStream
InputOutput UnendingError
IsDir UnendingError

尝试将目录文件描述符当作普通文件读取。

LockViolation UnendingError

由于锁定而无法读取文件。根据 Io 实现的不同,读取已锁定文件可能返回此错误,也可能忽略锁。

NotOpenForReading UnendingError

打开文件时未授予读取能力。

OutOfMemory Error
SocketUnconnected UnendingError
SystemResources UnendingError
Unexpected UnexpectedError

操作系统返回了未记录在文档中的错误码。

理论上不可能出现此错误,但处理 此错误优于触发未定义行为。

观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。

WouldBlock UnendingError

已启用非阻塞模式,且从该文件描述符读取会阻塞。

std.Build.Configuration.max_u32

常量

第 8 行

std.Build.Configuration.MaxRss

容器

第 1480 行

字段

none = 0
_

std.Build.Configuration.MaxRss.fromBytes

函数

第 1489 行

pub fn fromBytes(bytes: u64) MaxRss

参数

bytes: u64

std.Build.Configuration.MaxRss.toBytes

函数

第 1484 行

pub fn toBytes(mr: MaxRss) u64

参数

mr: MaxRss

std.Build.Configuration.Module

容器

第 1645 行

字段

flags: Flags
flags2: Flags2
import_table: ImportTable.Index
owner: Package.Index
root_source_file: LazyPath.OptionalIndex
resolved_target: ResolvedTarget.OptionalIndex
c_macros: Storage.FlagLengthPrefixedList(.flags, .c_macros, String)
lib_paths: Storage.FlagLengthPrefixedList(.flags, .lib_paths, LazyPath.Index)
export_symbol_names: Storage.FlagLengthPrefixedList(.flags, .export_symbol_names, String)
include_dirs: Storage.UnionList(.flags, .include_dirs, IncludeDir)
rpaths: Storage.UnionList(.flags, .rpaths, RPath)
link_objects: Storage.UnionList(.flags, .link_objects, LinkObject)
frameworks: Storage.FlagLengthPrefixedList(.flags, .frameworks, Framework)
patchable_function_entry: u32

std.Build.Configuration.Module.DwarfFormat

容器

第 1708 行

字段

@"32"
@"64"
default

std.Build.Configuration.Module.DwarfFormat.init

函数

第 1713 行

pub fn init(df: ?std.dwarf.Format) DwarfFormat

参数

std.Build.Configuration.Module.Flags

容器

第 1721 行

字段

optimize: Optimize
strip: DefaultingBool
unwind_tables: UnwindTables
dwarf_format: DwarfFormat
single_threaded: DefaultingBool
stack_protector: DefaultingBool
stack_check: DefaultingBool
sanitize_c: SanitizeC
sanitize_thread: DefaultingBool
fuzz: DefaultingBool
code_model: std.builtin.CodeModel
c_macros: bool
include_dirs: bool
lib_paths: bool
rpaths: bool
frameworks: bool
link_objects: bool
export_symbol_names: bool

std.Build.Configuration.Module.Flags2

容器

第 1742 行

字段

valgrind: DefaultingBool
pic: DefaultingBool
red_zone: DefaultingBool
omit_frame_pointer: DefaultingBool
error_tracing: DefaultingBool
link_libc: DefaultingBool
link_libcpp: DefaultingBool
no_builtin: DefaultingBool
_: u16 = 0

std.Build.Configuration.Module.Framework

容器

第 1781 行

字段

flags: @This().Flags
name: String

std.Build.Configuration.Module.Framework.Flags

容器

第 1785 行

字段

needed: bool
weak: bool
_: u30 = 0

std.Build.Configuration.Module.IncludeDir

容器

第 1754 行

字段

path: LazyPath.Index
path_system: LazyPath.Index
path_after: LazyPath.Index
framework_path: LazyPath.Index
framework_path_system: LazyPath.Index
config_header_step: Step.Index

始终为 Step.Tag.config_header。

embed_path: LazyPath.Index

std.Build.Configuration.Module.Index

类型

第 1792 行

std.Build.Configuration.Module.LinkObject

容器

第 1770 行

字段

static_path: LazyPath.Index
other_step: Step.Index

始终为 Step.Tag.compile。

system_lib: SystemLib.Index
assembly_file: LazyPath.Index
c_source_file: CSourceFile.Index
c_source_files: CSourceFiles.Index
win32_resource_file: RcSourceFile.Index

std.Build.Configuration.Module.Optimize

容器

第 1661 行

字段

debug
safe
fast
small
default

std.Build.Configuration.Module.Optimize.init

函数

第 1668 行

pub fn init(o: ?std.builtin.Optimize) Optimize

参数

std.Build.Configuration.Module.RPath

容器

第 1765 行

字段

lazy_path: LazyPath.Index
special: String

std.Build.Configuration.Module.SanitizeC

容器

第 1693 行

字段

off
trap
full
default

std.Build.Configuration.Module.SanitizeC.init

函数

第 1699 行

pub fn init(sc: ?std.zig.SanitizeC) SanitizeC

参数

std.Build.Configuration.Module.UnwindTables

容器

第 1678 行

字段

none
sync
async
default

std.Build.Configuration.Module.UnwindTables.init

函数

第 1684 行

pub fn init(ut: ?std.builtin.UnwindTables) UnwindTables

参数

std.Build.Configuration.native_endian

常量

第 9 行

std.Build.Configuration.OptionalCSourceLanguage

容器

第 2090 行

字段

c
cpp
objective_c
objective_cpp
assembly
assembly_with_preprocessor
default

std.Build.Configuration.OptionalCSourceLanguage.get

函数

第 2106 行

pub fn get(this: @This()) ?std.Build.Module.CSourceLanguage

参数

this: @This()

std.Build.Configuration.OptionalCSourceLanguage.init

函数

第 2100 行

pub fn init(x: ?std.Build.Module.CSourceLanguage) @This()

参数

std.Build.Configuration.OptionalGeneratedFileIndex

容器

第 1587 行

字段

none = max_u32
_

std.Build.Configuration.OptionalGeneratedFileIndex.init

函数

第 1591 行

pub fn init(i: ?GeneratedFileIndex) OptionalGeneratedFileIndex

参数

std.Build.Configuration.OptionalGeneratedFileIndex.unwrap

函数

第 1595 行

pub fn unwrap(this: @This()) ?GeneratedFileIndex

参数

this: @This()

std.Build.Configuration.OptionalString

容器

第 1922 行

指向 string_bytes 内部,以空字符终止。

字段

empty = 0
root = 1

字符串 "root"。

none = max_u32
_

std.Build.Configuration.OptionalString.init

函数

第 1929 行

pub fn init(s: String) OptionalString

参数

s: String

std.Build.Configuration.OptionalString.slice

函数

第 1940 行

pub fn slice(this: @This(), c: *const Configuration) ?[:0]const u8

参数

this: @This()
c: *const Configuration

std.Build.Configuration.OptionalString.unwrap

函数

第 1935 行

pub fn unwrap(this: @This()) ?String

参数

this: @This()

std.Build.Configuration.OptionalStringList

容器

第 1853 行

字段

none = max_u32
_

std.Build.Configuration.OptionalStringList.init

函数

第 1857 行

pub fn init(opt_string_list: ?StringList) OptionalStringList

参数

opt_string_list: ?StringList

std.Build.Configuration.OptionalStringList.slice

函数

第 1869 行

pub fn slice(this: @This(), c: *const Configuration) ?[]const String

参数

this: @This()
c: *const Configuration

std.Build.Configuration.OptionalStringList.unwrap

函数

第 1864 行

pub fn unwrap(this: @This()) ?StringList

参数

this: @This()

std.Build.Configuration.Package

容器

第 1603 行

字段

dep_prefix: String
hash: String
root_path: String

std.Build.Configuration.Package.Index

容器

第 1608 行

字段

root = max_u32
_

std.Build.Configuration.Package.Index.depPrefixSlice

函数

第 1618 行

pub fn depPrefixSlice(i: @This(), c: *const Configuration) [:0]const u8

参数

i: @This()
c: *const Configuration

std.Build.Configuration.Package.Index.get

函数

第 1613 行

根包返回 null。

pub fn get(i: @This(), c: *const Configuration) ?Package

参数

i: @This()
c: *const Configuration

std.Build.Configuration.Package.OptionalIndex

容器

第 1624 行

字段

none = max_u32 - 1
root = max_u32
_

std.Build.Configuration.Package.OptionalIndex.init

函数

第 1629 行

pub fn init(i: Index) OptionalIndex

参数

i: Index

std.Build.Configuration.Package.OptionalIndex.unwrap

函数

第 1635 行

pub fn unwrap(this: @This()) ?Index

参数

this: @This()

std.Build.Configuration.PathDep

容器

第 1874 行

字段

flags: Flags
sub: String
pkg: Package.OptionalIndex

std.Build.Configuration.PathDep.Flags

容器

第 1879 行

字段

is_directory: bool
metadata_only: bool
base: LazyPath.Relative.Base
_: u22 = 0

std.Build.Configuration.RcSourceFile

容器

第 2075 行

字段

flags: Flags
file: LazyPath.Index
args: Storage.FlagList(.flags, .args_len, String)
include_paths: Storage.FlagLengthPrefixedList(.flags, .include_paths, LazyPath.Index)

std.Build.Configuration.RcSourceFile.Flags

容器

第 2083 行

字段

args_len: u31

C 编译器命令行标志。

include_paths: bool

std.Build.Configuration.RcSourceFile.Index

类型

第 2081 行

std.Build.Configuration.ResolvedTarget

容器

第 2114 行

字段

query: TargetQuery.OptionalIndex

none 表示宿主机。

result: TargetQuery.Index

将解析默认值。

std.Build.Configuration.ResolvedTarget.Index

类型

第 2120 行

std.Build.Configuration.ResolvedTarget.OptionalIndex

容器

第 2122 行

字段

none = max_u32
_

std.Build.Configuration.ResolvedTarget.OptionalIndex.get

函数

第 2139 行

pub fn get(this: @This(), c: *const Configuration) ?ResolvedTarget

参数

this: @This()
c: *const Configuration

std.Build.Configuration.ResolvedTarget.OptionalIndex.init

函数

第 2126 行

pub fn init(i: Index) OptionalIndex

参数

i: Index

std.Build.Configuration.ResolvedTarget.OptionalIndex.unwrap

函数

第 2132 行

pub fn unwrap(this: @This()) ?Index

参数

this: @This()

std.Build.Configuration.ResolvedTarget.unwrapQuery

函数

第 2144 行

pub fn unwrapQuery(rt: *const ResolvedTarget, c: *const Configuration) ?std.Target.Query

参数

rt: *const ResolvedTarget
c: *const Configuration

std.Build.Configuration.std

别名

第 3 行

别名目标 std

std.Build.Configuration.Step

容器

第 477 行

字段

name: String
owner: Package.Index
deps: Deps.Index
max_rss: MaxRss
extended: Storage.Extended(Flags, union(Tag) {
    check_file: CheckFile,
    compile: Compile,
    config_header: ConfigHeader,
    fail: Fail,
    find_program: FindProgram,
    fmt: Fmt,
    install_artifact: InstallArtifact,
    install_dir: InstallDir,
    install_file: InstallFile,
    obj_copy: ObjCopy,
    options: Options,
    run: Run,
    top_level: TopLevel,
    translate_c: TranslateC,
    update_source_files: UpdateSourceFiles,
    write_file: WriteFile,
})

std.Build.Configuration.Step.CheckFile

容器

第 1060 行

字段

flags: @This().Flags
file: LazyPath.Index
expected_exact: Storage.FlagOptional(.flags, .expected_exact, Bytes)
expected_matches: Storage.FlagLengthPrefixedList(.flags, .expected_matches, Bytes)
max_bytes: Storage.FlagOptional(.flags, .max_bytes, u32)

std.Build.Configuration.Step.CheckFile.Flags

容器

第 1067 行

字段

tag: Tag = .check_file
expected_exact: bool
expected_matches: bool
max_bytes: bool
_: u24 = 0

std.Build.Configuration.Step.Compile

容器

第 706 行

字段

flags: @This().Flags
flags2: Flags2
flags3: Flags3
flags4: Flags4
root_module: Module.Index
root_name: String
filters: Storage.FlagLengthPrefixedList(.flags, .filters_len, String)
installed_headers: Storage.FlagLengthPrefixedList(.flags, .installed_headers_len, Storage.Extended(InstalledHeader.Flags, InstalledHeader))
force_undefined_symbols: Storage.FlagLengthPrefixedList(.flags, .force_undefined_symbols_len, String)
expect_errors: Storage.FlagUnion(.flags4, .expect_errors, ExpectErrors)
linker_script: Storage.FlagOptional(.flags4, .linker_script, LazyPath.Index)
version_script: Storage.FlagOptional(.flags4, .version_script, LazyPath.Index)
zig_lib_dir: Storage.FlagOptional(.flags3, .zig_lib_dir, LazyPath.Index)
libc_file: Storage.FlagOptional(.flags4, .libc_file, LazyPath.Index)
win32_manifest: Storage.FlagOptional(.flags3, .win32_manifest, LazyPath.Index)
win32_module_definition: Storage.FlagOptional(.flags3, .win32_module_definition, LazyPath.Index)
entitlements: Storage.FlagOptional(.flags4, .entitlements, LazyPath.Index)
version: Storage.FlagOptional(.flags3, .version, String)
entry: Storage.EnumOptional(.flags3, .entry, .symbol_name, String)
install_name: Storage.FlagOptional(.flags4, .install_name, String)
initial_memory: Storage.FlagOptional(.flags3, .initial_memory, u64)
max_memory: Storage.FlagOptional(.flags3, .max_memory, u64)
global_base: Storage.FlagOptional(.flags3, .global_base, u64)
image_base: Storage.FlagOptional(.flags3, .image_base, u64)
link_z_common_page_size: Storage.FlagOptional(.flags4, .link_z_common_page_size, u64)
link_z_max_page_size: Storage.FlagOptional(.flags4, .link_z_max_page_size, u64)
pagezero_size: Storage.FlagOptional(.flags4, .pagezero_size, u64)
stack_size: Storage.FlagOptional(.flags4, .stack_size, u64)
headerpad_size: Storage.FlagOptional(.flags4, .headerpad_size, u32)
error_limit: Storage.FlagOptional(.flags4, .error_limit, u32)
build_id: Storage.EnumOptional(.flags3, .build_id, .hexstring, String)
test_runner: Storage.FlagUnion(.flags3, .test_runner, TestRunner)
emit_directory: Storage.FlagOptional(.flags4, .emit_directory, GeneratedFileIndex)
generated_docs: Storage.FlagOptional(.flags4, .generated_docs, GeneratedFileIndex)
generated_asm: Storage.FlagOptional(.flags4, .generated_asm, GeneratedFileIndex)
generated_bin: Storage.FlagOptional(.flags4, .generated_bin, GeneratedFileIndex)
generated_pdb: Storage.FlagOptional(.flags4, .generated_pdb, GeneratedFileIndex)
generated_implib: Storage.FlagOptional(.flags4, .generated_implib, GeneratedFileIndex)
generated_llvm_bc: Storage.FlagOptional(.flags4, .generated_llvm_bc, GeneratedFileIndex)
generated_llvm_ir: Storage.FlagOptional(.flags4, .generated_llvm_ir, GeneratedFileIndex)
generated_h: Storage.FlagOptional(.flags4, .generated_h, GeneratedFileIndex)

std.Build.Configuration.Step.Compile.BuildId

容器

第 825 行

字段

none
fast
uuid
sha1
md5
hexstring
default

std.Build.Configuration.Step.Compile.BuildId.init

函数

第 834 行

pub fn init(build_id: ?std.zig.BuildId) BuildId

参数

build_id: ?std.zig.BuildId

std.Build.Configuration.Step.Compile.BuildId.unwrap

函数

第 845 行

pub fn unwrap(this: @This(), hexstring: ?String, c: *const Configuration) ?std.zig.BuildId

参数

this: @This()
hexstring: ?String
c: *const Configuration

std.Build.Configuration.Step.Compile.Entry

容器

第 808 行

字段

default
disabled
enabled
symbol_name

std.Build.Configuration.Step.Compile.ExpectErrors

容器

第 792 行

字段

contains: String
exact: Storage.LengthPrefixedList(String)
starts_with: String
stderr_contains: String
none: void

std.Build.Configuration.Step.Compile.ExpectErrors.Tag

容器

第 793 行

字段

contains
exact
starts_with
stderr_contains
none

std.Build.Configuration.Step.Compile.Flags

容器

第 940 行

字段

tag: Tag = .compile
filters_len: bool
installed_headers_len: bool
force_undefined_symbols_len: bool
verbose_link: bool
verbose_cc: bool
rdynamic: bool
import_memory: bool
export_memory: bool
import_symbols: bool
import_table: bool
export_table: bool
growable_table: bool
shared_memory: bool
link_eh_frame_hdr: bool
link_emit_relocs: bool
link_function_sections: bool
link_data_sections: bool
linker_dynamicbase: bool
link_z_notext: bool
link_z_relro: bool
link_z_lazy: bool
link_z_defs: bool
headerpad_max_install_names: bool
dead_strip_dylibs: bool
force_load_objc: bool
discard_local_symbols: bool
mingw_unicode_entry_point: bool

std.Build.Configuration.Step.Compile.Flags2

容器

第 973 行

字段

pie: DefaultingBool
formatted_panics: DefaultingBool
bundle_compiler_rt: DefaultingBool
bundle_ubsan_rt: DefaultingBool
each_lib_rpath: DefaultingBool
link_gc_sections: DefaultingBool
linker_allow_shlib_undefined: DefaultingBool
linker_allow_undefined_version: DefaultingBool
linker_enable_new_dtags: DefaultingBool
dll_export_fns: DefaultingBool
use_llvm: DefaultingBool
use_lld: DefaultingBool
use_new_linker: DefaultingBool
allow_so_scripts: DefaultingBool
sanitize_coverage_trace_pc_guard: DefaultingBool
linkage: Linkage

std.Build.Configuration.Step.Compile.Flags3

容器

第 992 行

字段

version: bool
initial_memory: bool
max_memory: bool
kind: Kind
compress_debug_sections: std.zig.CompressDebugSections
global_base: bool
test_runner: TestRunner.Tag
wasi_exec_model: WasiExecModel
win32_manifest: bool
win32_module_definition: bool
zig_lib_dir: bool
rc_includes: std.zig.RcIncludes
image_base: bool
build_id: BuildId
entry: Entry
lto: Lto
subsystem: Subsystem
_: u2 = 0

std.Build.Configuration.Step.Compile.Flags4

容器

第 1013 行

字段

libc_file: bool
link_z_common_page_size: bool
link_z_max_page_size: bool
pagezero_size: bool
stack_size: bool
headerpad_size: bool
error_limit: bool
install_name: bool
entitlements: bool
expect_errors: ExpectErrors.Tag
linker_script: bool
version_script: bool
emit_directory: bool
generated_docs: bool
generated_asm: bool
generated_bin: bool
generated_pdb: bool
generated_implib: bool
generated_llvm_bc: bool
generated_llvm_ir: bool
generated_h: bool
incremental: DefaultingBool
_: u7 = 0

std.Build.Configuration.Step.Compile.InstalledHeader

容器

第 752 行

字段

file: File
directory: Directory

std.Build.Configuration.Step.Compile.InstalledHeader.Directory

容器

第 777 行

字段

flags: @This().Flags
source: LazyPath.Index
dest_sub_path: String
exclude_extensions: Storage.FlagLengthPrefixedList(.flags, .exclude_extensions, String)
include_extensions: Storage.FlagLengthPrefixedList(.flags, .include_extensions, String)

std.Build.Configuration.Step.Compile.InstalledHeader.Directory.Flags

容器

第 784 行

字段

tag: InstalledHeader.Tag = .directory
exclude_extensions: bool
include_extensions: bool
_: u22 = 0

std.Build.Configuration.Step.Compile.InstalledHeader.File

容器

第 766 行

字段

flags: @This().Flags = .{}
source: LazyPath.Index
dest_sub_path: String

std.Build.Configuration.Step.Compile.InstalledHeader.File.Flags

容器

第 771 行

字段

tag: InstalledHeader.Tag = .file
_: u24 = 0

std.Build.Configuration.Step.Compile.InstalledHeader.Flags

容器

第 756 行

字段

tag: InstalledHeader.Tag
_: u24 = 0

std.Build.Configuration.Step.Compile.InstalledHeader.Tag

容器

第 761 行

字段

file
directory

std.Build.Configuration.Step.Compile.isDll

函数

第 1051 行

pub fn isDll(compile: *const Compile, c: *const Configuration) bool

参数

compile: *const Compile
c: *const Configuration

std.Build.Configuration.Step.Compile.isDynamicLibrary

函数

第 1039 行

pub fn isDynamicLibrary(compile: *const Compile) bool

参数

compile: *const Compile

std.Build.Configuration.Step.Compile.isStaticLibrary

函数

第 1043 行

pub fn isStaticLibrary(compile: *const Compile) bool

参数

compile: *const Compile

std.Build.Configuration.Step.Compile.Kind

容器

第 893 行

字段

exe
lib
obj
@"test"
test_obj

std.Build.Configuration.Step.Compile.Kind.isTest

函数

第 900 行

pub fn isTest(kind: Kind) bool

参数

kind: Kind

std.Build.Configuration.Step.Compile.Kind.toOutputMode

函数

第 907 行

pub fn toOutputMode(kind: Kind) std.builtin.OutputMode

参数

kind: Kind

std.Build.Configuration.Step.Compile.Linkage

容器

第 873 行

字段

static
dynamic
default

std.Build.Configuration.Step.Compile.Linkage.init

函数

第 878 行

pub fn init(link_mode: ?std.builtin.LinkMode) Linkage

参数

link_mode: ?std.builtin.LinkMode

std.Build.Configuration.Step.Compile.Linkage.unwrap

函数

第 885 行

pub fn unwrap(this: @This()) ?std.builtin.LinkMode

参数

this: @This()

std.Build.Configuration.Step.Compile.Lto

容器

第 810 行

字段

none
full
thin
default

std.Build.Configuration.Step.Compile.Lto.init

函数

第 816 行

pub fn init(lto: ?std.zig.LtoMode) Lto

参数

lto: ?std.zig.LtoMode

std.Build.Configuration.Step.Compile.producesImplib

函数

第 1047 行

pub fn producesImplib(compile: *const Compile, c: *const Configuration) bool

参数

compile: *const Compile
c: *const Configuration

std.Build.Configuration.Step.Compile.rootModuleTarget

函数

第 1055 行

pub fn rootModuleTarget(compile: *const Compile, c: *const Configuration) TargetQuery

参数

compile: *const Compile
c: *const Configuration

std.Build.Configuration.Step.Compile.Subsystem

容器

第 915 行

字段

console
windows
posix
native
efi_application
efi_boot_service_driver
efi_rom
efi_runtime_driver
default

std.Build.Configuration.Step.Compile.Subsystem.init

函数

第 926 行

pub fn init(subsystem: ?std.zig.Subsystem) Subsystem

参数

subsystem: ?std.zig.Subsystem

std.Build.Configuration.Step.Compile.TestRunner

容器

第 801 行

字段

default: void
simple: LazyPath.Index
server: LazyPath.Index

std.Build.Configuration.Step.Compile.TestRunner.Tag

容器

第 802 行

字段

default
simple
server

std.Build.Configuration.Step.Compile.WasiExecModel

容器

第 861 行

字段

default
command
reactor

std.Build.Configuration.Step.Compile.WasiExecModel.init

函数

第 866 行

pub fn init(wasi_exec_model: ?std.builtin.WasiExecModel) WasiExecModel

参数

wasi_exec_model: ?std.builtin.WasiExecModel

std.Build.Configuration.Step.ConfigHeader

容器

第 1076 行

字段

flags: @This().Flags
template_file: Storage.FlagOptional(.flags, .template_file, LazyPath.Index)
generated_dir: GeneratedFileIndex
input_size_limit: Storage.FlagOptional(.flags, .input_size_limit, u64)
include_path: String
include_guard: Storage.FlagOptional(.flags, .include_guard, String)
values: Storage.LengthPrefixedList(Value.Pair)

std.Build.Configuration.Step.ConfigHeader.Flags

容器

第 1211 行

字段

tag: Tag = .config_header
template_file: bool
style: Style
input_size_limit: bool
include_guard: bool
_: u21 = 0

std.Build.Configuration.Step.ConfigHeader.Style

容器

第 1085 行

字段

autoconf_undef
autoconf_at
cmake
meson
blank
nasm

std.Build.Configuration.Step.ConfigHeader.Style.init

函数

第 1093 行

pub fn init(s: std.Build.Step.ConfigHeader.Style) Style

参数

std.Build.Configuration.Step.ConfigHeader.Value

容器

第 1105 行

字段

flags: @This().Flags
i64: Storage.EnumOptional(.flags, .tag, .i64, i64)
u64: Storage.EnumOptional(.flags, .tag, .u64, u64)
ident: Storage.EnumOptional(.flags, .tag, .ident, String)
string: Storage.EnumOptional(.flags, .tag, .string, String)

std.Build.Configuration.Step.ConfigHeader.Value.Flags

容器

第 1112 行

字段

tag: Value.Tag
small: u29

std.Build.Configuration.Step.ConfigHeader.Value.Index

容器

第 1131 行

字段

int_0 = max_u32 - 5
int_1 = max_u32 - 4
bool_false = max_u32 - 3
bool_true = max_u32 - 2
undef = max_u32 - 1
defined = max_u32
_

std.Build.Configuration.Step.ConfigHeader.Value.Index.unpack

函数

第 1140 行

pub fn unpack(this: @This(), c: *const Configuration) Unpacked

参数

this: @This()
c: *const Configuration

std.Build.Configuration.Step.ConfigHeader.Value.initSigned

函数

第 1173 行

pub fn initSigned(x: i64) @This()

参数

x: i64

std.Build.Configuration.Step.ConfigHeader.Value.Pair

容器

第 1126 行

字段

key: String
index: Value.Index

std.Build.Configuration.Step.ConfigHeader.Value.Tag

容器

第 1117 行

字段

ident
string
small_unsigned
small_signed
i64
u64

std.Build.Configuration.Step.ConfigHeader.Value.Unpacked

容器

第 1163 行

字段

bool: bool
undef
defined
i64: i64
u64: u64
ident: []const u8
string: []const u8

std.Build.Configuration.Step.Fail

容器

第 1221 行

字段

flags: @This().Flags = .{}
msg: String

std.Build.Configuration.Step.Fail.Flags

容器

第 1225 行

字段

tag: Tag = .fail
_: u27 = 0

std.Build.Configuration.Step.FindProgram

容器

第 1245 行

字段

flags: @This().Flags = .{}
names: StringList
found_path: GeneratedFileIndex

std.Build.Configuration.Step.FindProgram.Flags

容器

第 1250 行

字段

tag: Tag = .find_program
_: u27 = 0

std.Build.Configuration.Step.flags

函数

第 1475 行

pub fn flags(s: *const Step, c: *const Configuration) Flags

参数

s: *const Step
c: *const Configuration

std.Build.Configuration.Step.Flags

容器

第 511 行

由所有步骤共享。

字段

tag: Tag
_: u27 = 0

std.Build.Configuration.Step.Fmt

容器

第 1231 行

字段

flags: @This().Flags
paths: Storage.FlagLengthPrefixedList(.flags, .paths, LazyPath.Index)
exclude_paths: Storage.FlagLengthPrefixedList(.flags, .exclude_paths, LazyPath.Index)

std.Build.Configuration.Step.Fmt.Flags

容器

第 1236 行

字段

tag: Tag = .fmt
paths: bool
exclude_paths: bool
check: bool
_: u24 = 0

std.Build.Configuration.Step.Index

容器

第 502 行

指向 steps 内部。

字段

_

std.Build.Configuration.Step.Index.ptr

函数

第 505 行

pub fn ptr(i: Index, c: *const Configuration) *const Step

参数

i: Index
c: *const Configuration

std.Build.Configuration.Step.InstallArtifact

容器

第 547 行

首个依赖步骤索引为编译步骤, 其产物由当前步骤安装。

字段

flags: @This().Flags
bin_dir: Storage.FlagOptional(.flags, .bin_dir, InstallDestDir)
implib_dir: Storage.FlagOptional(.flags, .implib_dir, InstallDestDir)
pdb_dir: Storage.FlagOptional(.flags, .pdb_dir, InstallDestDir)
h_dir: Storage.FlagOptional(.flags, .h_dir, InstallDestDir)
bin_sub_path: Storage.FlagOptional(.flags, .bin_sub_path, String)

std.Build.Configuration.Step.InstallArtifact.Flags

容器

第 555 行

字段

tag: Tag = .install_artifact
dylib_symlinks: bool
bin_dir: bool
implib_dir: bool
pdb_dir: bool
h_dir: bool
bin_sub_path: bool
_: u21 = 0

std.Build.Configuration.Step.InstallDir

容器

第 1256 行

字段

flags: @This().Flags
source_dir: LazyPath.Index
dest_dir: InstallDestDir
dest_sub_path: Storage.FlagOptional(.flags, .dest_sub_path, String)
exclude_extensions: Storage.FlagLengthPrefixedList(.flags, .exclude_extensions, String)
include_extensions: Storage.FlagLengthPrefixedList(.flags, .include_extensions, String)
blank_extensions: Storage.FlagLengthPrefixedList(.flags, .blank_extensions, String)

std.Build.Configuration.Step.InstallDir.Flags

容器

第 1265 行

字段

tag: Tag = .install_dir
dest_sub_path: bool
exclude_extensions: bool
include_extensions: bool
include_extensions_active: bool
blank_extensions: bool
_: u22 = 0

std.Build.Configuration.Step.InstallFile

容器

第 1276 行

字段

flags: @This().Flags = .{}
source: LazyPath.Index
dest_dir: InstallDestDir
dest_sub_path: String

std.Build.Configuration.Step.InstallFile.Flags

容器

第 1282 行

字段

tag: Tag = .install_file
_: u27 = 0

std.Build.Configuration.Step.ObjCopy

容器

第 1288 行

字段

flags: @This().Flags
input_file: LazyPath.Index
output_file: GeneratedFileIndex
basename: Storage.FlagOptional(.flags, .basename, String)
debug_file: Storage.FlagOptional(.flags, .debug_file, GeneratedFileIndex)
debug_basename: Storage.FlagOptional(.flags, .debug_basename, String)
only_section: Storage.FlagOptional(.flags, .only_section, String)
pad_to: Storage.FlagOptional(.flags, .pad_to, u64)
add_section: Storage.FlagLengthPrefixedList(.flags, .add_section, AddSection)
update_section: Storage.FlagLengthPrefixedList(.flags, .update_section, UpdateSection)

std.Build.Configuration.Step.ObjCopy.AddSection

容器

第 1321 行

字段

section_name: String
file_path: LazyPath.Index

std.Build.Configuration.Step.ObjCopy.Flags

容器

第 1360 行

字段

tag: Tag = .obj_copy
basename: bool
debug_file: bool
debug_basename: bool
format: Format
strip: Strip
compress_debug: bool
only_section: bool
pad_to: bool
add_section: bool
update_section: bool
_: u15 = 0

std.Build.Configuration.Step.ObjCopy.Format

容器

第 1300 行

字段

binary
hex
elf
default

std.Build.Configuration.Step.ObjCopy.Format.init

函数

第 1306 行

pub fn init(f: ?std.Build.Step.ObjCopy.Format) @This()

参数

std.Build.Configuration.Step.ObjCopy.SectionFlags

容器

第 1337 行

字段

alloc: bool = false

添加 SHF_ALLOC

contents: bool = false

若节类型为 SHT_NOBITS,则改为 SHT_PROGBITS,否则不执行操作

load: bool = false

若节类型为 SHT_NOBITS,则设为 SHT_PROGBITS;否则不进行操作(与 contents 相同)。

readonly: bool = false

只读:清除默认 SHF_WRITE 标志

code: bool = false

添加 SHF_EXECINSTR

exclude: bool = false

添加 SHF_EXCLUDE

large: bool = false

添加 SHF_X86_64_LARGE。如果目标不是 x86_64,则为致命错误

merge: bool = false

添加 SHF_MERGE

strings: bool = false

添加 SHF_STRINGS

std.Build.Configuration.Step.ObjCopy.SectionFlags.default

常量

第 1357 行

@This()

std.Build.Configuration.Step.ObjCopy.Strip

容器

第 1315 行

字段

none
debug
debug_and_symbols

std.Build.Configuration.Step.ObjCopy.UpdateSection

容器

第 1326 行

字段

section_name: String
flags: @This().Flags

std.Build.Configuration.Step.ObjCopy.UpdateSection.Flags

容器

第 1330 行

字段

section_flags: SectionFlags
alignment: Alignment
_: u17 = 0

std.Build.Configuration.Step.Options

容器

第 1376 行

字段

flags: @This().Flags
generated_file: GeneratedFileIndex
contents: Bytes
files: Storage.FlagLengthPrefixedList(.flags, .files, NamedPath)
directories: Storage.FlagLengthPrefixedList(.flags, .directories, NamedPath)
untracked_paths: Storage.FlagLengthPrefixedList(.flags, .untracked_paths, NamedPath)

std.Build.Configuration.Step.Options.Flags

容器

第 1389 行

字段

tag: Tag = .options
files: bool
directories: bool
untracked_paths: bool
_: u24 = 0

std.Build.Configuration.Step.Options.NamedPath

容器

第 1384 行

字段

name: String
path: LazyPath.Index

std.Build.Configuration.Step.Run

容器

第 567 行

字段

flags: @This().Flags
flags2: Flags2
args: Storage.LengthPrefixedList(Arg.Index)
cwd: Storage.FlagOptional(.flags, .cwd, LazyPath.Index)
preopens: Storage.FlagLengthPrefixedList(.flags, .preopens, Preopen)
captured_stdout: Storage.FlagOptional(.flags, .captured_stdout, CapturedStream)
captured_stderr: Storage.FlagOptional(.flags, .captured_stderr, CapturedStream)
file_inputs: Storage.LengthPrefixedList(LazyPath.Index)
stdio_limit: Storage.FlagOptional(.flags, .stdio_limit, u64)
producer: Storage.FlagOptional(.flags, .producer, Step.Index)

始终为编译步骤。

environ_map: Storage.FlagOptional(.flags, .environ_map, EnvironMap.Index)

前一半为键,后一半为值。

stdin: Storage.FlagUnion(.flags, .stdin, StdIn)
expect_stderr_exact: Storage.FlagOptional(.flags2, .expect_stderr_exact, Bytes)
expect_stdout_exact: Storage.FlagOptional(.flags2, .expect_stdout_exact, Bytes)
expect_stderr_match: Storage.FlagLengthPrefixedList(.flags2, .expect_stderr_match, Bytes)
expect_stdout_match: Storage.FlagLengthPrefixedList(.flags2, .expect_stdout_match, Bytes)
expect_term_value: Storage.FlagOptional(.flags2, .expect_term, u32)
expect_stdout_snapshot: Storage.FlagOptional(.flags2, .expect_stdout_snapshot, LazyPath.Index)
expect_stderr_snapshot: Storage.FlagOptional(.flags2, .expect_stderr_snapshot, LazyPath.Index)

std.Build.Configuration.Step.Run.Arg

容器

第 595 行

字段

flags: @This().Flags
prefix: Storage.FlagOptional(.flags, .prefix, String)
suffix: Storage.FlagOptional(.flags, .suffix, String)
basename: Storage.FlagOptional(.flags, .basename, String)
path: Storage.FlagOptional(.flags, .path, LazyPath.Index)
producer: Storage.FlagOptional(.flags, .producer, Step.Index)

始终为编译步骤。

generated: Storage.FlagOptional(.flags, .generated, GeneratedFileIndex)

std.Build.Configuration.Step.Run.Arg.Flags

容器

第 605 行

字段

tag: Arg.Tag
prefix: bool
suffix: bool
basename: bool
path: bool
producer: bool
generated: bool
dep_file: bool
make_absolute: bool
_: u20 = 0

std.Build.Configuration.Step.Run.Arg.Index

类型

第 638 行

std.Build.Configuration.Step.Run.Arg.Tag

容器

第 618 行

字段

artifact
path_file

path 包含该文件。

path_directory
string

prefix 包含此字符串。

file_content
output_file
output_directory
passthru
enable_darling

prefix 包含启用状态的字符串。 suffix 包含禁用状态的字符串。

enable_qemu
enable_rosetta
enable_wasmtime
enable_wine

std.Build.Configuration.Step.Run.CapturedStream

容器

第 590 行

字段

generated_file: GeneratedFileIndex
basename: String

std.Build.Configuration.Step.Run.Color

容器

第 641 行

字段

enable

已设置 CLICOLOR_FORCE,且未设置 NO_COLOR。

disable

已设置 NO_COLOR,且未设置 CLICOLOR_FORCE。

inherit

构建运行器使用颜色时等价于 .enable,否则等价于 .disable。

auto

若捕获或检查 stderr,则等价于 .disable;否则等价于 .inherit。

manual

构建运行器不修改 CLICOLOR_FORCE 或 NO_COLOR 环境变量。 它们按普通变量处理,因此可通过 setEnvironmentVariable 控制。

std.Build.Configuration.Step.Run.ExpectTermStatus

容器

第 670 行

字段

exited
signal
stopped
unknown

std.Build.Configuration.Step.Run.Flags

容器

第 672 行

字段

tag: Tag = .run
disable_zig_progress: bool
skip_foreign_checks: bool
failing_to_execute_foreign_is_an_error: bool
has_side_effects: bool
color: Color
stdin: StdIn.Tag
stdio: StdIo
stdout_trim_whitespace: TrimWhitespace
stderr_trim_whitespace: TrimWhitespace
stdio_limit: bool
producer: bool
cwd: bool
captured_stdout: bool
captured_stderr: bool
environ_map: bool
preopens: bool
_: u3 = 0

std.Build.Configuration.Step.Run.Flags2

容器

第 693 行

字段

expect_stderr_exact: bool
expect_stdout_exact: bool
expect_stderr_match: bool
expect_stdout_match: bool
expect_term: bool
expect_term_status: ExpectTermStatus
expect_stdout_snapshot: bool
expect_stderr_snapshot: bool
_: u23 = 0

std.Build.Configuration.Step.Run.Preopen

容器

第 655 行

字段

name: String
path: LazyPath.Index

std.Build.Configuration.Step.Run.StdIn

容器

第 660 行

字段

none: void
bytes: Bytes
lazy_path: LazyPath.Index

std.Build.Configuration.Step.Run.StdIn.Tag

容器

第 665 行

字段

none
bytes
lazy_path

std.Build.Configuration.Step.Run.StdIo

容器

第 668 行

字段

infer_from_args
inherit
check
zig_test
protocol

std.Build.Configuration.Step.Run.TrimWhitespace

容器

第 667 行

字段

none
all
leading
trailing

std.Build.Configuration.Step.Tag

容器

第 516 行

字段

check_file
compile
config_header
fail
find_program
fmt
install_artifact
install_dir
install_file
obj_copy
options
run
top_level
translate_c
update_source_files
write_file

std.Build.Configuration.Step.TopLevel

容器

第 535 行

字段

flags: @This().Flags = .{}
description: String

std.Build.Configuration.Step.TopLevel.Flags

容器

第 539 行

字段

tag: Tag = .top_level
_: u27 = 0

std.Build.Configuration.Step.TranslateC

容器

第 1398 行

字段

flags: @This().Flags
src_path: LazyPath.Index
output_file: GeneratedFileIndex
include_dirs: Storage.UnionList(.flags, .include_dirs, Module.IncludeDir)
system_libs: Storage.FlagLengthPrefixedList(.flags, .system_libs, SystemLib.Index)
cc_argv: Storage.FlagLengthPrefixedList(.flags, .cc_argv, String)
target: ResolvedTarget.OptionalIndex

std.Build.Configuration.Step.TranslateC.Flags

容器

第 1407 行

字段

tag: Tag = .translate_c
include_dirs: bool
system_libs: bool
cc_argv: bool
link_libc: bool
optimize: Module.Optimize
_: u20 = 0

std.Build.Configuration.Step.UpdateSourceFiles

容器

第 1418 行

字段

flags: @This().Flags
embeds: Storage.FlagLengthPrefixedList(.flags, .embeds, Embed)
copies: Storage.FlagLengthPrefixedList(.flags, .copies, Copy)

std.Build.Configuration.Step.UpdateSourceFiles.Copy

别名

第 1424 行

别名目标 std.Build.Configuration.Step.WriteFile.Copy

std.Build.Configuration.Step.UpdateSourceFiles.Embed

别名

第 1423 行

别名目标 std.Build.Configuration.Step.WriteFile.Embed

std.Build.Configuration.Step.UpdateSourceFiles.Flags

容器

第 1426 行

字段

tag: Tag = .update_source_files
embeds: bool
copies: bool
_: u25 = 0

std.Build.Configuration.Step.WriteFile

容器

第 1434 行

字段

flags: @This().Flags
generated_directory: GeneratedFileIndex
embeds: Storage.FlagLengthPrefixedList(.flags, .embeds, Embed)
copies: Storage.FlagLengthPrefixedList(.flags, .copies, Copy)
directories: Storage.FlagLengthPrefixedList(.flags, .directories, Directory)
mutate_path: Storage.EnumOptional(.flags, .mode, .mutate, LazyPath.Index)

std.Build.Configuration.Step.WriteFile.Copy

容器

第 1447 行

字段

sub_path: String
src_file: LazyPath.Index

std.Build.Configuration.Step.WriteFile.Directory

容器

第 1452 行

字段

sub_path: String
src_path: LazyPath.Index
exclude_extensions: OptionalStringList
include_extensions: OptionalStringList

std.Build.Configuration.Step.WriteFile.Embed

容器

第 1442 行

字段

sub_path: String
contents: Bytes

std.Build.Configuration.Step.WriteFile.Flags

容器

第 1465 行

字段

tag: Tag = .write_file
embeds: bool
copies: bool
directories: bool
mode: Mode
_: u22 = 0

std.Build.Configuration.Step.WriteFile.Mode

容器

第 1459 行

字段

whole_cached
tmp
mutate

std.Build.Configuration.Storage

容器

第 2535 行

字段

flag_optional
enum_optional
extended
length_prefixed_list
flag_length_prefixed_list
union_list
flag_union
multi_list
flag_list

std.Build.Configuration.Storage.data

函数

第 2775 行

pub fn data(buffer: []const u32, i: *usize, comptime T: type) T

参数

buffer: []const u32
i: *usize
T: type

std.Build.Configuration.Storage.dataField

函数

第 2798 行

fn dataField(buffer: []const u32, i: *usize, container: anytype, comptime Field: type) Field

参数

buffer: []const u32
i: *usize
Field: type

std.Build.Configuration.Storage.dataLength

函数

第 2769 行

pub fn dataLength(buffer: []const u32, i: usize, comptime S: type) usize

参数

buffer: []const u32
i: usize
S: type

std.Build.Configuration.Storage.EnumOptional

类型函数

第 2582 行

当 flags 中的枚举标签与特定值匹配时,此字段存在。

pub fn EnumOptional( comptime flags_arg: @EnumLiteral(), comptime flag_arg: @EnumLiteral(), comptime tag_arg: @EnumLiteral(), comptime ValueArg: type, ) type

参数

flags_arg: @EnumLiteral()
flag_arg: @EnumLiteral()
tag_arg: @EnumLiteral()
ValueArg: type

字段

value: ?Value

std.Build.Configuration.Storage.EnumOptional.flag

常量

第 2593 行

std.Build.Configuration.Storage.EnumOptional.flags

常量

第 2592 行

std.Build.Configuration.Storage.EnumOptional.storage

常量

第 2591 行

Storage

std.Build.Configuration.Storage.EnumOptional.tag

常量

第 2594 行

std.Build.Configuration.Storage.EnumOptional.Value

常量

第 2595 行

std.Build.Configuration.Storage.Extended

类型函数

第 2601 行

该字段是辅助缓冲区中的索引,其首元素 是包含标签的打包结构体。

pub fn Extended(comptime BaseFlags: type, comptime U: type) type

参数

BaseFlags: type
U: type

字段

_

std.Build.Configuration.Storage.Extended.cast

函数

第 2612 行

pub fn cast(this: @This(), c: *const Configuration, comptime S: type) ?S

参数

this: @This()
c: *const Configuration
S: type

std.Build.Configuration.Storage.Extended.get

函数

第 2623 行

pub fn get(this: @This(), buffer: []const u32) U

参数

this: @This()
buffer: []const u32

std.Build.Configuration.Storage.Extended.storage

常量

第 2605 行

Storage

std.Build.Configuration.Storage.Extended.tag

函数

第 2607 行

pub fn tag(this: @This(), c: *const Configuration) @FieldType(BaseFlags, "tag")

参数

this: @This()
c: *const Configuration

std.Build.Configuration.Storage.extraFieldLen

函数

第 2946 行

fn extraFieldLen(field: anytype) usize

std.Build.Configuration.Storage.extraLen

函数

第 2981 行

fn extraLen(extra: anytype) usize

std.Build.Configuration.Storage.FlagLengthPrefixedList

类型函数

第 2638 行

flags 中的一个字段决定长度为零还是非零。 若长度非零,则先有一个长度字段,其后跟随列表。 元素必须具有明确定义的内存布局,除此之外,其大小可以是任意 u32 大小的整数倍。 长度表示元素数量,而非 u32 的数量。

pub fn FlagLengthPrefixedList( comptime flags_arg: @EnumLiteral(), comptime flag_arg: @EnumLiteral(), comptime ElemArg: type, ) type

参数

flags_arg: @EnumLiteral()
flag_arg: @EnumLiteral()
ElemArg: type

字段

slice: []const Elem

std.Build.Configuration.Storage.FlagLengthPrefixedList.Elem

常量

第 2649 行

std.Build.Configuration.Storage.FlagLengthPrefixedList.flag

常量

第 2648 行

std.Build.Configuration.Storage.FlagLengthPrefixedList.flags

常量

第 2647 行

std.Build.Configuration.Storage.FlagLengthPrefixedList.initErased

函数

第 2651 行

pub fn initErased(s: []const u32) @This()

参数

s: []const u32

std.Build.Configuration.Storage.FlagLengthPrefixedList.storage

常量

第 2646 行

Storage

std.Build.Configuration.Storage.FlagList

类型函数

第 2675 行

此字段为列表,长度是 flags 内的一个整数。

pub fn FlagList( comptime flags_arg: @EnumLiteral(), comptime flag_arg: @EnumLiteral(), comptime ElemArg: type, ) type

参数

flags_arg: @EnumLiteral()
flag_arg: @EnumLiteral()
ElemArg: type

字段

slice: []const Elem

std.Build.Configuration.Storage.FlagList.Elem

常量

第 2686 行

std.Build.Configuration.Storage.FlagList.flag

常量

第 2685 行

std.Build.Configuration.Storage.FlagList.flags

常量

第 2684 行

std.Build.Configuration.Storage.FlagList.initErased

函数

第 2688 行

pub fn initErased(s: []const u32) @This()

参数

s: []const u32

std.Build.Configuration.Storage.FlagList.storage

常量

第 2683 行

Storage

std.Build.Configuration.Storage.FlagOptional

类型函数

第 2548 行

字段是否存在由紧凑结构体中的 一个布尔值决定。

pub fn FlagOptional( comptime flags_arg: @EnumLiteral(), comptime flag_arg: @EnumLiteral(), comptime ValueArg: type, ) type

参数

flags_arg: @EnumLiteral()
flag_arg: @EnumLiteral()
ValueArg: type

字段

value: ?Value

std.Build.Configuration.Storage.FlagOptional.flag

常量

第 2558 行

std.Build.Configuration.Storage.FlagOptional.flags

常量

第 2557 行

std.Build.Configuration.Storage.FlagOptional.storage

常量

第 2556 行

Storage

std.Build.Configuration.Storage.FlagOptional.Value

常量

第 2559 行

std.Build.Configuration.Storage.FlagUnion

类型函数

第 2564 行

字段类型由紧凑结构体中的枚举决定。

pub fn FlagUnion( comptime flags_arg: @EnumLiteral(), comptime flag_arg: @EnumLiteral(), comptime UnionArg: type, ) type

参数

flags_arg: @EnumLiteral()
flag_arg: @EnumLiteral()
UnionArg: type

字段

u: Union

std.Build.Configuration.Storage.FlagUnion.flag

常量

第 2574 行

std.Build.Configuration.Storage.FlagUnion.flags

常量

第 2573 行

std.Build.Configuration.Storage.FlagUnion.storage

常量

第 2572 行

Storage

std.Build.Configuration.Storage.FlagUnion.Tag

常量

第 2577 行

std.Build.Configuration.Storage.FlagUnion.Union

常量

第 2575 行

std.Build.Configuration.Storage.LengthPrefixedList

类型函数

第 2661 行

字段包含一个 u32 长度,后跟相应数量的元素。 每个元素必须具有明确定义的内存布局,此外其大小 可为任意个 u32 的整数倍。长度是元素数量, 而不是 u32 的数量。

pub fn LengthPrefixedList(comptime ElemArg: type) type

参数

ElemArg: type

字段

slice: []const Elem

std.Build.Configuration.Storage.LengthPrefixedList.Elem

常量

第 2666 行

std.Build.Configuration.Storage.LengthPrefixedList.initErased

函数

第 2668 行

pub fn initErased(s: []const u32) @This()

参数

s: []const u32

std.Build.Configuration.Storage.LengthPrefixedList.storage

常量

第 2665 行

Storage

std.Build.Configuration.Storage.MultiList

类型函数

第 2696 行

字段包含 u32 长度,其后先跟该数量的第一个字段元素, 再跟该数量的第二个字段元素,依此类推。

pub fn MultiList(comptime ElemArg: type) type

参数

ElemArg: type

字段

std.Build.Configuration.Storage.MultiList.Elem

常量

第 2701 行

std.Build.Configuration.Storage.MultiList.storage

常量

第 2700 行

Storage

std.Build.Configuration.Storage.setExtra

函数

第 2937 行

返回新的结束索引。

fn setExtra(buffer: []u32, index: usize, extra: anytype) usize

参数

buffer: []u32
index: usize

std.Build.Configuration.Storage.setExtraField

函数

第 2990 行

inline fn setExtraField(buffer: []u32, i: usize, comptime Field: type, value: anytype) usize

参数

buffer: []u32
i: usize
Field: type

std.Build.Configuration.Storage.UnionList

类型函数

第 2715 行

UnionArg 是以小整数作为枚举标签的带标签联合体。

flags 中的一个字段决定元数据是否存在。

元数据是一系列连续的位打包紧凑结构体,每项由 UnionArg 枚举标签和一个“last”布尔标记字段组成。 “last”为 true 时,该元素为最后一个,由此可确定列表长度。

随后是列表的各个元素,每个都可按位转换为 u32。

pub fn UnionList( comptime flags_arg: @EnumLiteral(), comptime flag_arg: @EnumLiteral(), comptime UnionArg: type, ) type

参数

flags_arg: @EnumLiteral()
flag_arg: @EnumLiteral()
UnionArg: type

字段

data: ?*const anyopaque

序列化时是 UnionArg 切片指针。 反序列化时是首个 UnionArg 元素的 extra 索引。

len: usize

std.Build.Configuration.Storage.UnionList.extraLen

函数

第 2763 行

fn extraLen(len: usize) usize

参数

len: usize

std.Build.Configuration.Storage.UnionList.flag

常量

第 2728 行

std.Build.Configuration.Storage.UnionList.flags

常量

第 2727 行

std.Build.Configuration.Storage.UnionList.get

函数

第 2749 行

仅在反序列化时允许调用。

pub fn get(this: *const @This(), extra: []const u32, i: usize) Union

参数

this: *const @This()
extra: []const u32
i: usize

std.Build.Configuration.Storage.UnionList.init

函数

第 2739 行

仅在序列化时调用才有效。

pub fn init(s: []const Union) @This()

参数

s: []const Union

std.Build.Configuration.Storage.UnionList.Meta

容器

第 2733 行

字段

tag: Tag
last: bool

std.Build.Configuration.Storage.UnionList.MetaInt

常量

第 2732 行

std.Build.Configuration.Storage.UnionList.slice

函数

第 2744 行

仅在反序列化时允许调用。

pub fn slice(this: *const @This(), extra: []const u32) []const u32

参数

this: *const @This()
extra: []const u32

std.Build.Configuration.Storage.UnionList.storage

常量

第 2726 行

Storage

std.Build.Configuration.Storage.UnionList.tag

函数

第 2757 行

仅在反序列化时允许调用。

pub fn tag(this: *const @This(), extra: []const u32, i: usize) Tag

参数

this: *const @This()
extra: []const u32
i: usize

std.Build.Configuration.Storage.UnionList.Tag

常量

第 2731 行

std.Build.Configuration.Storage.UnionList.Union

常量

第 2729 行

std.Build.Configuration.storeBits

函数

第 3202 行

当 value 跨多个字节时,按本机字节序存储位。 大端架构上:

  • 对于给定值,较早字节的位比后续字节的位具有更高权重。
  • bit_offset 使用 MSb 0 位编号方式。 小端架构上:
  • 对于给定值,较早字节的位比后续字节的位具有更低权重。
  • bit_offset 使用 LSb 0 位编号方式。
pub fn storeBits(comptime Int: type, buffer: []Int, bit_offset: usize, value: anytype) void

参数

Int: type
buffer: []Int
bit_offset: usize

std.Build.Configuration.String

容器

第 1946 行

指向 string_bytes 内部,以空字符终止。

字段

empty = 0
root = 1

字符串 "root"。

_

std.Build.Configuration.String.slice

函数

第 1952 行

pub fn slice(index: String, c: *const Configuration) [:0]const u8

参数

index: String
c: *const Configuration

std.Build.Configuration.StringList

容器

第 1844 行

指向 extra,第一个元素是字符串数量,后续 元素是相应数量的 String。

存储方式与 Deps 完全相同。

字段

_

std.Build.Configuration.StringList.slice

函数

第 1847 行

pub fn slice(this: @This(), c: *const Configuration) []const String

参数

this: @This()
c: *const Configuration

std.Build.Configuration.SystemIntegration

容器

第 446 行

字段

name: String
status: Status

std.Build.Configuration.SystemIntegration.Status

容器

第 450 行

字段

disabled = 0
enabled = 1

std.Build.Configuration.SystemLib

容器

第 2015 行

字段

name: String
flags: Flags

std.Build.Configuration.SystemLib.Flags

容器

第 2034 行

字段

needed: bool
weak: bool
use_pkg_config: UsePkgConfig
preferred_link_mode: LinkMode
search_strategy: SearchStrategy
_: u25 = 0

std.Build.Configuration.SystemLib.Index

类型

第 2019 行

std.Build.Configuration.SystemLib.LinkMode

别名

第 2032 行

别名目标 std.lang.LinkMode

std.Build.Configuration.SystemLib.SearchStrategy

容器

第 2043 行

字段

paths_first
mode_first
no_fallback

std.Build.Configuration.SystemLib.UsePkgConfig

容器

第 2021 行

字段

no

不使用 pkg-config,仅传入 -lfoo,其中 foo 为名称。

yes

尝试从 pkg-config 获取库链接信息。 若失败,则退回传递 -lfoo,其中 foo 为 name。

force

尝试从 pkg-config 获取库链接方式的信息。 失败则返回错误。

std.Build.Configuration.TargetQuery

容器

第 2172 行

字段

flags: Flags
cpu_features_add: Storage.FlagOptional(.flags, .cpu_features_add, std.Target.Cpu.Feature.Set)
cpu_features_sub: Storage.FlagOptional(.flags, .cpu_features_sub, std.Target.Cpu.Feature.Set)
cpu_name: Storage.EnumOptional(.flags, .cpu_model, .explicit, String)
os_version_min: Storage.FlagUnion(.flags, .os_version_min, OsVersion)
os_version_max: Storage.FlagUnion(.flags, .os_version_max, OsVersion)
glibc_version: Storage.FlagOptional(.flags, .glibc_version, String)
android_api_level: Storage.FlagOptional(.flags, .android_api_level, u32)
dynamic_linker: Storage.FlagOptional(.flags, .dynamic_linker, String)

std.Build.Configuration.TargetQuery.Abi

容器

第 2252 行

字段

none
gnu
gnuabin32
gnuabi64
gnueabi
gnueabihf
gnuf32
gnusf
gnux32
eabi
eabihf
abin32
x32
ilp32
android
androideabi
musl
muslabin32
muslabi64
musleabi
musleabihf
muslf32
muslsf
muslx32
msvc
itanium
simulator
ohos
ohoseabi
call0
default

std.Build.Configuration.TargetQuery.Abi.init

函数

第 2286 行

pub fn init(x: ?std.Target.Abi) @This()

参数

x: ?std.Target.Abi

std.Build.Configuration.TargetQuery.Abi.unwrap

函数

第 2292 行

pub fn unwrap(this: @This()) ?std.Target.Abi

参数

this: @This()

std.Build.Configuration.TargetQuery.CpuArch

容器

第 2300 行

字段

aarch64
aarch64_be
alpha
amdgcn
arc
arceb
arm
armeb
avr
bpfeb
bpfel
csky
ez80
hexagon
hppa
hppa64
kalimba
kvx
lanai
loongarch32
loongarch64
m68k
m88k
microblaze
microblazeel
mips
mipsel
mips64
mips64el
msp430
nvptx
nvptx64
or1k
powerpc
powerpcle
powerpc64
powerpc64le
propeller
riscv32
riscv32be
riscv64
riscv64be
s390x
sh
sheb
sparc
sparc64
spork8
spirv32
spirv64
thumb
thumbeb
ve
wasm32
wasm64
x86_16
x86
x86_64
xcore
xtensa
xtensaeb
default

std.Build.Configuration.TargetQuery.CpuArch.init

函数

第 2365 行

pub fn init(x: ?std.Target.Cpu.Arch) @This()

参数

std.Build.Configuration.TargetQuery.CpuArch.unwrap

函数

第 2371 行

pub fn unwrap(this: @This()) ?std.Target.Cpu.Arch

参数

this: @This()

std.Build.Configuration.TargetQuery.CpuModel

容器

第 2222 行

字段

native
baseline
determined_by_arch_os
explicit

std.Build.Configuration.TargetQuery.CpuModel.init

函数

第 2228 行

pub fn init(x: std.Target.Query.CpuModel) @This()

参数

std.Build.Configuration.TargetQuery.Flags

容器

第 2472 行

字段

cpu_arch: CpuArch
cpu_model: CpuModel
cpu_features_add: bool
cpu_features_sub: bool
os_tag: OsTag
abi: Abi
object_format: ObjectFormat
os_version_min: OsVersion.Tag
os_version_max: OsVersion.Tag
glibc_version: bool
android_api_level: bool
dynamic_linker: bool

std.Build.Configuration.TargetQuery.Index

容器

第 2184 行

字段

_

std.Build.Configuration.TargetQuery.Index.extraSlice

函数

第 2187 行

pub fn extraSlice(i: Index, extra: []const u32) []const u32

参数

i: Index
extra: []const u32

std.Build.Configuration.TargetQuery.Index.get

函数

第 2195 行

pub fn get(this: @This(), c: *const Configuration) TargetQuery

参数

this: @This()
c: *const Configuration

std.Build.Configuration.TargetQuery.Index.length

函数

第 2191 行

pub fn length(i: Index, extra: []const u32) usize

参数

i: Index
extra: []const u32

std.Build.Configuration.TargetQuery.ObjectFormat

容器

第 2445 行

字段

c
coff
elf
hex
macho
plan9
raw
spirv
wasm
default

std.Build.Configuration.TargetQuery.ObjectFormat.init

函数

第 2458 行

pub fn init(x: ?std.Target.ObjectFormat) @This()

参数

std.Build.Configuration.TargetQuery.ObjectFormat.unwrap

函数

第 2464 行

pub fn unwrap(this: @This()) ?std.Target.ObjectFormat

参数

this: @This()

std.Build.Configuration.TargetQuery.OptionalIndex

容器

第 2200 行

字段

none = max_u32
_

std.Build.Configuration.TargetQuery.OptionalIndex.get

函数

第 2217 行

pub fn get(this: @This(), c: *const Configuration) ?TargetQuery

参数

this: @This()
c: *const Configuration

std.Build.Configuration.TargetQuery.OptionalIndex.init

函数

第 2204 行

pub fn init(i: Index) OptionalIndex

参数

i: Index

std.Build.Configuration.TargetQuery.OptionalIndex.unwrap

函数

第 2210 行

pub fn unwrap(this: @This()) ?Index

参数

this: @This()

std.Build.Configuration.TargetQuery.OsTag

容器

第 2379 行

字段

freestanding
other
contiki
fuchsia
hermit
managarm
haiku
hurd
illumos
linux
plan9
rtems
serenity
dragonfly
freebsd
netbsd
openbsd
driverkit
ios
maccatalyst
macos
tvos
visionos
watchos
windows
uefi
@"3ds"
wiiu
@"switch"
gba
psx
ps3
ps4
ps5
psp
vita
emscripten
wasi
amdhsa
amdpal
cuda
mesa3d
nvcl
opencl
opengl
vulkan
tios
ashetos
default

std.Build.Configuration.TargetQuery.OsTag.init

函数

第 2431 行

pub fn init(x: ?std.Target.Os.Tag) @This()

参数

std.Build.Configuration.TargetQuery.OsTag.unwrap

函数

第 2437 行

pub fn unwrap(this: @This()) ?std.Target.Os.Tag

参数

this: @This()

std.Build.Configuration.TargetQuery.OsVersion

容器

第 2234 行

字段

none: void
semver: String
windows: std.Target.Os.WindowsVersion
default: void

std.Build.Configuration.TargetQuery.OsVersion.Tag

容器

第 2235 行

字段

none
semver
windows
default

std.Build.Configuration.TargetQuery.OsVersion.unwrap

函数

第 2242 行

pub fn unwrap(this: @This(), c: *const Configuration) ?std.Target.Query.OsVersion

参数

this: @This()
c: *const Configuration

std.Build.Configuration.TargetQuery.unwrapTarget

函数

第 2487 行

pub fn unwrapTarget(tq: *const TargetQuery, c: *const Configuration) std.Target

参数

tq: *const TargetQuery
c: *const Configuration

std.Build.Configuration.Wip

容器

第 47 行

字段

gpa: Allocator
string_table: StringTable = .empty
dedupe_table: DedupeTable = .empty

对 extra 内的数组去重。

targets_table: TargetsTable = .empty
string_bytes: std.ArrayList(u8) = .empty
unlazy_deps: std.ArrayList(String) = .empty
system_integrations: std.ArrayList(SystemIntegration) = .empty
available_options: std.ArrayList(AvailableOption) = .empty
steps: std.ArrayList(Step) = .empty
path_deps: std.ArrayList(PathDep) = .empty
search_prefixes: std.ArrayList(String) = .empty
extra: std.ArrayList(u32) = .empty
next_generated_file_index: u32 = 0
cache_poison: bool = false

std.Build.Configuration.Wip.addBytes

函数

第 230 行

pub fn addBytes(wip: *Wip, bytes: []const u8) Allocator.Error!Bytes

参数

wip: *Wip
bytes: []const u8

错误

OutOfMemory

std.Build.Configuration.Wip.addDeduped

函数

第 395 行

类似 addExtra,但使用哈希表,可能返回已有索引, 而非追加到 extra。

pub fn addDeduped(wip: *Wip, comptime T: type, v: T) Allocator.Error!T.Index

参数

wip: *Wip
T: type
v: T

错误

OutOfMemory

std.Build.Configuration.Wip.addExtra

函数

第 381 行

pub fn addExtra(wip: *Wip, comptime T: type, v: T) Allocator.Error!T.Index

参数

wip: *Wip
T: type
v: T

错误

OutOfMemory

std.Build.Configuration.Wip.addExtraErased

函数

第 387 行

pub fn addExtraErased(wip: *Wip, comptime T: type, v: T) Allocator.Error!u32

参数

wip: *Wip
T: type
v: T

错误

OutOfMemory

std.Build.Configuration.Wip.addExtraOptionalStringAssumeCapacity

函数

第 429 行

fn addExtraOptionalStringAssumeCapacity(wip: *Wip, optional_string: ?String) void

参数

wip: *Wip
optional_string: ?String

std.Build.Configuration.Wip.addExtraReserved

函数

第 419 行

pub fn addExtraReserved(wip: *Wip, comptime T: type, v: T) T.Index

参数

wip: *Wip
T: type
v: T

std.Build.Configuration.Wip.addExtraReservedErased

函数

第 423 行

pub fn addExtraReservedErased(wip: *Wip, comptime T: type, v: T) u32

参数

wip: *Wip
T: type
v: T

std.Build.Configuration.Wip.addGeneratedFile

函数

第 434 行

pub fn addGeneratedFile(wip: *Wip) GeneratedFileIndex

参数

wip: *Wip

std.Build.Configuration.Wip.addOptionalString

函数

第 205 行

pub fn addOptionalString(wip: *Wip, bytes: ?[]const u8) Allocator.Error!OptionalString

参数

wip: *Wip
bytes: ?[]const u8

错误

OutOfMemory

std.Build.Configuration.Wip.addSemVer

函数

第 238 行

pub fn addSemVer(wip: *Wip, sv: std.SemanticVersion) Allocator.Error!String

参数

wip: *Wip
sv: std.SemanticVersion

错误

OutOfMemory

std.Build.Configuration.Wip.addString

函数

第 183 行

pub fn addString(wip: *Wip, bytes: []const u8) Allocator.Error!String

参数

wip: *Wip
bytes: []const u8

错误

OutOfMemory

std.Build.Configuration.Wip.addStringList

函数

第 209 行

pub fn addStringList(wip: *Wip, list: []const []const u8) Allocator.Error!StringList

参数

wip: *Wip
list: []const []const u8

错误

OutOfMemory

std.Build.Configuration.Wip.addTarget

函数

第 306 行

pub fn addTarget(wip: *Wip, t: std.Target) !TargetQuery.Index

参数

wip: *Wip
t: std.Target

std.Build.Configuration.Wip.addTargetQuery

函数

第 245 行

pub fn addTargetQuery(wip: *Wip, q: *const std.Target.Query) !TargetQuery.OptionalIndex

参数

wip: *Wip
q: *const std.Target.Query

std.Build.Configuration.Wip.DedupeTable

类型

第 65 行

std.Build.Configuration.Wip.deinit

函数

第 133 行

pub fn deinit(wip: *Wip) void

参数

wip: *Wip

std.Build.Configuration.Wip.ExtraSlice

容器

第 68 行

字段

index: u32
len: u32

std.Build.Configuration.Wip.ExtraSlice.Context

容器

第 72 行

字段

extra: []const u32

std.Build.Configuration.Wip.ExtraSlice.Context.eql

函数

第 75 行

pub fn eql(ctx: @This(), a: ExtraSlice, b: ExtraSlice) bool

参数

ctx: @This()
a: ExtraSlice
b: ExtraSlice

std.Build.Configuration.Wip.ExtraSlice.Context.hash

函数

第 81 行

pub fn hash(ctx: @This(), key: ExtraSlice) u64

参数

ctx: @This()
key: ExtraSlice

std.Build.Configuration.Wip.init

函数

第 129 行

pub fn init(gpa: Allocator) Wip

参数

gpa: Allocator

std.Build.Configuration.Wip.Static

容器

第 146 行

字段

default_step: Step.Index
generated_files_len: u32
poisoned: bool

std.Build.Configuration.Wip.stringSlice

函数

第 440 行

下一次向配置追加内容时,返回的切片失效。

pub fn stringSlice(wip: *const Wip, s: String) [:0]const u8

参数

wip: *const Wip
s: String

std.Build.Configuration.Wip.StringTable

类型

第 103 行

std.Build.Configuration.Wip.StringTableContext

容器

第 104 行

字段

bytes: []const u8

std.Build.Configuration.Wip.StringTableContext.eql

函数

第 107 行

pub fn eql(_: @This(), a: String, b: String) bool

参数

_: @This()
a: String
b: String

std.Build.Configuration.Wip.StringTableContext.hash

函数

第 111 行

pub fn hash(ctx: @This(), key: String) u64

参数

ctx: @This()
key: String

std.Build.Configuration.Wip.StringTableIndexAdapter

容器

第 116 行

字段

bytes: []const u8

std.Build.Configuration.Wip.StringTableIndexAdapter.eql

函数

第 119 行

pub fn eql(ctx: @This(), a: []const u8, b: String) bool

参数

ctx: @This()
a: []const u8
b: String

std.Build.Configuration.Wip.StringTableIndexAdapter.hash

函数

第 123 行

pub fn hash(_: @This(), adapted_key: []const u8) u64

参数

_: @This()
adapted_key: []const u8

std.Build.Configuration.Wip.TargetsTable

类型

第 66 行

std.Build.Configuration.Wip.TargetsTableContext

容器

第 88 行

字段

extra: []const u32

std.Build.Configuration.Wip.TargetsTableContext.eql

函数

第 91 行

pub fn eql(ctx: @This(), a: TargetQuery.Index, b: TargetQuery.Index) bool

参数

ctx: @This()
a: TargetQuery.Index
b: TargetQuery.Index

std.Build.Configuration.Wip.TargetsTableContext.hash

函数

第 97 行

pub fn hash(ctx: @This(), key: TargetQuery.Index) u64

参数

ctx: @This()
key: TargetQuery.Index

std.Build.Configuration.Wip.write

函数

第 152 行

pub fn write(wip: *Wip, w: *Io.Writer, static: Static) Io.Writer.Error!void

参数

wip: *Wip
w: *Io.Writer
static: Static

错误

WriteFailed

详细诊断信息见 Writer 实现。

源码

std/Build/Configuration.zig

const Configuration = @This();

const std = @import("../std.zig");
const builtin = @import("builtin");
const Io = std.Io;
const Allocator = std.mem.Allocator;
const assert = std.debug.assert;
const max_u32 = std.math.maxInt(u32);
const native_endian = builtin.target.cpu.arch.endian();

string_bytes: []u8,
steps: []Step,
path_deps: []PathDep,
unlazy_deps: []String,
system_integrations: []SystemIntegration,
available_options: []AvailableOption,
search_prefixes: []String,
extra: []u32,
default_step: Step.Index,
generated_files_len: u32,
poisoned: bool,

/// 此处字段顺序与 `Configuration` 一致,
/// 后者说明序列化格式中的顺序。
pub const Header = extern struct {
    string_bytes_len: u32,
    steps_len: u32,
    path_deps_len: u32,
    unlazy_deps_len: u32,
    system_integrations_len: u32,
    available_options_len: u32,
    search_prefixes_len: u32,
    extra_len: u32,

    default_step: Step.Index,
    /// 实际上不为此存储数据;它仅使执行进程能够为这些项目预分配数组。
    ///
    generated_files_len: u32,
    flags: Flags,

    pub const Flags = packed struct(u32) {
        poisoned: bool,
        _: u31 = 0,
    };
};

pub const Wip = struct {
    gpa: Allocator,
    string_table: StringTable = .empty,
    /// 对 `extra` 内的数组去重。
    dedupe_table: DedupeTable = .empty,
    targets_table: TargetsTable = .empty,

    string_bytes: std.ArrayList(u8) = .empty,
    unlazy_deps: std.ArrayList(String) = .empty,
    system_integrations: std.ArrayList(SystemIntegration) = .empty,
    available_options: std.ArrayList(AvailableOption) = .empty,
    steps: std.ArrayList(Step) = .empty,
    path_deps: std.ArrayList(PathDep) = .empty,
    search_prefixes: std.ArrayList(String) = .empty,
    extra: std.ArrayList(u32) = .empty,
    next_generated_file_index: u32 = 0,
    cache_poison: bool = false,

    const DedupeTable = std.HashMapUnmanaged(ExtraSlice, void, ExtraSlice.Context, std.hash_map.default_max_load_percentage);
    const TargetsTable = std.HashMapUnmanaged(TargetQuery.Index, void, TargetsTableContext, std.hash_map.default_max_load_percentage);

    const ExtraSlice = struct {
        index: u32,
        len: u32,

        const Context = struct {
            extra: []const u32,

            pub fn eql(ctx: @This(), a: ExtraSlice, b: ExtraSlice) bool {
                const slice_a = ctx.extra[a.index..][0..a.len];
                const slice_b = ctx.extra[b.index..][0..b.len];
                return std.mem.eql(u32, slice_a, slice_b);
            }

            pub fn hash(ctx: @This(), key: ExtraSlice) u64 {
                const slice = ctx.extra[key.index..][0..key.len];
                return std.hash_map.hashString(@ptrCast(slice));
            }
        };
    };

    const TargetsTableContext = struct {
        extra: []const u32,

        pub fn eql(ctx: @This(), a: TargetQuery.Index, b: TargetQuery.Index) bool {
            const slice_a = a.extraSlice(ctx.extra);
            const slice_b = b.extraSlice(ctx.extra);
            return std.mem.eql(u32, slice_a, slice_b);
        }

        pub fn hash(ctx: @This(), key: TargetQuery.Index) u64 {
            const slice = key.extraSlice(ctx.extra);
            return std.hash_map.hashString(@ptrCast(slice));
        }
    };

    const StringTable = std.HashMapUnmanaged(String, void, StringTableContext, std.hash_map.default_max_load_percentage);
    const StringTableContext = struct {
        bytes: []const u8,

        pub fn eql(_: @This(), a: String, b: String) bool {
            return a == b;
        }

        pub fn hash(ctx: @This(), key: String) u64 {
            return std.hash_map.hashString(std.mem.sliceTo(ctx.bytes[@backingInt(key)..], 0));
        }
    };

    const StringTableIndexAdapter = struct {
        bytes: []const u8,

        pub fn eql(ctx: @This(), a: []const u8, b: String) bool {
            return std.mem.eql(u8, a, std.mem.sliceTo(ctx.bytes[@backingInt(b)..], 0));
        }

        pub fn hash(_: @This(), adapted_key: []const u8) u64 {
            assert(std.mem.findScalar(u8, adapted_key, 0) == null);
            return std.hash_map.hashString(adapted_key);
        }
    };

    pub fn init(gpa: Allocator) Wip {
        return .{ .gpa = gpa };
    }

    pub fn deinit(wip: *Wip) void {
        const gpa = wip.gpa;
        wip.string_bytes.deinit(gpa);
        wip.unlazy_deps.deinit(gpa);
        wip.system_integrations.deinit(gpa);
        wip.available_options.deinit(gpa);
        wip.steps.deinit(gpa);
        wip.path_deps.deinit(gpa);
        wip.search_prefixes.deinit(gpa);
        wip.extra.deinit(gpa);
        wip.* = undefined;
    }

    pub const Static = struct {
        default_step: Step.Index,
        generated_files_len: u32,
        poisoned: bool,
    };

    pub fn write(wip: *Wip, w: *Io.Writer, static: Static) Io.Writer.Error!void {
        const header: Header = .{
            .string_bytes_len = @intCast(wip.string_bytes.items.len),
            .steps_len = @intCast(wip.steps.items.len),
            .path_deps_len = @intCast(wip.path_deps.items.len),
            .unlazy_deps_len = @intCast(wip.unlazy_deps.items.len),
            .system_integrations_len = @intCast(wip.system_integrations.items.len),
            .available_options_len = @intCast(wip.available_options.items.len),
            .search_prefixes_len = @intCast(wip.search_prefixes.items.len),
            .extra_len = @intCast(wip.extra.items.len),

            .default_step = static.default_step,
            .generated_files_len = static.generated_files_len,
            .flags = .{
                .poisoned = static.poisoned,
            },
        };
        var buffers = [_][]const u8{
            @ptrCast(&header),
            wip.string_bytes.items,
            @ptrCast(wip.steps.items),
            @ptrCast(wip.path_deps.items),
            @ptrCast(wip.unlazy_deps.items),
            @ptrCast(wip.system_integrations.items),
            @ptrCast(wip.available_options.items),
            @ptrCast(wip.search_prefixes.items),
            @ptrCast(wip.extra.items),
        };
        try w.writeVecAll(&buffers);
    }

    pub fn addString(wip: *Wip, bytes: []const u8) Allocator.Error!String {
        const gpa = wip.gpa;
        assert(std.mem.findScalar(u8, bytes, 0) == null);
        const gop = try wip.string_table.getOrPutContextAdapted(
            gpa,
            @as([]const u8, bytes),
            @as(StringTableIndexAdapter, .{ .bytes = wip.string_bytes.items }),
            @as(StringTableContext, .{ .bytes = wip.string_bytes.items }),
        );
        if (gop.found_existing) return gop.key_ptr.*;

        try wip.string_bytes.ensureUnusedCapacity(gpa, bytes.len + 1);
        const new_off: String = @fromBackingInt(@intCast(wip.string_bytes.items.len));

        wip.string_bytes.appendSliceAssumeCapacity(bytes);
        wip.string_bytes.appendAssumeCapacity(0);

        gop.key_ptr.* = new_off;

        return new_off;
    }

    pub fn addOptionalString(wip: *Wip, bytes: ?[]const u8) Allocator.Error!OptionalString {
        return .init(try addString(wip, bytes orelse return .none));
    }

    pub fn addStringList(wip: *Wip, list: []const []const u8) Allocator.Error!StringList {
        // 扩展 extra 以容纳列表,并将字符串列表添加
        // 到其中。随后检查重复项,若已存在则回退列表。
        const gpa = wip.gpa;
        const revert_index: u32 = @intCast(wip.extra.items.len);
        const added = try wip.extra.addManyAsSlice(gpa, list.len + 1);
        added[0] = @intCast(list.len);
        for (added[1..], list) |*d, s| d.* = @backingInt(try addString(wip, s));
        const gop = try wip.dedupe_table.getOrPutContext(gpa, .{
            .index = revert_index,
            .len = @intCast(added.len),
        }, @as(ExtraSlice.Context, .{ .extra = wip.extra.items }));

        if (gop.found_existing) {
            wip.extra.items.len = revert_index;
            return @fromBackingInt(@intCast(gop.key_ptr.index));
        }

        return @fromBackingInt(@intCast(revert_index));
    }

    pub fn addBytes(wip: *Wip, bytes: []const u8) Allocator.Error!Bytes {
        try wip.string_bytes.appendSlice(wip.gpa, bytes);
        return .{
            .index = @intCast(wip.string_bytes.items.len - bytes.len),
            .len = @intCast(bytes.len),
        };
    }

    pub fn addSemVer(wip: *Wip, sv: std.SemanticVersion) Allocator.Error!String {
        var buffer: [256]u8 = undefined;
        var writer: std.Io.Writer = .fixed(&buffer);
        sv.format(&writer) catch return error.OutOfMemory;
        return addString(wip, writer.buffered());
    }

    pub fn addTargetQuery(wip: *Wip, q: *const std.Target.Query) !TargetQuery.OptionalIndex {
        if (q.isNative()) return .none;
        const gpa = wip.gpa;
        const cpu_name: ?String = switch (q.cpu_model) {
            .native, .baseline, .determined_by_arch_os => null,
            .explicit => |model| try wip.addString(model.name),
        };
        const os_version_min: TargetQuery.OsVersion = if (q.os_version_min) |ver| switch (ver) {
            .none => .none,
            .semver => |sem_ver| .{ .semver = try wip.addSemVer(sem_ver) },
            .windows => |win_ver| .{ .windows = win_ver },
        } else .default;
        const os_version_max: TargetQuery.OsVersion = if (q.os_version_max) |ver| switch (ver) {
            .none => .none,
            .semver => |sem_ver| .{ .semver = try wip.addSemVer(sem_ver) },
            .windows => |win_ver| .{ .windows = win_ver },
        } else .default;
        const glibc_version: ?String = if (q.glibc_version) |sem_ver| try wip.addSemVer(sem_ver) else null;
        const dynamic_linker: ?String = if (q.dynamic_linker) |*dl|
            if (dl.get()) |s| try wip.addString(s) else .empty
        else
            null;
        const cpu_features_add_empty = q.cpu_features_add.isEmpty();
        const cpu_features_sub_empty = q.cpu_features_sub.isEmpty();
        const result_index: TargetQuery.Index = try wip.addExtra(TargetQuery, .{
            .flags = .{
                .cpu_arch = .init(q.cpu_arch),
                .cpu_model = .init(q.cpu_model),
                .cpu_features_add = !cpu_features_add_empty,
                .cpu_features_sub = !cpu_features_sub_empty,
                .os_tag = .init(q.os_tag),
                .abi = .init(q.abi),
                .object_format = .init(q.ofmt),
                .os_version_min = os_version_min,
                .os_version_max = os_version_max,
                .glibc_version = glibc_version != null,
                .android_api_level = q.android_api_level != null,
                .dynamic_linker = dynamic_linker != null,
            },
            .cpu_features_add = .{ .value = if (cpu_features_add_empty) null else q.cpu_features_add },
            .cpu_features_sub = .{ .value = if (cpu_features_sub_empty) null else q.cpu_features_sub },
            .glibc_version = .{ .value = glibc_version },
            .android_api_level = .{ .value = q.android_api_level },
            .dynamic_linker = .{ .value = dynamic_linker },
            .cpu_name = .{ .value = cpu_name },
            .os_version_min = .{ .u = os_version_min },
            .os_version_max = .{ .u = os_version_max },
        });

        // 去重。
        const gop = try wip.targets_table.getOrPutContext(gpa, result_index, @as(TargetsTableContext, .{
            .extra = wip.extra.items,
        }));
        if (gop.found_existing) {
            wip.extra.items.len = @backingInt(result_index);
            return .init(gop.key_ptr.*);
        } else {
            return .init(result_index);
        }
    }

    pub fn addTarget(wip: *Wip, t: std.Target) !TargetQuery.Index {
        const gpa = wip.gpa;
        const cpu_name: String = try wip.addString(t.cpu.model.name);

        const os_version_min: TargetQuery.OsVersion, const os_version_max: TargetQuery.OsVersion, const glibc_version: ?String, const android_api_level: ?u32 = switch (t.os.versionRange()) {
            .none => .{
                .none,
                .none,
                null,
                null,
            },
            .semver => |range| .{
                .{ .semver = try wip.addSemVer(range.min) },
                .{ .semver = try wip.addSemVer(range.max) },
                null,
                null,
            },
            .hurd => |hurd| .{
                .{ .semver = try wip.addSemVer(hurd.range.min) },
                .{ .semver = try wip.addSemVer(hurd.range.max) },
                try wip.addSemVer(hurd.glibc),
                null,
            },
            .linux => |linux| .{
                .{ .semver = try wip.addSemVer(linux.range.min) },
                .{ .semver = try wip.addSemVer(linux.range.max) },
                try wip.addSemVer(linux.glibc),
                linux.android,
            },
            .windows => |range| .{
                .{ .windows = range.min },
                .{ .windows = range.max },
                null,
                null,
            },
        };
        const dynamic_linker: ?String = if (t.dynamic_linker.get()) |dl| try wip.addString(dl) else null;
        const cpu_features_add_empty = t.cpu.features.isEmpty();
        const result_index = try wip.addExtra(TargetQuery, .{
            .flags = .{
                .cpu_arch = .init(t.cpu.arch),
                .cpu_model = .explicit,
                .cpu_features_add = !cpu_features_add_empty,
                .cpu_features_sub = false,
                .os_tag = .init(t.os.tag),
                .abi = .init(t.abi),
                .object_format = .init(t.ofmt),
                .os_version_min = os_version_min,
                .os_version_max = os_version_max,
                .glibc_version = glibc_version != null,
                .android_api_level = android_api_level != null,
                .dynamic_linker = dynamic_linker != null,
            },
            .cpu_features_add = .{ .value = if (cpu_features_add_empty) null else t.cpu.features },
            .cpu_features_sub = .{ .value = null },
            .glibc_version = .{ .value = glibc_version },
            .android_api_level = .{ .value = android_api_level },
            .dynamic_linker = .{ .value = dynamic_linker },
            .cpu_name = .{ .value = cpu_name },
            .os_version_min = .{ .u = os_version_min },
            .os_version_max = .{ .u = os_version_max },
        });

        // 去重。
        const gop = try wip.targets_table.getOrPutContext(gpa, result_index, @as(TargetsTableContext, .{
            .extra = wip.extra.items,
        }));
        if (gop.found_existing) {
            wip.extra.items.len = @backingInt(result_index);
            return gop.key_ptr.*;
        } else {
            return result_index;
        }
    }

    pub fn addExtra(wip: *Wip, comptime T: type, v: T) Allocator.Error!T.Index {
        const extra_len = Storage.extraLen(v);
        try wip.extra.ensureUnusedCapacity(wip.gpa, extra_len);
        return addExtraReserved(wip, T, v);
    }

    pub fn addExtraErased(wip: *Wip, comptime T: type, v: T) Allocator.Error!u32 {
        const extra_len = Storage.extraLen(v);
        try wip.extra.ensureUnusedCapacity(wip.gpa, extra_len);
        return addExtraReservedErased(wip, T, v);
    }

    /// 类似 `addExtra`,但使用哈希表,可能返回已有索引,
    /// 而非追加到 `extra`。
    pub fn addDeduped(wip: *Wip, comptime T: type, v: T) Allocator.Error!T.Index {
        const gpa = wip.gpa;
        const revert_index = wip.extra.items.len;
        const upper_bound_len = Storage.extraLen(v);
        try wip.extra.ensureUnusedCapacity(gpa, upper_bound_len);
        try wip.dedupe_table.ensureUnusedCapacityContext(gpa, 1, @as(ExtraSlice.Context, .{
            .extra = wip.extra.items,
        }));
        const new_index = addExtraReservedErased(wip, T, v);
        const len: u32 = @intCast(wip.extra.items.len - new_index);
        assert(len != 0);
        const gop = wip.dedupe_table.getOrPutAssumeCapacityContext(.{
            .index = new_index,
            .len = len,
        }, @as(ExtraSlice.Context, .{ .extra = wip.extra.items }));

        if (gop.found_existing) {
            wip.extra.items.len = revert_index;
            return @fromBackingInt(@intCast(gop.key_ptr.index));
        }

        return @fromBackingInt(@intCast(new_index));
    }

    pub fn addExtraReserved(wip: *Wip, comptime T: type, v: T) T.Index {
        return @fromBackingInt(@intCast(addExtraReservedErased(wip, T, v)));
    }

    pub fn addExtraReservedErased(wip: *Wip, comptime T: type, v: T) u32 {
        const result: u32 = @intCast(wip.extra.items.len);
        wip.extra.items.len = Storage.setExtra(wip.extra.allocatedSlice(), result, v);
        return result;
    }

    fn addExtraOptionalStringAssumeCapacity(wip: *Wip, optional_string: ?String) void {
        const string = optional_string orelse return;
        wip.extra.appendAssumeCapacity(@backingInt(string));
    }

    pub fn addGeneratedFile(wip: *Wip) GeneratedFileIndex {
        defer wip.next_generated_file_index += 1;
        return @fromBackingInt(@intCast(wip.next_generated_file_index));
    }

    /// 下一次向配置追加内容时,返回的切片失效。
    pub fn stringSlice(wip: *const Wip, s: String) [:0]const u8 {
        const start_slice = wip.string_bytes.items[@backingInt(s)..];
        return start_slice[0..std.mem.findScalar(u8, start_slice, 0).? :0];
    }
};

pub const SystemIntegration = extern struct {
    name: String,
    status: Status,

    pub const Status = enum(u32) {
        disabled = 0,
        enabled = 1,
    };
};

pub const AvailableOption = extern struct {
    name: String,
    description: String,
    type: Type,
    /// 若 `type_id` 为 `enum` 或 `enum_list`,则提供枚举选项列表
    enum_options: OptionalStringList,

    pub const Type = enum(u8) {
        bool,
        int,
        float,
        @"enum",
        enum_list,
        string,
        list,
        build_id,
        lazy_path,
        lazy_path_list,
    };
};

pub const Step = extern struct {
    name: String,
    owner: Package.Index,
    deps: Deps.Index,
    max_rss: MaxRss,
    extended: Storage.Extended(Flags, union(Tag) {
        check_file: CheckFile,
        compile: Compile,
        config_header: ConfigHeader,
        fail: Fail,
        find_program: FindProgram,
        fmt: Fmt,
        install_artifact: InstallArtifact,
        install_dir: InstallDir,
        install_file: InstallFile,
        obj_copy: ObjCopy,
        options: Options,
        run: Run,
        top_level: TopLevel,
        translate_c: TranslateC,
        update_source_files: UpdateSourceFiles,
        write_file: WriteFile,
    }),

    /// 指向 `steps` 内部。
    pub const Index = enum(u32) {
        _,

        pub fn ptr(i: Index, c: *const Configuration) *const Step {
            return &c.steps[@backingInt(i)];
        }
    };

    /// 由所有步骤共享。
    pub const Flags = packed struct(u32) {
        tag: Tag,
        _: u27 = 0,
    };

    pub const Tag = enum(u5) {
        check_file,
        compile,
        config_header,
        fail,
        find_program,
        fmt,
        install_artifact,
        install_dir,
        install_file,
        obj_copy,
        options,
        run,
        top_level,
        translate_c,
        update_source_files,
        write_file,
    };

    pub const TopLevel = struct {
        flags: @This().Flags = .{},
        description: String,

        pub const Flags = packed struct(u32) {
            tag: Tag = .top_level,
            _: u27 = 0,
        };
    };

    /// 首个依赖步骤索引为编译步骤,
    /// 其产物由当前步骤安装。
    pub const InstallArtifact = struct {
        flags: @This().Flags,
        bin_dir: Storage.FlagOptional(.flags, .bin_dir, InstallDestDir),
        implib_dir: Storage.FlagOptional(.flags, .implib_dir, InstallDestDir),
        pdb_dir: Storage.FlagOptional(.flags, .pdb_dir, InstallDestDir),
        h_dir: Storage.FlagOptional(.flags, .h_dir, InstallDestDir),
        bin_sub_path: Storage.FlagOptional(.flags, .bin_sub_path, String),

        pub const Flags = packed struct(u32) {
            tag: Tag = .install_artifact,
            dylib_symlinks: bool,
            bin_dir: bool,
            implib_dir: bool,
            pdb_dir: bool,
            h_dir: bool,
            bin_sub_path: bool,
            _: u21 = 0,
        };
    };

    pub const Run = struct {
        flags: @This().Flags,
        flags2: Flags2,
        args: Storage.LengthPrefixedList(Arg.Index),
        cwd: Storage.FlagOptional(.flags, .cwd, LazyPath.Index),
        preopens: Storage.FlagLengthPrefixedList(.flags, .preopens, Preopen),
        captured_stdout: Storage.FlagOptional(.flags, .captured_stdout, CapturedStream),
        captured_stderr: Storage.FlagOptional(.flags, .captured_stderr, CapturedStream),
        file_inputs: Storage.LengthPrefixedList(LazyPath.Index),
        stdio_limit: Storage.FlagOptional(.flags, .stdio_limit, u64),
        /// 始终为编译步骤。
        producer: Storage.FlagOptional(.flags, .producer, Step.Index),
        /// 前一半为键,后一半为值。
        environ_map: Storage.FlagOptional(.flags, .environ_map, EnvironMap.Index),
        stdin: Storage.FlagUnion(.flags, .stdin, StdIn),
        expect_stderr_exact: Storage.FlagOptional(.flags2, .expect_stderr_exact, Bytes),
        expect_stdout_exact: Storage.FlagOptional(.flags2, .expect_stdout_exact, Bytes),
        expect_stderr_match: Storage.FlagLengthPrefixedList(.flags2, .expect_stderr_match, Bytes),
        expect_stdout_match: Storage.FlagLengthPrefixedList(.flags2, .expect_stdout_match, Bytes),
        expect_term_value: Storage.FlagOptional(.flags2, .expect_term, u32),
        expect_stdout_snapshot: Storage.FlagOptional(.flags2, .expect_stdout_snapshot, LazyPath.Index),
        expect_stderr_snapshot: Storage.FlagOptional(.flags2, .expect_stderr_snapshot, LazyPath.Index),

        pub const CapturedStream = extern struct {
            generated_file: GeneratedFileIndex,
            basename: String,
        };

        pub const Arg = struct {
            flags: @This().Flags,
            prefix: Storage.FlagOptional(.flags, .prefix, String),
            suffix: Storage.FlagOptional(.flags, .suffix, String),
            basename: Storage.FlagOptional(.flags, .basename, String),
            path: Storage.FlagOptional(.flags, .path, LazyPath.Index),
            /// 始终为编译步骤。
            producer: Storage.FlagOptional(.flags, .producer, Step.Index),
            generated: Storage.FlagOptional(.flags, .generated, GeneratedFileIndex),

            pub const Flags = packed struct(u32) {
                tag: Arg.Tag,
                prefix: bool,
                suffix: bool,
                basename: bool,
                path: bool,
                producer: bool,
                generated: bool,
                dep_file: bool,
                make_absolute: bool,
                _: u20 = 0,
            };

            pub const Tag = enum(u4) {
                artifact,
                /// `path` 包含该文件。
                path_file,
                path_directory,
                /// `prefix` 包含此字符串。
                string,
                file_content,
                output_file,
                output_directory,
                passthru,
                /// `prefix` 包含启用状态的字符串。
                /// `suffix` 包含禁用状态的字符串。
                enable_darling,
                enable_qemu,
                enable_rosetta,
                enable_wasmtime,
                enable_wine,
            };

            pub const Index = IndexType(@This());
        };

        pub const Color = enum(u4) {
            /// 已设置 `CLICOLOR_FORCE`,且未设置 `NO_COLOR`。
            enable,
            /// 已设置 `NO_COLOR`,且未设置 `CLICOLOR_FORCE`。
            disable,
            /// 构建运行器使用颜色时等价于 `.enable`,否则等价于 `.disable`。
            inherit,
            /// 若捕获或检查 stderr,则等价于 `.disable`;否则等价于 `.inherit`。
            auto,
            /// 构建运行器不修改 `CLICOLOR_FORCE` 或 `NO_COLOR` 环境变量。
            /// 它们按普通变量处理,因此可通过 `setEnvironmentVariable` 控制。
            manual,
        };

        pub const Preopen = extern struct {
            name: String,
            path: LazyPath.Index,
        };

        pub const StdIn = union(@This().Tag) {
            none: void,
            bytes: Bytes,
            lazy_path: LazyPath.Index,

            pub const Tag = enum(u2) { none, bytes, lazy_path };
        };
        pub const TrimWhitespace = enum(u2) { none, all, leading, trailing };
        pub const StdIo = enum(u3) { infer_from_args, inherit, check, zig_test, protocol };

        pub const ExpectTermStatus = enum(u2) { exited, signal, stopped, unknown };

        pub const Flags = packed struct(u32) {
            tag: Tag = .run,
            disable_zig_progress: bool,
            skip_foreign_checks: bool,
            failing_to_execute_foreign_is_an_error: bool,
            has_side_effects: bool,
            color: Color,
            stdin: StdIn.Tag,
            stdio: StdIo,
            stdout_trim_whitespace: TrimWhitespace,
            stderr_trim_whitespace: TrimWhitespace,
            stdio_limit: bool,
            producer: bool,
            cwd: bool,
            captured_stdout: bool,
            captured_stderr: bool,
            environ_map: bool,
            preopens: bool,
            _: u3 = 0,
        };

        pub const Flags2 = packed struct(u32) {
            expect_stderr_exact: bool,
            expect_stdout_exact: bool,
            expect_stderr_match: bool,
            expect_stdout_match: bool,
            expect_term: bool,
            expect_term_status: ExpectTermStatus,
            expect_stdout_snapshot: bool,
            expect_stderr_snapshot: bool,
            _: u23 = 0,
        };
    };

    pub const Compile = struct {
        flags: @This().Flags,
        flags2: Flags2,
        flags3: Flags3,
        flags4: Flags4,

        root_module: Module.Index,
        root_name: String,

        filters: Storage.FlagLengthPrefixedList(.flags, .filters_len, String),
        installed_headers: Storage.FlagLengthPrefixedList(.flags, .installed_headers_len, Storage.Extended(InstalledHeader.Flags, InstalledHeader)),
        force_undefined_symbols: Storage.FlagLengthPrefixedList(.flags, .force_undefined_symbols_len, String),
        expect_errors: Storage.FlagUnion(.flags4, .expect_errors, ExpectErrors),
        linker_script: Storage.FlagOptional(.flags4, .linker_script, LazyPath.Index),
        version_script: Storage.FlagOptional(.flags4, .version_script, LazyPath.Index),
        zig_lib_dir: Storage.FlagOptional(.flags3, .zig_lib_dir, LazyPath.Index),
        libc_file: Storage.FlagOptional(.flags4, .libc_file, LazyPath.Index),
        win32_manifest: Storage.FlagOptional(.flags3, .win32_manifest, LazyPath.Index),
        win32_module_definition: Storage.FlagOptional(.flags3, .win32_module_definition, LazyPath.Index),
        entitlements: Storage.FlagOptional(.flags4, .entitlements, LazyPath.Index),
        version: Storage.FlagOptional(.flags3, .version, String), // 语义化版本字符串
        entry: Storage.EnumOptional(.flags3, .entry, .symbol_name, String),
        install_name: Storage.FlagOptional(.flags4, .install_name, String),
        initial_memory: Storage.FlagOptional(.flags3, .initial_memory, u64),
        max_memory: Storage.FlagOptional(.flags3, .max_memory, u64),
        global_base: Storage.FlagOptional(.flags3, .global_base, u64),
        image_base: Storage.FlagOptional(.flags3, .image_base, u64),
        link_z_common_page_size: Storage.FlagOptional(.flags4, .link_z_common_page_size, u64),
        link_z_max_page_size: Storage.FlagOptional(.flags4, .link_z_max_page_size, u64),
        pagezero_size: Storage.FlagOptional(.flags4, .pagezero_size, u64),
        stack_size: Storage.FlagOptional(.flags4, .stack_size, u64),
        headerpad_size: Storage.FlagOptional(.flags4, .headerpad_size, u32),
        error_limit: Storage.FlagOptional(.flags4, .error_limit, u32),
        build_id: Storage.EnumOptional(.flags3, .build_id, .hexstring, String),
        test_runner: Storage.FlagUnion(.flags3, .test_runner, TestRunner),

        emit_directory: Storage.FlagOptional(.flags4, .emit_directory, GeneratedFileIndex),
        generated_docs: Storage.FlagOptional(.flags4, .generated_docs, GeneratedFileIndex),
        generated_asm: Storage.FlagOptional(.flags4, .generated_asm, GeneratedFileIndex),
        generated_bin: Storage.FlagOptional(.flags4, .generated_bin, GeneratedFileIndex),
        generated_pdb: Storage.FlagOptional(.flags4, .generated_pdb, GeneratedFileIndex),
        generated_implib: Storage.FlagOptional(.flags4, .generated_implib, GeneratedFileIndex),
        generated_llvm_bc: Storage.FlagOptional(.flags4, .generated_llvm_bc, GeneratedFileIndex),
        generated_llvm_ir: Storage.FlagOptional(.flags4, .generated_llvm_ir, GeneratedFileIndex),
        generated_h: Storage.FlagOptional(.flags4, .generated_h, GeneratedFileIndex),

        pub const InstalledHeader = union(@This().Tag) {
            file: File,
            directory: Directory,

            pub const Flags = packed struct(u32) {
                tag: InstalledHeader.Tag,
                _: u24 = 0,
            };

            pub const Tag = enum(u8) {
                file,
                directory,
            };

            pub const File = struct {
                flags: @This().Flags = .{},
                source: LazyPath.Index,
                dest_sub_path: String,

                pub const Flags = packed struct(u32) {
                    tag: InstalledHeader.Tag = .file,
                    _: u24 = 0,
                };
            };

            pub const Directory = struct {
                flags: @This().Flags,
                source: LazyPath.Index,
                dest_sub_path: String,
                exclude_extensions: Storage.FlagLengthPrefixedList(.flags, .exclude_extensions, String),
                include_extensions: Storage.FlagLengthPrefixedList(.flags, .include_extensions, String),

                pub const Flags = packed struct(u32) {
                    tag: InstalledHeader.Tag = .directory,
                    exclude_extensions: bool,
                    include_extensions: bool,
                    _: u22 = 0,
                };
            };
        };
        pub const ExpectErrors = union(@This().Tag) {
            pub const Tag = enum(u3) { contains, exact, starts_with, stderr_contains, none };

            contains: String,
            exact: Storage.LengthPrefixedList(String),
            starts_with: String,
            stderr_contains: String,
            none: void,
        };
        pub const TestRunner = union(@This().Tag) {
            pub const Tag = enum(u2) { default, simple, server };

            default: void,
            simple: LazyPath.Index,
            server: LazyPath.Index,
        };
        pub const Entry = enum(u2) { default, disabled, enabled, symbol_name };

        pub const Lto = enum(u2) {
            none,
            full,
            thin,
            default,

            pub fn init(lto: ?std.zig.LtoMode) Lto {
                return switch (lto orelse return .default) {
                    .none => .none,
                    .full => .full,
                    .thin => .thin,
                };
            }
        };

        pub const BuildId = enum(u3) {
            none,
            fast,
            uuid,
            sha1,
            md5,
            hexstring,
            default,

            pub fn init(build_id: ?std.zig.BuildId) BuildId {
                return switch (build_id orelse return .default) {
                    .none => .none,
                    .fast => .fast,
                    .uuid => .uuid,
                    .sha1 => .sha1,
                    .md5 => .md5,
                    .hexstring => .hexstring,
                };
            }

            pub fn unwrap(this: @This(), hexstring: ?String, c: *const Configuration) ?std.zig.BuildId {
                if (hexstring) |h| {
                    assert(this == .hexstring);
                    return .initHexString(h.slice(c));
                }
                return switch (this) {
                    .none => .none,
                    .fast => .fast,
                    .uuid => .uuid,
                    .sha1 => .sha1,
                    .md5 => .md5,
                    .hexstring => unreachable,
                    .default => null,
                };
            }
        };
        pub const WasiExecModel = enum(u2) {
            default,
            command,
            reactor,

            pub fn init(wasi_exec_model: ?std.builtin.WasiExecModel) WasiExecModel {
                return switch (wasi_exec_model orelse return .default) {
                    .command => .command,
                    .reactor => .reactor,
                };
            }
        };
        pub const Linkage = enum(u2) {
            static,
            dynamic,
            default,

            pub fn init(link_mode: ?std.builtin.LinkMode) Linkage {
                return switch (link_mode orelse return .default) {
                    .static => .static,
                    .dynamic => .dynamic,
                };
            }

            pub fn unwrap(this: @This()) ?std.builtin.LinkMode {
                return switch (this) {
                    .static => .static,
                    .dynamic => .dynamic,
                    .default => null,
                };
            }
        };
        pub const Kind = enum(u3) {
            exe,
            lib,
            obj,
            @"test",
            test_obj,

            pub fn isTest(kind: Kind) bool {
                return switch (kind) {
                    .exe, .lib, .obj => false,
                    .@"test", .test_obj => true,
                };
            }

            pub fn toOutputMode(kind: Kind) std.builtin.OutputMode {
                return switch (kind) {
                    .exe, .@"test" => .Exe,
                    .lib => .Lib,
                    .obj, .test_obj => .Obj,
                };
            }
        };
        pub const Subsystem = enum(u4) {
            console,
            windows,
            posix,
            native,
            efi_application,
            efi_boot_service_driver,
            efi_rom,
            efi_runtime_driver,
            default,

            pub fn init(subsystem: ?std.zig.Subsystem) Subsystem {
                return switch (subsystem orelse return .default) {
                    .console => .console,
                    .windows => .windows,
                    .posix => .posix,
                    .native => .native,
                    .efi_application => .efi_application,
                    .efi_boot_service_driver => .efi_boot_service_driver,
                    .efi_rom => .efi_rom,
                    .efi_runtime_driver => .efi_runtime_driver,
                };
            }
        };

        pub const Flags = packed struct(u32) {
            tag: Tag = .compile,

            filters_len: bool,
            installed_headers_len: bool,
            force_undefined_symbols_len: bool,

            verbose_link: bool,
            verbose_cc: bool,
            rdynamic: bool,
            import_memory: bool,
            export_memory: bool,
            import_symbols: bool,
            import_table: bool,
            export_table: bool,
            growable_table: bool,
            shared_memory: bool,
            link_eh_frame_hdr: bool,
            link_emit_relocs: bool,
            link_function_sections: bool,
            link_data_sections: bool,
            linker_dynamicbase: bool,
            link_z_notext: bool,
            link_z_relro: bool,
            link_z_lazy: bool,
            link_z_defs: bool,
            headerpad_max_install_names: bool,
            dead_strip_dylibs: bool,
            force_load_objc: bool,
            discard_local_symbols: bool,
            mingw_unicode_entry_point: bool,
        };

        pub const Flags2 = packed struct(u32) {
            pie: DefaultingBool,
            formatted_panics: DefaultingBool,
            bundle_compiler_rt: DefaultingBool,
            bundle_ubsan_rt: DefaultingBool,
            each_lib_rpath: DefaultingBool,
            link_gc_sections: DefaultingBool,
            linker_allow_shlib_undefined: DefaultingBool,
            linker_allow_undefined_version: DefaultingBool,
            linker_enable_new_dtags: DefaultingBool,
            dll_export_fns: DefaultingBool,
            use_llvm: DefaultingBool,
            use_lld: DefaultingBool,
            use_new_linker: DefaultingBool,
            allow_so_scripts: DefaultingBool,
            sanitize_coverage_trace_pc_guard: DefaultingBool,
            linkage: Linkage,
        };

        pub const Flags3 = packed struct(u32) {
            version: bool,
            initial_memory: bool,
            max_memory: bool,
            kind: Kind,
            compress_debug_sections: std.zig.CompressDebugSections,
            global_base: bool,
            test_runner: TestRunner.Tag,
            wasi_exec_model: WasiExecModel,
            win32_manifest: bool,
            win32_module_definition: bool,
            zig_lib_dir: bool,
            rc_includes: std.zig.RcIncludes,
            image_base: bool,
            build_id: BuildId,
            entry: Entry,
            lto: Lto,
            subsystem: Subsystem,
            _: u2 = 0,
        };

        pub const Flags4 = packed struct(u32) {
            libc_file: bool,
            link_z_common_page_size: bool,
            link_z_max_page_size: bool,
            pagezero_size: bool,
            stack_size: bool,
            headerpad_size: bool,
            error_limit: bool,
            install_name: bool,
            entitlements: bool,
            expect_errors: ExpectErrors.Tag,
            linker_script: bool,
            version_script: bool,
            emit_directory: bool,
            generated_docs: bool,
            generated_asm: bool,
            generated_bin: bool,
            generated_pdb: bool,
            generated_implib: bool,
            generated_llvm_bc: bool,
            generated_llvm_ir: bool,
            generated_h: bool,
            incremental: DefaultingBool,
            _: u7 = 0,
        };

        pub fn isDynamicLibrary(compile: *const Compile) bool {
            return compile.flags3.kind == .lib and compile.flags2.linkage == .dynamic;
        }

        pub fn isStaticLibrary(compile: *const Compile) bool {
            return compile.flags3.kind == .lib and compile.flags2.linkage != .dynamic;
        }

        pub fn producesImplib(compile: *const Compile, c: *const Configuration) bool {
            return isDll(compile, c);
        }

        pub fn isDll(compile: *const Compile, c: *const Configuration) bool {
            return isDynamicLibrary(compile) and rootModuleTarget(compile, c).flags.os_tag == .windows;
        }

        pub fn rootModuleTarget(compile: *const Compile, c: *const Configuration) TargetQuery {
            return compile.root_module.get(c).resolved_target.get(c).?.result.get(c);
        }
    };

    pub const CheckFile = struct {
        flags: @This().Flags,
        file: LazyPath.Index,
        expected_exact: Storage.FlagOptional(.flags, .expected_exact, Bytes),
        expected_matches: Storage.FlagLengthPrefixedList(.flags, .expected_matches, Bytes),
        max_bytes: Storage.FlagOptional(.flags, .max_bytes, u32),

        pub const Flags = packed struct(u32) {
            tag: Tag = .check_file,
            expected_exact: bool,
            expected_matches: bool,
            max_bytes: bool,
            _: u24 = 0,
        };
    };

    pub const ConfigHeader = struct {
        flags: @This().Flags,
        template_file: Storage.FlagOptional(.flags, .template_file, LazyPath.Index),
        generated_dir: GeneratedFileIndex,
        input_size_limit: Storage.FlagOptional(.flags, .input_size_limit, u64),
        include_path: String,
        include_guard: Storage.FlagOptional(.flags, .include_guard, String),
        values: Storage.LengthPrefixedList(Value.Pair),

        pub const Style = enum(u3) {
            autoconf_undef,
            autoconf_at,
            cmake,
            meson,
            blank,
            nasm,

            pub fn init(s: std.Build.Step.ConfigHeader.Style) Style {
                return switch (s) {
                    .autoconf_undef => .autoconf_undef,
                    .autoconf_at => .autoconf_at,
                    .cmake => .cmake,
                    .meson => .meson,
                    .blank => .blank,
                    .nasm => .nasm,
                };
            }
        };

        pub const Value = struct {
            flags: @This().Flags,
            i64: Storage.EnumOptional(.flags, .tag, .i64, i64),
            u64: Storage.EnumOptional(.flags, .tag, .u64, u64),
            ident: Storage.EnumOptional(.flags, .tag, .ident, String),
            string: Storage.EnumOptional(.flags, .tag, .string, String),

            pub const Flags = packed struct(u32) {
                tag: Value.Tag,
                small: u29,
            };

            pub const Tag = enum(u3) {
                ident,
                string,
                small_unsigned,
                small_signed,
                i64,
                u64,
            };

            pub const Pair = extern struct {
                key: String,
                index: Value.Index,
            };

            pub const Index = enum(u32) {
                int_0 = max_u32 - 5,
                int_1 = max_u32 - 4,
                bool_false = max_u32 - 3,
                bool_true = max_u32 - 2,
                undef = max_u32 - 1,
                defined = max_u32,
                _,

                pub fn unpack(this: @This(), c: *const Configuration) Unpacked {
                    return switch (this) {
                        .int_0 => .{ .u64 = 0 },
                        .int_1 => .{ .u64 = 1 },
                        .bool_false => .{ .bool = false },
                        .bool_true => .{ .bool = true },
                        .undef => .undef,
                        .defined => .defined,
                        _ => {
                            const value = extraData(c, Value, @backingInt(this));
                            return switch (value.flags.tag) {
                                .ident => .{ .ident = value.ident.value.?.slice(c) },
                                .string => .{ .string = value.string.value.?.slice(c) },
                                .small_unsigned => .{ .u64 = value.flags.small },
                                .small_signed => .{ .i64 = @as(i29, @bitCast(value.flags.small)) },
                                .i64 => .{ .i64 = value.i64.value.? },
                                .u64 => .{ .u64 = value.u64.value.? },
                            };
                        },
                    };
                }
            };

            pub const Unpacked = union(enum) {
                bool: bool,
                undef,
                defined,
                i64: i64,
                u64: u64,
                ident: []const u8,
                string: []const u8,
            };

            pub fn initSigned(x: i64) @This() {
                return switch (x) {
                    0 => unreachable, // 本应为 Index
                    1 => unreachable, // 本应为 Index
                    2...std.math.maxInt(u29) => .{
                        .flags = .{
                            .tag = .small_unsigned,
                            .small = @intCast(x),
                        },
                        .i64 = .{ .value = null },
                        .u64 = .{ .value = null },
                        .ident = .{ .value = null },
                        .string = .{ .value = null },
                    },
                    std.math.minInt(i29)...-1 => .{
                        .flags = .{
                            .tag = .small_signed,
                            .small = @bitCast(@as(i29, @intCast(x))),
                        },
                        .i64 = .{ .value = null },
                        .u64 = .{ .value = null },
                        .ident = .{ .value = null },
                        .string = .{ .value = null },
                    },
                    else => .{
                        .flags = .{
                            .tag = .i64,
                            .small = 0,
                        },
                        .i64 = .{ .value = x },
                        .u64 = .{ .value = null },
                        .ident = .{ .value = null },
                        .string = .{ .value = null },
                    },
                };
            }
        };

        pub const Flags = packed struct(u32) {
            tag: Tag = .config_header,
            template_file: bool,
            style: Style,
            input_size_limit: bool,
            include_guard: bool,
            _: u21 = 0,
        };
    };

    pub const Fail = struct {
        flags: @This().Flags = .{},
        msg: String,

        pub const Flags = packed struct(u32) {
            tag: Tag = .fail,
            _: u27 = 0,
        };
    };

    pub const Fmt = struct {
        flags: @This().Flags,
        paths: Storage.FlagLengthPrefixedList(.flags, .paths, LazyPath.Index),
        exclude_paths: Storage.FlagLengthPrefixedList(.flags, .exclude_paths, LazyPath.Index),

        pub const Flags = packed struct(u32) {
            tag: Tag = .fmt,
            paths: bool,
            exclude_paths: bool,
            check: bool,
            _: u24 = 0,
        };
    };

    pub const FindProgram = struct {
        flags: @This().Flags = .{},
        names: StringList,
        found_path: GeneratedFileIndex,

        pub const Flags = packed struct(u32) {
            tag: Tag = .find_program,
            _: u27 = 0,
        };
    };

    pub const InstallDir = struct {
        flags: @This().Flags,
        source_dir: LazyPath.Index,
        dest_dir: InstallDestDir,
        dest_sub_path: Storage.FlagOptional(.flags, .dest_sub_path, String),
        exclude_extensions: Storage.FlagLengthPrefixedList(.flags, .exclude_extensions, String),
        include_extensions: Storage.FlagLengthPrefixedList(.flags, .include_extensions, String),
        blank_extensions: Storage.FlagLengthPrefixedList(.flags, .blank_extensions, String),

        pub const Flags = packed struct(u32) {
            tag: Tag = .install_dir,
            dest_sub_path: bool,
            exclude_extensions: bool,
            include_extensions: bool,
            include_extensions_active: bool,
            blank_extensions: bool,
            _: u22 = 0,
        };
    };

    pub const InstallFile = struct {
        flags: @This().Flags = .{},
        source: LazyPath.Index,
        dest_dir: InstallDestDir,
        dest_sub_path: String,

        pub const Flags = packed struct(u32) {
            tag: Tag = .install_file,
            _: u27 = 0,
        };
    };

    pub const ObjCopy = struct {
        flags: @This().Flags,
        input_file: LazyPath.Index,
        output_file: GeneratedFileIndex,
        basename: Storage.FlagOptional(.flags, .basename, String),
        debug_file: Storage.FlagOptional(.flags, .debug_file, GeneratedFileIndex),
        debug_basename: Storage.FlagOptional(.flags, .debug_basename, String),
        only_section: Storage.FlagOptional(.flags, .only_section, String),
        pad_to: Storage.FlagOptional(.flags, .pad_to, u64),
        add_section: Storage.FlagLengthPrefixedList(.flags, .add_section, AddSection),
        update_section: Storage.FlagLengthPrefixedList(.flags, .update_section, UpdateSection),

        pub const Format = enum(u2) {
            binary,
            hex,
            elf,
            default,

            pub fn init(f: ?std.Build.Step.ObjCopy.Format) @This() {
                return switch (f orelse return .default) {
                    .binary => .binary,
                    .hex => .hex,
                    .elf => .elf,
                };
            }
        };

        pub const Strip = enum(u2) {
            none,
            debug,
            debug_and_symbols,
        };

        pub const AddSection = extern struct {
            section_name: String,
            file_path: LazyPath.Index,
        };

        pub const UpdateSection = extern struct {
            section_name: String,
            flags: @This().Flags,

            pub const Flags = packed struct(u32) {
                section_flags: SectionFlags,
                alignment: Alignment,
                _: u17 = 0,
            };
        };

        pub const SectionFlags = packed struct(u9) {
            /// 添加 SHF_ALLOC
            alloc: bool = false,
            /// 若节类型为 SHT_NOBITS,则改为 SHT_PROGBITS,否则不执行操作
            contents: bool = false,
            /// 若节类型为 SHT_NOBITS,则设为 SHT_PROGBITS;否则不进行操作(与 contents 相同)。
            load: bool = false,
            /// 只读:清除默认 SHF_WRITE 标志
            readonly: bool = false,
            /// 添加 SHF_EXECINSTR
            code: bool = false,
            /// 添加 SHF_EXCLUDE
            exclude: bool = false,
            /// 添加 SHF_X86_64_LARGE。如果目标不是 x86_64,则为致命错误
            large: bool = false,
            /// 添加 SHF_MERGE
            merge: bool = false,
            /// 添加 SHF_STRINGS
            strings: bool = false,

            pub const default: @This() = .{};
        };

        pub const Flags = packed struct(u32) {
            tag: Tag = .obj_copy,
            basename: bool,
            debug_file: bool,
            debug_basename: bool,
            format: Format,
            strip: Strip,
            compress_debug: bool,
            only_section: bool,
            pad_to: bool,
            add_section: bool,
            update_section: bool,
            _: u15 = 0,
        };
    };

    pub const Options = struct {
        flags: @This().Flags,
        generated_file: GeneratedFileIndex,
        contents: Bytes,
        files: Storage.FlagLengthPrefixedList(.flags, .files, NamedPath),
        directories: Storage.FlagLengthPrefixedList(.flags, .directories, NamedPath),
        untracked_paths: Storage.FlagLengthPrefixedList(.flags, .untracked_paths, NamedPath),

        pub const NamedPath = extern struct {
            name: String,
            path: LazyPath.Index,
        };

        pub const Flags = packed struct(u32) {
            tag: Tag = .options,
            files: bool,
            directories: bool,
            untracked_paths: bool,
            _: u24 = 0,
        };
    };

    pub const TranslateC = struct {
        flags: @This().Flags,
        src_path: LazyPath.Index,
        output_file: GeneratedFileIndex,
        include_dirs: Storage.UnionList(.flags, .include_dirs, Module.IncludeDir),
        system_libs: Storage.FlagLengthPrefixedList(.flags, .system_libs, SystemLib.Index),
        cc_argv: Storage.FlagLengthPrefixedList(.flags, .cc_argv, String),
        target: ResolvedTarget.OptionalIndex,

        pub const Flags = packed struct(u32) {
            tag: Tag = .translate_c,
            include_dirs: bool,
            system_libs: bool,
            cc_argv: bool,
            link_libc: bool,
            optimize: Module.Optimize,
            _: u20 = 0,
        };
    };

    pub const UpdateSourceFiles = struct {
        flags: @This().Flags,
        embeds: Storage.FlagLengthPrefixedList(.flags, .embeds, Embed),
        copies: Storage.FlagLengthPrefixedList(.flags, .copies, Copy),

        pub const Embed = WriteFile.Embed;
        pub const Copy = WriteFile.Copy;

        pub const Flags = packed struct(u32) {
            tag: Tag = .update_source_files,
            embeds: bool,
            copies: bool,
            _: u25 = 0,
        };
    };

    pub const WriteFile = struct {
        flags: @This().Flags,
        generated_directory: GeneratedFileIndex,
        embeds: Storage.FlagLengthPrefixedList(.flags, .embeds, Embed),
        copies: Storage.FlagLengthPrefixedList(.flags, .copies, Copy),
        directories: Storage.FlagLengthPrefixedList(.flags, .directories, Directory),
        mutate_path: Storage.EnumOptional(.flags, .mode, .mutate, LazyPath.Index),

        pub const Embed = extern struct {
            sub_path: String,
            contents: Bytes,
        };

        pub const Copy = extern struct {
            sub_path: String,
            src_file: LazyPath.Index,
        };

        pub const Directory = extern struct {
            sub_path: String,
            src_path: LazyPath.Index,
            exclude_extensions: OptionalStringList,
            include_extensions: OptionalStringList,
        };

        pub const Mode = enum(u2) {
            whole_cached,
            tmp,
            mutate,
        };

        pub const Flags = packed struct(u32) {
            tag: Tag = .write_file,
            embeds: bool,
            copies: bool,
            directories: bool,
            mode: Mode,
            _: u22 = 0,
        };
    };

    pub fn flags(s: *const Step, c: *const Configuration) Flags {
        return @bitCast(c.extra[@backingInt(s.extended)]);
    }
};

pub const MaxRss = enum(u32) {
    none = 0,
    _,

    pub fn toBytes(mr: MaxRss) u64 {
        const x: usize = @backingInt(mr);
        return x << 8;
    }

    pub fn fromBytes(bytes: u64) MaxRss {
        return @fromBackingInt(@intCast(bytes >> 8));
    }
};

pub const LazyPath = union(@This().Tag) {
    source_path: SourcePath,
    relative: Relative,
    generated: Generated,

    pub const Tag = enum(u8) {
        /// 相对于构建根目录的源文件路径。
        source_path,
        /// 相对于 flags 指示的目录。
        relative,
        /// 仅在所属步骤填充路径后,该路径才可用。
        generated,
    };

    pub const Flags = packed struct(u32) {
        tag: Tag,
        _: u24 = 0,
    };

    /// `extra` 的索引。
    pub const Index = IndexType(@This());

    /// `extra` 中的索引,或 `null`。
    pub const OptionalIndex = enum(u32) {
        none = max_u32,
        _,

        pub fn unwrap(this: @This()) ?Index {
            return switch (this) {
                .none => null,
                else => @fromBackingInt(@intCast(@backingInt(this))),
            };
        }
    };

    pub const SourcePath = struct {
        flags: @This().Flags = .{},
        owner: Package.Index,
        sub_path: String,

        pub const Flags = packed struct(u32) {
            tag: Tag = .source_path,
            _: u24 = 0,
        };
    };

    pub const Generated = struct {
        flags: @This().Flags = .{},
        index: GeneratedFileIndex,
        /// 在 `up` 之后应用。
        sub_path: String = .empty,

        pub const Flags = packed struct(u32) {
            tag: Tag = .generated,
            /// 向上遍历父目录的数量。
            /// 0 表示生成文件自身。
            /// 1 表示生成文件所在目录。
            /// 2 表示该目录的父目录,依此类推。
            up: u24 = 0,
        };
    };

    pub const Relative = struct {
        flags: @This().Flags,
        sub_path: String,

        pub const Flags = packed struct(u32) {
            tag: Tag = .relative,
            base: Base,
            _: u16 = 0,
        };

        pub const Base = enum(u8) {
            cwd,
            local_cache,
            global_cache,
            /// 缺少程序包索引,因此不得与 Relative 配合使用。
            build_root,
            zig_exe,
            zig_lib,
            install_prefix,
            install_lib,
            install_bin,
            install_include,
            libc_runtimes,
        };
    };
};

pub const GeneratedFileIndex = enum(u32) {
    _,
};

pub const OptionalGeneratedFileIndex = enum(u32) {
    none = max_u32,
    _,

    pub fn init(i: ?GeneratedFileIndex) OptionalGeneratedFileIndex {
        return @fromBackingInt(@intCast(@backingInt(i orelse return .none)));
    }

    pub fn unwrap(this: @This()) ?GeneratedFileIndex {
        return switch (this) {
            .none => null,
            else => @fromBackingInt(@intCast(@backingInt(this))),
        };
    }
};

pub const Package = struct {
    dep_prefix: String,
    hash: String,
    root_path: String,

    pub const Index = enum(u32) {
        root = max_u32,
        _,

        /// 根包返回 `null`。
        pub fn get(i: @This(), c: *const Configuration) ?Package {
            if (i == .root) return null;
            return extraData(c, Package, @backingInt(i));
        }

        pub fn depPrefixSlice(i: @This(), c: *const Configuration) [:0]const u8 {
            const package = get(i, c) orelse return "";
            return package.dep_prefix.slice(c);
        }
    };

    pub const OptionalIndex = enum(u32) {
        none = max_u32 - 1,
        root = max_u32,
        _,

        pub fn init(i: Index) OptionalIndex {
            const result: OptionalIndex = @fromBackingInt(@intCast(@backingInt(i)));
            assert(result != .none);
            return result;
        }

        pub fn unwrap(this: @This()) ?Index {
            return switch (this) {
                .none => null,
                .root => .root,
                _ => @fromBackingInt(@intCast(@backingInt(this))),
            };
        }
    };
};

pub const Module = struct {
    flags: Flags,
    flags2: Flags2,
    import_table: ImportTable.Index,
    owner: Package.Index,
    root_source_file: LazyPath.OptionalIndex,
    resolved_target: ResolvedTarget.OptionalIndex,
    c_macros: Storage.FlagLengthPrefixedList(.flags, .c_macros, String),
    lib_paths: Storage.FlagLengthPrefixedList(.flags, .lib_paths, LazyPath.Index),
    export_symbol_names: Storage.FlagLengthPrefixedList(.flags, .export_symbol_names, String),
    include_dirs: Storage.UnionList(.flags, .include_dirs, IncludeDir),
    rpaths: Storage.UnionList(.flags, .rpaths, RPath),
    link_objects: Storage.UnionList(.flags, .link_objects, LinkObject),
    frameworks: Storage.FlagLengthPrefixedList(.flags, .frameworks, Framework),
    patchable_function_entry: u32,

    pub const Optimize = enum(u3) {
        debug,
        safe,
        fast,
        small,
        default,

        pub fn init(o: ?std.builtin.Optimize) Optimize {
            return switch (o orelse return .default) {
                .debug => .debug,
                .safe => .safe,
                .fast => .fast,
                .small => .small,
            };
        }
    };

    pub const UnwindTables = enum(u2) {
        none,
        sync,
        async,
        default,

        pub fn init(ut: ?std.builtin.UnwindTables) UnwindTables {
            return switch (ut orelse return .default) {
                .none => .none,
                .sync => .sync,
                .async => .async,
            };
        }
    };

    pub const SanitizeC = enum(u2) {
        off,
        trap,
        full,
        default,

        pub fn init(sc: ?std.zig.SanitizeC) SanitizeC {
            return switch (sc orelse return .default) {
                .off => .off,
                .trap => .trap,
                .full => .full,
            };
        }
    };

    pub const DwarfFormat = enum(u2) {
        @"32",
        @"64",
        default,

        pub fn init(df: ?std.dwarf.Format) DwarfFormat {
            return switch (df orelse return .default) {
                .@"32" => .@"32",
                .@"64" => .@"64",
            };
        }
    };

    pub const Flags = packed struct(u32) {
        optimize: Optimize,
        strip: DefaultingBool,
        unwind_tables: UnwindTables,
        dwarf_format: DwarfFormat,
        single_threaded: DefaultingBool,
        stack_protector: DefaultingBool,
        stack_check: DefaultingBool,
        sanitize_c: SanitizeC,
        sanitize_thread: DefaultingBool,
        fuzz: DefaultingBool,
        code_model: std.builtin.CodeModel,
        c_macros: bool,
        include_dirs: bool,
        lib_paths: bool,
        rpaths: bool,
        frameworks: bool,
        link_objects: bool,
        export_symbol_names: bool,
    };

    pub const Flags2 = packed struct(u32) {
        valgrind: DefaultingBool,
        pic: DefaultingBool,
        red_zone: DefaultingBool,
        omit_frame_pointer: DefaultingBool,
        error_tracing: DefaultingBool,
        link_libc: DefaultingBool,
        link_libcpp: DefaultingBool,
        no_builtin: DefaultingBool,
        _: u16 = 0,
    };

    pub const IncludeDir = union(enum(u3)) {
        path: LazyPath.Index,
        path_system: LazyPath.Index,
        path_after: LazyPath.Index,
        framework_path: LazyPath.Index,
        framework_path_system: LazyPath.Index,
        /// 始终为 `Step.Tag.config_header`。
        config_header_step: Step.Index,
        embed_path: LazyPath.Index,
    };

    pub const RPath = union(enum(u1)) {
        lazy_path: LazyPath.Index,
        special: String,
    };

    pub const LinkObject = union(enum(u3)) {
        static_path: LazyPath.Index,
        /// 始终为 `Step.Tag.compile`。
        other_step: Step.Index,
        system_lib: SystemLib.Index,
        assembly_file: LazyPath.Index,
        c_source_file: CSourceFile.Index,
        c_source_files: CSourceFiles.Index,
        win32_resource_file: RcSourceFile.Index,
    };

    pub const Framework = extern struct {
        flags: @This().Flags,
        name: String,

        pub const Flags = packed struct(u32) {
            needed: bool,
            weak: bool,
            _: u30 = 0,
        };
    };

    pub const Index = IndexType(@This());
};

pub const ImportTable = struct {
    imports: Storage.MultiList(Import),

    pub const Import = struct {
        name: String,
        module: Module.Index,
    };

    /// 指向 `extra` 内部。
    pub const Index = enum(u32) {
        invalid = max_u32,
        _,

        pub fn get(this: @This(), c: *const Configuration) ImportTable {
            return switch (this) {
                .invalid => unreachable,
                _ => extraData(c, ImportTable, @backingInt(this)),
            };
        }
    };
};

pub const Deps = struct {
    steps: Storage.LengthPrefixedList(Step.Index),

    pub const Index = enum(u32) {
        _,

        pub fn get(this: @This(), c: *const Configuration) Deps {
            return extraData(c, Deps, @backingInt(this));
        }

        pub fn slice(this: @This(), c: *const Configuration) []const Step.Index {
            return get(this, c).steps.slice;
        }
    };
};

pub const EnvironMap = struct {
    keys: StringList,
    values: StringList,

    pub const Index = IndexType(@This());
};

/// 指向 `extra`,第一个元素是字符串数量,后续
/// 元素是相应数量的 `String`。
///
/// 存储方式与 `Deps` 完全相同。
pub const StringList = enum(u32) {
    _,

    pub fn slice(this: @This(), c: *const Configuration) []const String {
        const len = c.extra[@backingInt(this)];
        return @ptrCast(c.extra[@backingInt(this) + 1 ..][0..len]);
    }
};

pub const OptionalStringList = enum(u32) {
    none = max_u32,
    _,

    pub fn init(opt_string_list: ?StringList) OptionalStringList {
        const sl = opt_string_list orelse return .none;
        const result: OptionalStringList = @fromBackingInt(@intCast(@backingInt(sl)));
        assert(result != .none);
        return result;
    }

    pub fn unwrap(this: @This()) ?StringList {
        if (this == .none) return null;
        return @fromBackingInt(@intCast(@backingInt(this)));
    }

    pub fn slice(this: @This(), c: *const Configuration) ?[]const String {
        return (unwrap(this) orelse return null).slice(c);
    }
};

pub const PathDep = extern struct {
    flags: Flags,
    sub: String,
    pkg: Package.OptionalIndex,

    pub const Flags = packed struct(u32) {
        is_directory: bool,
        metadata_only: bool,
        base: LazyPath.Relative.Base,
        _: u22 = 0,
    };
};

pub const InstallDestDir = enum(u32) {
    none = max_u32 - 4,
    prefix = max_u32 - 3,
    lib = max_u32 - 2,
    bin = max_u32 - 1,
    header = max_u32,
    /// 相对于前缀的 `String` 路径。
    _,

    pub fn initCustom(sub_path: String) InstallDestDir {
        assert(@backingInt(sub_path) < @backingInt(InstallDestDir.none));
        return @fromBackingInt(@intCast(@backingInt(sub_path)));
    }

    pub const Unpacked = union(enum) {
        prefix,
        lib,
        bin,
        header,
        sub_path: String,
    };

    pub fn unpack(this: @This()) ?Unpacked {
        return switch (this) {
            .none => null,
            .prefix => .prefix,
            .lib => .lib,
            .bin => .bin,
            .header => .header,
            _ => .{ .sub_path = @fromBackingInt(@intCast(@backingInt(this))) },
        };
    }
};

/// 指向 `string_bytes` 内部,以空字符终止。
pub const OptionalString = enum(u32) {
    empty = 0,
    /// 字符串 "root"。
    root = 1,
    none = max_u32,
    _,

    pub fn init(s: String) OptionalString {
        const result: OptionalString = @fromBackingInt(@intCast(@backingInt(s)));
        assert(result != .none);
        return result;
    }

    pub fn unwrap(this: @This()) ?String {
        if (this == .none) return null;
        return @fromBackingInt(@intCast(@backingInt(this)));
    }

    pub fn slice(this: @This(), c: *const Configuration) ?[:0]const u8 {
        return (unwrap(this) orelse return null).slice(c);
    }
};

/// 指向 `string_bytes` 内部,以空字符终止。
pub const String = enum(u32) {
    empty = 0,
    /// 字符串 "root"。
    root = 1,
    _,

    pub fn slice(index: String, c: *const Configuration) [:0]const u8 {
        const start_slice = c.string_bytes[@backingInt(index)..];
        return start_slice[0..std.mem.findScalar(u8, start_slice, 0).? :0];
    }
};

/// 可能包含空字节的任意字节序列。
pub const Bytes = extern struct {
    /// 指向 `string_bytes` 内部。
    index: u32,
    len: u32,

    pub fn slice(bytes: Bytes, c: *const Configuration) []const u8 {
        return c.string_bytes[bytes.index..][0..bytes.len];
    }
};

/// 以 2 的幂形式存储,另用一个特殊值表示无。
pub const Alignment = enum(u6) {
    @"1" = 0,
    @"2" = 1,
    @"4" = 2,
    @"8" = 3,
    @"16" = 4,
    @"32" = 5,
    @"64" = 6,
    none = std.math.maxInt(u6),
    _,

    pub fn init(optional_alignment: ?std.mem.Alignment) @This() {
        const a = optional_alignment orelse return .none;
        return @fromBackingInt(@intCast(@backingInt(a)));
    }

    pub fn toBytes(a: @This()) ?u64 {
        return switch (a) {
            .none => null,
            else => @as(u64, 1) << @backingInt(a),
        };
    }
};

pub const DefaultingBool = enum(u2) {
    false,
    true,
    default,

    pub fn init(b: ?bool) DefaultingBool {
        return switch (b orelse return .default) {
            false => .false,
            true => .true,
        };
    }

    pub fn toBool(db: DefaultingBool) ?bool {
        return switch (db) {
            .false => false,
            .true => true,
            .default => null,
        };
    }
};

pub const SystemLib = struct {
    name: String,
    flags: Flags,

    pub const Index = IndexType(@This());

    pub const UsePkgConfig = enum(u2) {
        /// 不使用 pkg-config,仅传入 -lfoo,其中 foo 为名称。
        no,
        /// 尝试从 pkg-config 获取库链接信息。
        /// 若失败,则退回传递 -lfoo,其中 foo 为 name。
        yes,
        /// 尝试从 pkg-config 获取库链接方式的信息。
        /// 失败则返回错误。
        force,
    };

    pub const LinkMode = std.builtin.LinkMode;

    pub const Flags = packed struct(u32) {
        needed: bool,
        weak: bool,
        use_pkg_config: UsePkgConfig,
        preferred_link_mode: LinkMode,
        search_strategy: SearchStrategy,
        _: u25 = 0,
    };

    pub const SearchStrategy = enum(u2) { paths_first, mode_first, no_fallback };
};

pub const CSourceFiles = struct {
    flags: Flags,
    root: LazyPath.Index,
    args: Storage.FlagList(.flags, .args_len, String),
    sub_paths: Storage.LengthPrefixedList(String),

    pub const Index = IndexType(@This());

    pub const Flags = packed struct(u32) {
        /// C 编译器命令行标志。
        args_len: u29,
        lang: OptionalCSourceLanguage,
    };
};

pub const CSourceFile = struct {
    flags: Flags,
    file: LazyPath.Index,
    args: Storage.FlagList(.flags, .args_len, String),

    pub const Index = IndexType(@This());

    pub const Flags = packed struct(u32) {
        /// C 编译器命令行标志。
        args_len: u29,
        lang: OptionalCSourceLanguage,
    };
};

pub const RcSourceFile = struct {
    flags: Flags,
    file: LazyPath.Index,
    args: Storage.FlagList(.flags, .args_len, String),
    include_paths: Storage.FlagLengthPrefixedList(.flags, .include_paths, LazyPath.Index),

    pub const Index = IndexType(@This());

    pub const Flags = packed struct(u32) {
        /// C 编译器命令行标志。
        args_len: u31,
        include_paths: bool,
    };
};

pub const OptionalCSourceLanguage = enum(u3) {
    c,
    cpp,
    objective_c,
    objective_cpp,
    assembly,
    assembly_with_preprocessor,

    default,

    pub fn init(x: ?std.Build.Module.CSourceLanguage) @This() {
        return switch (x orelse return .default) {
            inline else => |tag| @field(@This(), @tagName(tag)),
        };
    }

    pub fn get(this: @This()) ?std.Build.Module.CSourceLanguage {
        return switch (this) {
            inline else => |tag| @field(std.Build.Module.CSourceLanguage, @tagName(tag)),
            .default => null,
        };
    }
};

pub const ResolvedTarget = struct {
    /// none 表示宿主机。
    query: TargetQuery.OptionalIndex,
    /// 将解析默认值。
    result: TargetQuery.Index,

    pub const Index = IndexType(@This());

    pub const OptionalIndex = enum(u32) {
        none = max_u32,
        _,

        pub fn init(i: Index) OptionalIndex {
            const result: OptionalIndex = @fromBackingInt(@intCast(@backingInt(i)));
            assert(result != .none);
            return result;
        }

        pub fn unwrap(this: @This()) ?Index {
            return switch (this) {
                .none => null,
                _ => @fromBackingInt(@intCast(@backingInt(this))),
            };
        }

        pub fn get(this: @This(), c: *const Configuration) ?ResolvedTarget {
            return (unwrap(this) orelse return null).get(c);
        }
    };

    pub fn unwrapQuery(rt: *const ResolvedTarget, c: *const Configuration) ?std.Target.Query {
        const tq = rt.query.get(c) orelse return null;
        const cpu_arch = tq.flags.cpu_arch.unwrap() orelse rt.result.get(c).flags.cpu_arch.unwrap().?;
        return .{
            .cpu_arch = cpu_arch,
            .cpu_model = switch (tq.flags.cpu_model) {
                .native => .native,
                .baseline => .baseline,
                .determined_by_arch_os => .determined_by_arch_os,
                .explicit => .{ .explicit = cpu_arch.parseCpuModel(tq.cpu_name.value.?.slice(c)).? },
            },
            .cpu_features_add = tq.cpu_features_add.value orelse .empty,
            .cpu_features_sub = tq.cpu_features_sub.value orelse .empty,
            .os_tag = tq.flags.os_tag.unwrap(),
            .os_version_min = tq.os_version_min.u.unwrap(c),
            .os_version_max = tq.os_version_max.u.unwrap(c),
            .glibc_version = if (tq.glibc_version.value) |s|
                std.SemanticVersion.parse(s.slice(c)) catch unreachable
            else
                null,
            .android_api_level = tq.android_api_level.value,
            .abi = tq.flags.abi.unwrap(),
            .dynamic_linker = if (tq.dynamic_linker.value) |s| .init(s.slice(c)) else null,
            .ofmt = tq.flags.object_format.unwrap(),
        };
    }
};

pub const TargetQuery = struct {
    flags: Flags,

    cpu_features_add: Storage.FlagOptional(.flags, .cpu_features_add, std.Target.Cpu.Feature.Set),
    cpu_features_sub: Storage.FlagOptional(.flags, .cpu_features_sub, std.Target.Cpu.Feature.Set),
    cpu_name: Storage.EnumOptional(.flags, .cpu_model, .explicit, String),
    os_version_min: Storage.FlagUnion(.flags, .os_version_min, OsVersion),
    os_version_max: Storage.FlagUnion(.flags, .os_version_max, OsVersion),
    glibc_version: Storage.FlagOptional(.flags, .glibc_version, String),
    android_api_level: Storage.FlagOptional(.flags, .android_api_level, u32),
    dynamic_linker: Storage.FlagOptional(.flags, .dynamic_linker, String),

    pub const Index = enum(u32) {
        _,

        pub fn extraSlice(i: Index, extra: []const u32) []const u32 {
            return extra[@backingInt(i)..][0..length(i, extra)];
        }

        pub fn length(i: Index, extra: []const u32) usize {
            return Storage.dataLength(extra, @backingInt(i), TargetQuery);
        }

        pub fn get(this: @This(), c: *const Configuration) TargetQuery {
            return extraData(c, TargetQuery, @backingInt(this));
        }
    };

    pub const OptionalIndex = enum(u32) {
        none = max_u32,
        _,

        pub fn init(i: Index) OptionalIndex {
            const result: OptionalIndex = @fromBackingInt(@intCast(@backingInt(i)));
            assert(result != .none);
            return result;
        }

        pub fn unwrap(this: @This()) ?Index {
            return switch (this) {
                .none => null,
                _ => @fromBackingInt(@intCast(@backingInt(this))),
            };
        }

        pub fn get(this: @This(), c: *const Configuration) ?TargetQuery {
            return (this.unwrap() orelse return null).get(c);
        }
    };

    pub const CpuModel = enum(u2) {
        native,
        baseline,
        determined_by_arch_os,
        explicit,

        pub fn init(x: std.Target.Query.CpuModel) @This() {
            return switch (x) {
                inline else => |_, tag| @field(@This(), @tagName(tag)),
            };
        }
    };
    pub const OsVersion = union(@This().Tag) {
        pub const Tag = enum(u2) { none, semver, windows, default };

        none: void,
        semver: String,
        windows: std.Target.Os.WindowsVersion,
        default: void,

        pub fn unwrap(this: @This(), c: *const Configuration) ?std.Target.Query.OsVersion {
            return switch (this) {
                .none => .none,
                .semver => |sv| .{ .semver = std.SemanticVersion.parse(sv.slice(c)) catch unreachable },
                .windows => |wv| .{ .windows = wv },
                .default => null,
            };
        }
    };

    pub const Abi = enum(u5) {
        none,
        gnu,
        gnuabin32,
        gnuabi64,
        gnueabi,
        gnueabihf,
        gnuf32,
        gnusf,
        gnux32,
        eabi,
        eabihf,
        abin32,
        x32,
        ilp32,
        android,
        androideabi,
        musl,
        muslabin32,
        muslabi64,
        musleabi,
        musleabihf,
        muslf32,
        muslsf,
        muslx32,
        msvc,
        itanium,
        simulator,
        ohos,
        ohoseabi,
        call0,

        default,

        pub fn init(x: ?std.Target.Abi) @This() {
            return switch (x orelse return .default) {
                inline else => |tag| @field(@This(), @tagName(tag)),
            };
        }

        pub fn unwrap(this: @This()) ?std.Target.Abi {
            return switch (this) {
                inline else => |tag| @field(std.Target.Abi, @tagName(tag)),
                .default => null,
            };
        }
    };

    pub const CpuArch = enum(u6) {
        aarch64,
        aarch64_be,
        alpha,
        amdgcn,
        arc,
        arceb,
        arm,
        armeb,
        avr,
        bpfeb,
        bpfel,
        csky,
        ez80,
        hexagon,
        hppa,
        hppa64,
        kalimba,
        kvx,
        lanai,
        loongarch32,
        loongarch64,
        m68k,
        m88k,
        microblaze,
        microblazeel,
        mips,
        mipsel,
        mips64,
        mips64el,
        msp430,
        nvptx,
        nvptx64,
        or1k,
        powerpc,
        powerpcle,
        powerpc64,
        powerpc64le,
        propeller,
        riscv32,
        riscv32be,
        riscv64,
        riscv64be,
        s390x,
        sh,
        sheb,
        sparc,
        sparc64,
        spork8,
        spirv32,
        spirv64,
        thumb,
        thumbeb,
        ve,
        wasm32,
        wasm64,
        x86_16,
        x86,
        x86_64,
        xcore,
        xtensa,
        xtensaeb,

        default,

        pub fn init(x: ?std.Target.Cpu.Arch) @This() {
            return switch (x orelse return .default) {
                inline else => |tag| @field(@This(), @tagName(tag)),
            };
        }

        pub fn unwrap(this: @This()) ?std.Target.Cpu.Arch {
            return switch (this) {
                inline else => |tag| @field(std.Target.Cpu.Arch, @tagName(tag)),
                .default => null,
            };
        }
    };

    pub const OsTag = enum(u6) {
        freestanding,
        other,
        contiki,
        fuchsia,
        hermit,
        managarm,
        haiku,
        hurd,
        illumos,
        linux,
        plan9,
        rtems,
        serenity,
        dragonfly,
        freebsd,
        netbsd,
        openbsd,
        driverkit,
        ios,
        maccatalyst,
        macos,
        tvos,
        visionos,
        watchos,
        windows,
        uefi,
        @"3ds",
        wiiu,
        @"switch",
        gba,
        psx,
        ps3,
        ps4,
        ps5,
        psp,
        vita,
        emscripten,
        wasi,
        amdhsa,
        amdpal,
        cuda,
        mesa3d,
        nvcl,
        opencl,
        opengl,
        vulkan,
        tios,
        ashetos,

        default,

        pub fn init(x: ?std.Target.Os.Tag) @This() {
            return switch (x orelse return .default) {
                inline else => |tag| @field(@This(), @tagName(tag)),
            };
        }

        pub fn unwrap(this: @This()) ?std.Target.Os.Tag {
            return switch (this) {
                inline else => |tag| @field(std.Target.Os.Tag, @tagName(tag)),
                .default => null,
            };
        }
    };

    pub const ObjectFormat = enum(u4) {
        c,
        coff,
        elf,
        hex,
        macho,
        plan9,
        raw,
        spirv,
        wasm,

        default,

        pub fn init(x: ?std.Target.ObjectFormat) @This() {
            return switch (x orelse return .default) {
                inline else => |tag| @field(@This(), @tagName(tag)),
            };
        }

        pub fn unwrap(this: @This()) ?std.Target.ObjectFormat {
            return switch (this) {
                inline else => |tag| @field(std.Target.ObjectFormat, @tagName(tag)),
                .default => null,
            };
        }
    };

    pub const Flags = packed struct(u32) {
        cpu_arch: CpuArch,
        cpu_model: CpuModel,
        cpu_features_add: bool,
        cpu_features_sub: bool,
        os_tag: OsTag,
        abi: Abi,
        object_format: ObjectFormat,
        os_version_min: OsVersion.Tag,
        os_version_max: OsVersion.Tag,
        glibc_version: bool,
        android_api_level: bool,
        dynamic_linker: bool,
    };

    pub fn unwrapTarget(tq: *const TargetQuery, c: *const Configuration) std.Target {
        const cpu_arch = tq.flags.cpu_arch.unwrap().?;
        const os_tag = tq.flags.os_tag.unwrap().?;
        return .{
            .cpu = .{
                .arch = cpu_arch,
                .model = cpu_arch.parseCpuModel(tq.cpu_name.value.?.slice(c)).?,
                .features = tq.cpu_features_add.value.?,
            },
            .os = .{
                .tag = os_tag,
                .version_range = switch (os_tag) {
                    .linux => .{ .linux = .{
                        .range = .{
                            .min = tq.os_version_min.u.unwrap(c).?.semver,
                            .max = tq.os_version_max.u.unwrap(c).?.semver,
                        },
                        .glibc = std.SemanticVersion.parse(tq.glibc_version.value.?.slice(c)) catch unreachable,
                        .android = tq.android_api_level.value.?,
                    } },
                    .hurd => .{ .hurd = .{
                        .range = .{
                            .min = tq.os_version_min.u.unwrap(c).?.semver,
                            .max = tq.os_version_max.u.unwrap(c).?.semver,
                        },
                        .glibc = std.SemanticVersion.parse(tq.glibc_version.value.?.slice(c)) catch unreachable,
                    } },
                    .windows => .{ .windows = .{
                        .min = tq.os_version_min.u.unwrap(c).?.windows,
                        .max = tq.os_version_max.u.unwrap(c).?.windows,
                    } },
                    else => switch (tq.os_version_min.u.unwrap(c).?) {
                        .none => .{ .none = {} },
                        .semver => |min| .{ .semver = .{
                            .min = min,
                            .max = tq.os_version_max.u.unwrap(c).?.semver,
                        } },
                        .windows => unreachable,
                    },
                },
            },
            .abi = tq.flags.abi.unwrap().?,
            .ofmt = tq.flags.object_format.unwrap().?,
            .dynamic_linker = .init(if (tq.dynamic_linker.value) |s| s.slice(c) else null),
        };
    }
};

pub const Storage = enum {
    flag_optional,
    enum_optional,
    extended,
    length_prefixed_list,
    flag_length_prefixed_list,
    union_list,
    flag_union,
    multi_list,
    flag_list,

    /// 字段是否存在由紧凑结构体中的
    /// 一个布尔值决定。
    pub fn FlagOptional(
        comptime flags_arg: @EnumLiteral(),
        comptime flag_arg: @EnumLiteral(),
        comptime ValueArg: type,
    ) type {
        return struct {
            value: ?Value,

            pub const storage: Storage = .flag_optional;
            pub const flags = flags_arg;
            pub const flag = flag_arg;
            pub const Value = ValueArg;
        };
    }

    /// 字段类型由紧凑结构体中的枚举决定。
    pub fn FlagUnion(
        comptime flags_arg: @EnumLiteral(),
        comptime flag_arg: @EnumLiteral(),
        comptime UnionArg: type,
    ) type {
        return struct {
            u: Union,

            pub const storage: Storage = .flag_union;
            pub const flags = flags_arg;
            pub const flag = flag_arg;
            pub const Union = UnionArg;

            pub const Tag = @typeInfo(Union).@"union".tag_type.?;
        };
    }

    /// 当 flags 中的枚举标签与特定值匹配时,此字段存在。
    pub fn EnumOptional(
        comptime flags_arg: @EnumLiteral(),
        comptime flag_arg: @EnumLiteral(),
        comptime tag_arg: @EnumLiteral(),
        comptime ValueArg: type,
    ) type {
        return struct {
            value: ?Value,

            pub const storage: Storage = .enum_optional;
            pub const flags = flags_arg;
            pub const flag = flag_arg;
            pub const tag = tag_arg;
            pub const Value = ValueArg;
        };
    }

    /// 该字段是辅助缓冲区中的索引,其首元素
    /// 是包含标签的打包结构体。
    pub fn Extended(comptime BaseFlags: type, comptime U: type) type {
        return enum(u32) {
            _,

            pub const storage: Storage = .extended;

            pub fn tag(this: @This(), c: *const Configuration) @FieldType(BaseFlags, "tag") {
                const base_flags: BaseFlags = @bitCast(c.extra[@backingInt(this)]);
                return base_flags.tag;
            }

            pub fn cast(this: @This(), c: *const Configuration, comptime S: type) ?S {
                const wanted_tag = blk: {
                    const info = @typeInfo(S.Flags).@"struct";
                    break :blk info.field_attrs[0].defaultValue(info.field_types[0]).?;
                };
                const base_flags: BaseFlags = @bitCast(c.extra[@backingInt(this)]);
                if (base_flags.tag != wanted_tag) return null;
                var i: usize = @backingInt(this);
                return data(c.extra, &i, S);
            }

            pub fn get(this: @This(), buffer: []const u32) U {
                var i: usize = @backingInt(this);
                const base_flags: BaseFlags = @bitCast(buffer[i]);
                return switch (base_flags.tag) {
                    inline else => |t| @unionInit(U, @tagName(t), data(buffer, &i, @FieldType(U, @tagName(t)))),
                };
            }
        };
    }

    /// flags 中的一个字段决定长度为零还是非零。
    /// 若长度非零,则先有一个长度字段,其后跟随列表。
    /// 元素必须具有明确定义的内存布局,除此之外,其大小可以是任意 u32 大小的整数倍。
    /// 长度表示元素数量,而非 u32 的数量。
    ///
    pub fn FlagLengthPrefixedList(
        comptime flags_arg: @EnumLiteral(),
        comptime flag_arg: @EnumLiteral(),
        comptime ElemArg: type,
    ) type {
        return struct {
            slice: []const Elem,

            pub const storage: Storage = .flag_length_prefixed_list;
            pub const flags = flags_arg;
            pub const flag = flag_arg;
            pub const Elem = ElemArg;

            pub fn initErased(s: []const u32) @This() {
                return .{ .slice = @ptrCast(s) };
            }
        };
    }

    /// 字段包含一个 u32 长度,后跟相应数量的元素。
    /// 每个元素必须具有明确定义的内存布局,此外其大小
    /// 可为任意个 u32 的整数倍。长度是元素数量,
    /// 而不是 u32 的数量。
    pub fn LengthPrefixedList(comptime ElemArg: type) type {
        return struct {
            slice: []const Elem,

            pub const storage: Storage = .length_prefixed_list;
            pub const Elem = ElemArg;

            pub fn initErased(s: []const u32) @This() {
                return .{ .slice = @ptrCast(s) };
            }
        };
    }

    /// 此字段为列表,长度是 flags 内的一个整数。
    pub fn FlagList(
        comptime flags_arg: @EnumLiteral(),
        comptime flag_arg: @EnumLiteral(),
        comptime ElemArg: type,
    ) type {
        return struct {
            slice: []const Elem,

            pub const storage: Storage = .flag_list;
            pub const flags = flags_arg;
            pub const flag = flag_arg;
            pub const Elem = ElemArg;

            pub fn initErased(s: []const u32) @This() {
                return .{ .slice = @ptrCast(s) };
            }
        };
    }

    /// 字段包含 u32 长度,其后先跟该数量的第一个字段元素,
    /// 再跟该数量的第二个字段元素,依此类推。
    pub fn MultiList(comptime ElemArg: type) type {
        return struct {
            mal: std.MultiArrayList(Elem),

            pub const storage: Storage = .multi_list;
            pub const Elem = ElemArg;
        };
    }

    /// `UnionArg` 是以小整数作为枚举标签的带标签联合体。
    ///
    /// flags 中的一个字段决定元数据是否存在。
    ///
    /// 元数据是一系列连续的位打包紧凑结构体,每项由 `UnionArg` 枚举标签和一个“last”布尔标记字段组成。
    /// “last”为 true 时,该元素为最后一个,由此可确定列表长度。
    ///
    /// 随后是列表的各个元素,每个都可按位转换为 u32。
    ///
    ///
    pub fn UnionList(
        comptime flags_arg: @EnumLiteral(),
        comptime flag_arg: @EnumLiteral(),
        comptime UnionArg: type,
    ) type {
        return struct {
            /// 序列化时是 UnionArg 切片指针。
            /// 反序列化时是首个 UnionArg 元素的 extra 索引。
            data: ?*const anyopaque,
            len: usize,

            pub const storage: Storage = .union_list;
            pub const flags = flags_arg;
            pub const flag = flag_arg;
            pub const Union = UnionArg;

            pub const Tag = @typeInfo(Union).@"union".tag_type.?;
            pub const MetaInt = @Int(.unsigned, @bitSizeOf(Tag) + 1);
            pub const Meta = packed struct(MetaInt) {
                tag: Tag,
                last: bool,
            };

            /// 仅在序列化时调用才有效。
            pub fn init(s: []const Union) @This() {
                return .{ .data = s.ptr, .len = s.len };
            }

            /// 仅在反序列化时允许调用。
            pub fn slice(this: *const @This(), extra: []const u32) []const u32 {
                return extra[@intFromPtr(this.data)..][0..this.len];
            }

            /// 仅在反序列化时允许调用。
            pub fn get(this: *const @This(), extra: []const u32, i: usize) Union {
                const elem = slice(this, extra)[i];
                return switch (this.tag(extra, i)) {
                    inline else => |comptime_tag| @unionInit(Union, @tagName(comptime_tag), @fromBackingInt(@intCast(elem))),
                };
            }

            /// 仅在反序列化时允许调用。
            pub fn tag(this: *const @This(), extra: []const u32, i: usize) Tag {
                const start = @intFromPtr(this.data);
                const meta_start = start - (this.len * @bitSizeOf(Meta) + 31) / 32;
                return loadBits(u32, extra[meta_start..], i * @bitSizeOf(Meta), Meta).tag;
            }

            fn extraLen(len: usize) usize {
                return len + (len * @bitSizeOf(Meta) + 31) / 32;
            }
        };
    }

    pub fn dataLength(buffer: []const u32, i: usize, comptime S: type) usize {
        var end = i;
        _ = data(buffer, &end, S);
        return end - i;
    }

    pub fn data(buffer: []const u32, i: *usize, comptime T: type) T {
        switch (@typeInfo(T)) {
            .@"struct" => |info| {
                var result: T = undefined;
                inline for (info.field_names, info.field_types) |field_name, field_type| {
                    @field(result, field_name) = dataField(buffer, i, &result, field_type);
                }
                return result;
            },
            .@"union" => |info| {
                const flags: T.Flags = @bitCast(buffer[i.*]);
                return switch (flags.tag) {
                    inline else => |comptime_tag| @unionInit(
                        T,
                        @tagName(comptime_tag),
                        data(buffer, i, info.field_types[@backingInt(comptime_tag)]),
                    ),
                };
            },
            else => comptime unreachable,
        }
    }

    fn dataField(buffer: []const u32, i: *usize, container: anytype, comptime Field: type) Field {
        switch (@typeInfo(Field)) {
            .void => return {},
            .int => |info| switch (info.bits) {
                32 => {
                    defer i.* += 1;
                    return buffer[i.*];
                },
                64 => {
                    defer i.* += 2;
                    return @bitCast(buffer[i.*..][0..2].*);
                },
                else => comptime unreachable,
            },
            .@"enum" => {
                defer i.* += 1;
                return @fromBackingInt(@intCast(buffer[i.*]));
            },
            .@"struct" => |info| switch (info.layout) {
                .@"packed" => switch (info.backing_integer.?) {
                    u32 => {
                        defer i.* += 1;
                        return @bitCast(buffer[i.*]);
                    },
                    u64 => {
                        defer i.* += 2;
                        return @bitCast(buffer[i.*..][0..2].*);
                    },
                    else => comptime unreachable,
                },
                .auto => switch (Field) {
                    std.Target.Cpu.Feature.Set => {
                        const u32_count = (Field.usize_count * @sizeOf(usize)) / @sizeOf(u32);
                        defer i.* += u32_count;
                        return .{ .ints = @as(
                            *align(@alignOf(u32)) const [Field.usize_count]usize,
                            @ptrCast(buffer[i.*..][0..u32_count]),
                        ).* };
                    },
                    else => switch (Field.storage) {
                        .flag_optional => {
                            const flags = @field(container, @tagName(Field.flags));
                            const flag = @field(flags, @tagName(Field.flag));
                            return .{
                                .value = if (flag) dataField(buffer, i, container, Field.Value) else null,
                            };
                        },
                        .flag_union => {
                            const flags = @field(container, @tagName(Field.flags));
                            const tag: Field.Tag = @field(flags, @tagName(Field.flag));
                            return .{
                                .u = switch (tag) {
                                    inline else => |comptime_tag| @unionInit(
                                        Field.Union,
                                        @tagName(comptime_tag),
                                        dataField(
                                            buffer,
                                            i,
                                            container,
                                            @typeInfo(Field.Union).@"union".field_types[@backingInt(comptime_tag)],
                                        ),
                                    ),
                                },
                            };
                        },
                        .enum_optional => {
                            const flags = @field(container, @tagName(Field.flags));
                            const tag = @field(flags, @tagName(Field.flag));
                            const match = tag == Field.tag;
                            return .{
                                .value = if (match) dataField(buffer, i, container, Field.Value) else null,
                            };
                        },
                        .extended => @compileError("unimplemented"),
                        .length_prefixed_list => {
                            const n = @divExact(@sizeOf(Field.Elem), @sizeOf(u32));
                            const data_start = i.* + 1;
                            const buf_len = buffer[data_start - 1] * n;
                            defer i.* = data_start + buf_len;
                            return .{ .slice = @ptrCast(buffer[data_start..][0..buf_len]) };
                        },
                        .flag_length_prefixed_list => {
                            const flags = @field(container, @tagName(Field.flags));
                            const flag = @field(flags, @tagName(Field.flag));
                            if (!flag) return .{ .slice = &.{} };
                            const n = @divExact(@sizeOf(Field.Elem), @sizeOf(u32));
                            const data_start = i.* + 1;
                            const buf_len = buffer[data_start - 1] * n;
                            defer i.* = data_start + buf_len;
                            return .{ .slice = @ptrCast(buffer[data_start..][0..buf_len]) };
                        },
                        .flag_list => {
                            const flags = @field(container, @tagName(Field.flags));
                            const len: u32 = @field(flags, @tagName(Field.flag));
                            const data_start = i.*;
                            defer i.* = data_start + len;
                            return .{ .slice = @ptrCast(buffer[data_start..][0..len]) };
                        },
                        .multi_list => {
                            const data_start = i.* + 1;
                            const len = buffer[data_start - 1];
                            defer i.* = data_start + len * @typeInfo(Field.Elem).@"struct".field_names.len;
                            return .{ .mal = .{
                                .bytes = @ptrCast(@constCast(buffer[data_start..][0..len])),
                                .len = len,
                                .capacity = len,
                            } };
                        },
                        .union_list => {
                            const flags = @field(container, @tagName(Field.flags));
                            const flag = @field(flags, @tagName(Field.flag));
                            if (!flag) return .{ .data = null, .len = 0 };
                            const meta_start = i.*;
                            const meta_buffer = buffer[meta_start..];
                            var len: u32 = 0;
                            var bit_offset: usize = 0;
                            while (true) : (bit_offset += @bitSizeOf(Field.Meta)) {
                                const meta = loadBits(u32, meta_buffer, bit_offset, Field.Meta);
                                len += 1;
                                if (meta.last) break;
                            }
                            const end = meta_start + Field.extraLen(len);
                            i.* = end;
                            return .{ .data = @ptrFromInt(end - len), .len = len };
                        },
                    },
                },
                .@"extern" => {
                    const n = @divExact(@sizeOf(Field), @sizeOf(u32));
                    defer i.* += n;
                    const ptr: *align(@alignOf(u32)) const Field = @ptrCast(buffer[i.*..][0..n]);
                    return ptr.*;
                },
            },
            else => comptime unreachable,
        }
    }

    /// 返回新的结束索引。
    fn setExtra(buffer: []u32, index: usize, extra: anytype) usize {
        const info = @typeInfo(@TypeOf(extra)).@"struct";
        var i = index;
        inline for (info.field_names, info.field_types) |field_name, field_type| {
            i += setExtraField(buffer, i, field_type, @field(extra, field_name));
        }
        return i;
    }

    fn extraFieldLen(field: anytype) usize {
        const Field = @TypeOf(field);
        return switch (@typeInfo(Field)) {
            .void => 0,
            .int => |info| switch (info.bits) {
                32 => 1,
                64 => 2,
                else => comptime unreachable,
            },
            .@"enum" => 1,
            .@"struct" => |info| switch (info.layout) {
                .@"packed" => switch (info.backing_integer.?) {
                    u32 => 1,
                    u64 => 2,
                    else => comptime unreachable,
                },
                .auto => switch (Field.storage) {
                    .flag_optional, .enum_optional => (@sizeOf(Field.Value) + 3) / 4,
                    .extended => 1,
                    .length_prefixed_list,
                    .flag_length_prefixed_list,
                    .flag_list,
                    => 1 + @divExact(@sizeOf(Field.Elem), @sizeOf(u32)) * field.slice.len,
                    .multi_list => 1 + field.mal.len * @typeInfo(Field.Elem).@"struct".field_names.len,
                    .union_list => Field.extraLen(field.len),
                    .flag_union => switch (field.u) {
                        inline else => |v| extraFieldLen(v),
                    },
                },
                .@"extern" => @divExact(@sizeOf(Field), @sizeOf(u32)),
            },
            else => @compileError("bad type: " ++ @typeName(Field)),
        };
    }

    fn extraLen(extra: anytype) usize {
        const field_names = @typeInfo(@TypeOf(extra)).@"struct".field_names;
        var i: usize = 0;
        inline for (field_names) |name| {
            i += Storage.extraFieldLen(@field(extra, name));
        }
        return i;
    }

    inline fn setExtraField(buffer: []u32, i: usize, comptime Field: type, value: anytype) usize {
        switch (@typeInfo(Field)) {
            .void => return 0,
            .int => |info| switch (info.bits) {
                32 => {
                    buffer[i] = value;
                    return 1;
                },
                64 => {
                    buffer[i..][0..2].* = @bitCast(value);
                    return 2;
                },
                else => comptime unreachable,
            },
            .@"enum" => {
                buffer[i] = @backingInt(value);
                return 1;
            },
            .@"struct" => |info| switch (info.layout) {
                .@"packed" => switch (info.backing_integer.?) {
                    u32 => {
                        buffer[i] = @bitCast(value);
                        return 1;
                    },
                    u64 => {
                        buffer[i..][0..2].* = @bitCast(value);
                        return 2;
                    },
                    else => comptime unreachable,
                },
                .auto => switch (Field) {
                    std.Target.Cpu.Feature.Set => {
                        const casted: []const u32 = @ptrCast(&value.ints);
                        @memcpy(buffer[i..][0..casted.len], casted);
                        return casted.len;
                    },
                    else => switch (Field.storage) {
                        .flag_optional, .enum_optional => {
                            return if (value.value) |v| setExtraField(buffer, i, Field.Value, v) else 0;
                        },
                        .flag_union => return switch (value.u) {
                            inline else => |x| setExtraField(buffer, i, @TypeOf(x), x),
                        },
                        .extended => @compileError("unimplemented"),
                        .flag_length_prefixed_list => {
                            const len: u32 = @intCast(value.slice.len);
                            if (len == 0) return 0; // 标志位隐藏长度前缀。
                            buffer[i] = len;
                            const buf_len = len * @divExact(@sizeOf(Field.Elem), @sizeOf(u32));
                            @memcpy(buffer[i + 1 ..][0..buf_len], @as([]const u32, @ptrCast(value.slice)));
                            return 1 + buf_len;
                        },
                        .length_prefixed_list => {
                            const len: u32 = @intCast(value.slice.len);
                            buffer[i] = len;
                            const buf_len = len * @divExact(@sizeOf(Field.Elem), @sizeOf(u32));
                            @memcpy(buffer[i + 1 ..][0..buf_len], @as([]const u32, @ptrCast(value.slice)));
                            return 1 + buf_len;
                        },
                        .flag_list => {
                            const len: u32 = @intCast(value.slice.len);
                            @memcpy(buffer[i..][0..len], @as([]const u32, @ptrCast(value.slice)));
                            return len;
                        },
                        .multi_list => {
                            const len: u32 = @intCast(value.mal.len);
                            buffer[i] = len;
                            const field_names = @typeInfo(Field.Elem).@"struct".field_names;
                            inline for (0..field_names.len) |field_i| @memcpy(
                                buffer[i + 1 + field_i * len ..][0..len],
                                @as([]const u32, @ptrCast(value.mal.items(@fromBackingInt(@intCast(field_i))))),
                            );
                            return 1 + field_names.len * len;
                        },
                        .union_list => {
                            if (value.len == 0) return 0;
                            const Tag = @typeInfo(Field.Union).@"union".tag_type.?;
                            const slice_ptr: [*]const Field.Union = @ptrCast(@alignCast(value.data));
                            const slice = slice_ptr[0..value.len];
                            const meta_buffer = buffer[i..][0 .. (slice.len * @bitSizeOf(Field.Meta) + 31) / 32];
                            for (slice[0 .. slice.len - 1], 0..) |elem, elem_index| {
                                const union_tag: Tag = elem;
                                storeBits(u32, meta_buffer, elem_index * @bitSizeOf(Field.Meta), @as(Field.Meta, .{
                                    .tag = union_tag,
                                    .last = false,
                                }));
                            } else {
                                const elem_index = slice.len - 1;
                                const elem = slice[elem_index];
                                const union_tag: Tag = elem;
                                storeBits(u32, meta_buffer, elem_index * @bitSizeOf(Field.Meta), @as(Field.Meta, .{
                                    .tag = union_tag,
                                    .last = true,
                                }));
                            }
                            var total: usize = meta_buffer.len;
                            for (i + meta_buffer.len.., slice) |elem_index, src| switch (src) {
                                inline else => |x| total += setExtraField(buffer, elem_index, @TypeOf(x), x),
                            };
                            return total;
                        },
                    },
                },
                .@"extern" => {
                    const n = @divExact(@sizeOf(Field), @sizeOf(u32));
                    const ptr: *align(@alignOf(Field)) const [n]u32 = @ptrCast(&value);
                    buffer[i..][0..n].* = ptr.*;
                    return n;
                },
            },
            else => @compileError("bad field type: " ++ @typeName(Field)),
        }
    }
};

fn IndexType(comptime T: type) type {
    return enum(u32) {
        _,

        pub fn get(this: @This(), c: *const Configuration) T {
            return extraData(c, T, @backingInt(this));
        }
    };
}

pub fn extraData(c: *const Configuration, comptime T: type, index: usize) T {
    var i: usize = index;
    return Storage.data(c.extra, &i, T);
}

pub const LoadFileError = Io.File.Reader.Error || Allocator.Error || error{EndOfStream};

pub fn loadFile(arena: Allocator, io: Io, file: Io.File) LoadFileError!Configuration {
    var buffer: [2000]u8 = undefined;
    var fr = file.reader(io, &buffer);
    return load(arena, &fr.interface) catch |err| switch (err) {
        error.ReadFailed => return fr.err.?,
        else => |e| return e,
    };
}

pub const LoadError = Io.Reader.Error || Allocator.Error;

pub fn load(arena: Allocator, reader: *Io.Reader) LoadError!Configuration {
    const header = try reader.takeStruct(Header, .native);
    const result: Configuration = .{
        .string_bytes = try arena.alloc(u8, header.string_bytes_len),
        .steps = try arena.alloc(Step, header.steps_len),
        .path_deps = try arena.alloc(PathDep, header.path_deps_len),
        .unlazy_deps = try arena.alloc(String, header.unlazy_deps_len),
        .system_integrations = try arena.alloc(SystemIntegration, header.system_integrations_len),
        .available_options = try arena.alloc(AvailableOption, header.available_options_len),
        .search_prefixes = try arena.alloc(String, header.search_prefixes_len),
        .extra = try arena.alloc(u32, header.extra_len),
        .default_step = header.default_step,
        .generated_files_len = header.generated_files_len,
        .poisoned = header.flags.poisoned,
    };
    var vecs = [_][]u8{
        result.string_bytes,
        @ptrCast(result.steps),
        @ptrCast(result.path_deps),
        @ptrCast(result.unlazy_deps),
        @ptrCast(result.system_integrations),
        @ptrCast(result.available_options),
        @ptrCast(result.search_prefixes),
        @ptrCast(result.extra),
    };
    try reader.readVecAll(&vecs);
    return result;
}

/// `value` 跨越多个字节时,使用本机字节序加载位。
/// 在大端架构上,`bit_offset` 使用最高有效位编号为 0 的位编号方式。
/// 在小端架构上,`bit_offset` 使用最低有效位编号为 0 的位编号方式。
/// 参见 `storeBits`。
pub fn loadBits(comptime Int: type, buffer: []const Int, bit_offset: usize, comptime Result: type) Result {
    const index = bit_offset / @bitSizeOf(Int);
    const small_bit_offset = bit_offset % @bitSizeOf(Int);
    const ResultInt = @Int(.unsigned, @bitSizeOf(Result));
    switch (native_endian) {
        .little => {
            const result: ResultInt = @truncate(buffer[index] >> @intCast(small_bit_offset));
            const available_bits = @bitSizeOf(Int) - small_bit_offset;
            if (available_bits >= @bitSizeOf(ResultInt)) return @bitCast(result);
            const missing_bits = @bitSizeOf(ResultInt) - available_bits;
            const upper: ResultInt = @truncate(buffer[index + 1] & ((@as(usize, 1) << @intCast(missing_bits)) - 1));
            return @bitCast(result | (upper << @intCast(available_bits)));
        },
        .big => {
            const available_bits = @bitSizeOf(Int) - small_bit_offset;
            if (available_bits >= @bitSizeOf(ResultInt)) {
                const shift = available_bits - @bitSizeOf(ResultInt);
                const result: ResultInt = @truncate(buffer[index] >> @intCast(shift));
                return @bitCast(result);
            }
            const mask = (@as(Int, 1) << @intCast(available_bits)) - 1;
            const result: ResultInt = @intCast(buffer[index] & mask);
            const missing_bits = @bitSizeOf(ResultInt) - available_bits;
            const lower: ResultInt = @truncate(buffer[index + 1] >> @intCast(@bitSizeOf(Int) - missing_bits));
            return @bitCast((result << @intCast(missing_bits)) | lower);
        },
    }
}

/// 当 `value` 跨多个字节时,按本机字节序存储位。
/// 大端架构上:
/// - 对于给定值,较早字节的位比后续字节的位具有更高权重。
/// - `bit_offset` 使用 MSb 0 位编号方式。
/// 小端架构上:
/// - 对于给定值,较早字节的位比后续字节的位具有更低权重。
/// - `bit_offset` 使用 LSb 0 位编号方式。
pub fn storeBits(comptime Int: type, buffer: []Int, bit_offset: usize, value: anytype) void {
    const Value = @TypeOf(value);
    const ValueInt = @Int(.unsigned, @bitSizeOf(Value));
    const value_int: ValueInt = @bitCast(value);
    const index = bit_offset / @bitSizeOf(Int);
    const small_bit_offset = bit_offset % @bitSizeOf(Int);
    const available_bits = @bitSizeOf(Int) - small_bit_offset;
    if (available_bits >= @bitSizeOf(ValueInt)) {
        const shift = switch (native_endian) {
            .little => small_bit_offset,
            .big => available_bits - @bitSizeOf(ValueInt),
        };
        buffer[index] &= ~(((@as(Int, 1) << @intCast(@bitSizeOf(Value))) - 1) << @intCast(shift));
        buffer[index] |= @as(Int, value_int) << @intCast(shift);
    } else {
        const DoubleInt = @Int(.unsigned, @bitSizeOf(Int) * 2);
        const shift = switch (native_endian) {
            .little => small_bit_offset,
            .big => @bitSizeOf(DoubleInt) - small_bit_offset - @bitSizeOf(ValueInt),
        };
        const ptr: *align(@alignOf(Int)) DoubleInt = @ptrCast(buffer[index..][0..2]);
        ptr.* &= ~(((@as(DoubleInt, 1) << @intCast(@bitSizeOf(Value))) - 1) << @intCast(shift));
        ptr.* |= @as(DoubleInt, value_int) << @intCast(shift);
    }
}

test "loadBits and storeBits" {
    var buffer: [2]u32 = switch (native_endian) {
        .little => .{
            // ──┐ 0b100011(结束)   ┌─┐ 0b100
            0b01111111000000001111111100000000,
            //            n <── 位偏移 0 ┘
            //                             ┌── 0b100011(起始)
            0b11111111000000001111111100000100,
        },
        .big => .{
            //      ┌─┐ 0b100              ┌── 0b100011(起点)
            0b11111110000000001111111100000100,
            // └ 位偏移 0 ──> n
            // ──┐ 0b100011(结束)
            0b01111111000000001111111100000000,
        },
    };

    try std.testing.expectEqual(0b100, loadBits(u32, &buffer, 6, u3));
    try std.testing.expectEqual(0b100011, loadBits(u32, &buffer, 29, u6));

    storeBits(u32, &buffer, 0, @as(u1, 0b0));
    storeBits(u32, &buffer, 6, @as(u3, 0b010));
    storeBits(u32, &buffer, 29, @as(u6, 0b010110));
    storeBits(u32, &buffer, 40, @as(u17, 0b01110110011111110));

    try std.testing.expectEqual(0b0, loadBits(u32, &buffer, 0, u1));
    try std.testing.expectEqual(0b010, loadBits(u32, &buffer, 6, u3));
    try std.testing.expectEqual(0b010110, loadBits(u32, &buffer, 29, u6));
    try std.testing.expectEqual(0b01110110011111110, loadBits(u32, &buffer, 40, u17));

    // 测试大小与偏移量组合的往返转换。
    inline for (1..32) |value_size| {
        for (0..64) |bit_offset| {
            if (value_size + bit_offset > @bitSizeOf(@TypeOf(buffer))) continue;

            buffer = .{ 0, 0 };

            const Value = @Int(.unsigned, value_size);
            const value: Value = @intCast((@as(u32, 1) << @intCast(@bitSizeOf(Value))) - 1);
            storeBits(u32, &buffer, bit_offset, value);
            std.testing.expectEqual(value, loadBits(u32, &buffer, bit_offset, Value)) catch |err| {
                std.debug.print("value size: {} bit offset: {}\n", .{ value_size, bit_offset });
                std.debug.print("buffer: {b:0>32} {b:0>32}\n", .{ buffer[0], buffer[1] });
                return err;
            };
        }
    }
}