字段
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
ConfigurationstdbuiltinIoAllocatorassertmax_u32native_endianHeaderWipSystemIntegrationAvailableOptionStepMaxRssLazyPathGeneratedFileIndexOptionalGeneratedFileIndexPackageModuleImportTableDepsEnvironMapStringListOptionalStringListPathDepInstallDestDirOptionalStringStringBytesAlignmentDefaultingBoolSystemLibCSourceFilesCSourceFileRcSourceFileOptionalCSourceLanguageResolvedTargetTargetQueryStorageIndexTypeextraDataLoadFileErrorloadFileLoadErrorloadloadBitsstoreBits
std.Build.Configuration.Alignment
容器
以 2 的幂形式存储,另用一个特殊值表示无。
字段
std.Build.Configuration.Alignment.init
函数
pub fn init(optional_alignment: ?std.mem.Alignment) @This()
参数
std.Build.Configuration.Alignment.toBytes
函数
pub fn toBytes(a: @This()) ?u64
参数
a: @This()
std.Build.Configuration.Allocator
别名
别名目标 std.mem.Allocator
std.Build.Configuration.assert
别名
别名目标 std.debug.assert
std.Build.Configuration.AvailableOption
容器
字段
name: String
description: String
type: Type
enum_options: OptionalStringList若 type_id 为 enum 或 enum_list,则提供枚举选项列表
std.Build.Configuration.AvailableOption.Type
容器
字段
bool
int
float
@"enum"
enum_list
string
list
build_id
lazy_path
lazy_path_list
std.Build.Configuration.builtin
常量
std.Build.Configuration.Bytes
容器
可能包含空字节的任意字节序列。
字段
index: u32指向 string_bytes 内部。
len: u32
std.Build.Configuration.Bytes.slice
函数
pub fn slice(bytes: Bytes, c: *const Configuration) []const u8
参数
bytes: Bytes
c: *const Configuration
std.Build.Configuration.Configuration
别名
std.Build.Configuration.CSourceFile
容器
字段
std.Build.Configuration.CSourceFile.Flags
容器
字段
std.Build.Configuration.CSourceFile.Index
类型
std.Build.Configuration.CSourceFiles
容器
字段
std.Build.Configuration.CSourceFiles.Flags
容器
字段
std.Build.Configuration.CSourceFiles.Index
类型
std.Build.Configuration.DefaultingBool
容器
字段
false
true
default
std.Build.Configuration.DefaultingBool.init
函数
pub fn init(b: ?bool) DefaultingBool
参数
b: ?bool
std.Build.Configuration.DefaultingBool.toBool
函数
pub fn toBool(db: DefaultingBool) ?bool
参数
db: DefaultingBool
std.Build.Configuration.Deps
容器
字段
steps: Storage.LengthPrefixedList(Step.Index)
std.Build.Configuration.Deps.Index
容器
字段
_
std.Build.Configuration.Deps.Index.get
函数
pub fn get(this: @This(), c: *const Configuration) Deps
参数
this: @This()
c: *const Configuration
std.Build.Configuration.Deps.Index.slice
函数
pub fn slice(this: @This(), c: *const Configuration) []const Step.Index
参数
this: @This()
c: *const Configuration
std.Build.Configuration.EnvironMap
容器
字段
keys: StringList
values: StringList
std.Build.Configuration.EnvironMap.Index
类型
std.Build.Configuration.extraData
函数
pub fn extraData(c: *const Configuration, comptime T: type, index: usize) T
参数
std.Build.Configuration.GeneratedFileIndex
容器
字段
_
std.Build.Configuration.Header
容器
此处字段顺序与 Configuration 一致,
后者说明序列化格式中的顺序。
字段
std.Build.Configuration.Header.Flags
容器
字段
poisoned: bool
_: u31 = 0
std.Build.Configuration.ImportTable
容器
字段
std.Build.Configuration.ImportTable.Import
容器
字段
std.Build.Configuration.ImportTable.Index
容器
指向 extra 内部。
字段
invalid = max_u32
_
std.Build.Configuration.ImportTable.Index.get
函数
pub fn get(this: @This(), c: *const Configuration) ImportTable
参数
this: @This()
c: *const Configuration
std.Build.Configuration.IndexType
类型函数
fn IndexType(comptime T: type) type
参数
T: type
字段
_
std.Build.Configuration.IndexType.get
函数
pub fn get(this: @This(), c: *const Configuration) T
参数
this: @This()
c: *const Configuration
std.Build.Configuration.InstallDestDir
容器
字段
std.Build.Configuration.InstallDestDir.initCustom
函数
pub fn initCustom(sub_path: String) InstallDestDir
参数
sub_path: String
std.Build.Configuration.InstallDestDir.unpack
函数
pub fn unpack(this: @This()) ?Unpacked
参数
this: @This()
std.Build.Configuration.InstallDestDir.Unpacked
容器
字段
std.Build.Configuration.Io
别名
别名目标 std.Io
std.Build.Configuration.LazyPath
容器
字段
std.Build.Configuration.LazyPath.Flags
容器
字段
tag: Tag
_: u24 = 0
std.Build.Configuration.LazyPath.Generated
容器
字段
std.Build.Configuration.LazyPath.Generated.Flags
容器
字段
std.Build.Configuration.LazyPath.Index
类型
extra 的索引。
std.Build.Configuration.LazyPath.OptionalIndex
容器
extra 中的索引,或 null。
字段
none = max_u32
_
std.Build.Configuration.LazyPath.OptionalIndex.unwrap
函数
pub fn unwrap(this: @This()) ?Index
参数
this: @This()
std.Build.Configuration.LazyPath.Relative
容器
字段
flags: @This().Flags
sub_path: String
std.Build.Configuration.LazyPath.Relative.Base
容器
字段
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
容器
字段
std.Build.Configuration.LazyPath.SourcePath
容器
字段
std.Build.Configuration.LazyPath.SourcePath.Flags
容器
字段
tag: Tag = .source_path
_: u24 = 0
std.Build.Configuration.LazyPath.Tag
容器
字段
source_path相对于构建根目录的源文件路径。
relative相对于 flags 指示的目录。
generated仅在所属步骤填充路径后,该路径才可用。
std.Build.Configuration.load
函数
pub fn load(arena: Allocator, reader: *Io.Reader) LoadError!Configuration
参数
错误
std.Build.Configuration.loadBits
函数
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
错误集合
错误
std.Build.Configuration.loadFile
函数
pub fn loadFile(arena: Allocator, io: Io, file: Io.File) LoadFileError!Configuration
参数
错误
- 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
错误集合
错误
- 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
常量
std.Build.Configuration.MaxRss
容器
字段
none = 0
_
std.Build.Configuration.MaxRss.fromBytes
函数
pub fn fromBytes(bytes: u64) MaxRss
参数
bytes: u64
std.Build.Configuration.MaxRss.toBytes
函数
pub fn toBytes(mr: MaxRss) u64
参数
mr: MaxRss
std.Build.Configuration.Module
容器
字段
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
容器
字段
@"32"
@"64"
default
std.Build.Configuration.Module.DwarfFormat.init
函数
pub fn init(df: ?std.dwarf.Format) DwarfFormat
参数
std.Build.Configuration.Module.Flags
容器
字段
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
容器
字段
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
容器
字段
flags: @This().Flags
name: String
std.Build.Configuration.Module.Framework.Flags
容器
字段
needed: bool
weak: bool
_: u30 = 0
std.Build.Configuration.Module.IncludeDir
容器
字段
std.Build.Configuration.Module.Index
类型
std.Build.Configuration.Module.LinkObject
容器
字段
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
容器
字段
debug
safe
fast
small
default
std.Build.Configuration.Module.Optimize.init
函数
pub fn init(o: ?std.builtin.Optimize) Optimize
参数
std.Build.Configuration.Module.RPath
容器
字段
std.Build.Configuration.Module.SanitizeC
容器
字段
off
trap
full
default
std.Build.Configuration.Module.SanitizeC.init
函数
pub fn init(sc: ?std.zig.SanitizeC) SanitizeC
参数
std.Build.Configuration.Module.UnwindTables
容器
字段
none
sync
async
default
std.Build.Configuration.Module.UnwindTables.init
函数
pub fn init(ut: ?std.builtin.UnwindTables) UnwindTables
参数
ut: ?std.builtin.UnwindTables
std.Build.Configuration.native_endian
常量
std.Build.Configuration.OptionalCSourceLanguage
容器
字段
c
cpp
objective_c
objective_cpp
assembly
assembly_with_preprocessor
default
std.Build.Configuration.OptionalCSourceLanguage.get
函数
pub fn get(this: @This()) ?std.Build.Module.CSourceLanguage
参数
this: @This()
std.Build.Configuration.OptionalCSourceLanguage.init
函数
pub fn init(x: ?std.Build.Module.CSourceLanguage) @This()
参数
std.Build.Configuration.OptionalGeneratedFileIndex
容器
字段
none = max_u32
_
std.Build.Configuration.OptionalGeneratedFileIndex.init
函数
pub fn init(i: ?GeneratedFileIndex) OptionalGeneratedFileIndex
参数
std.Build.Configuration.OptionalGeneratedFileIndex.unwrap
函数
pub fn unwrap(this: @This()) ?GeneratedFileIndex
参数
this: @This()
std.Build.Configuration.OptionalString
容器
指向 string_bytes 内部,以空字符终止。
字段
std.Build.Configuration.OptionalString.init
函数
pub fn init(s: String) OptionalString
参数
s: String
std.Build.Configuration.OptionalString.slice
函数
pub fn slice(this: @This(), c: *const Configuration) ?[:0]const u8
参数
this: @This()
c: *const Configuration
std.Build.Configuration.OptionalString.unwrap
函数
pub fn unwrap(this: @This()) ?String
参数
this: @This()
std.Build.Configuration.OptionalStringList
容器
字段
none = max_u32
_
std.Build.Configuration.OptionalStringList.init
函数
pub fn init(opt_string_list: ?StringList) OptionalStringList
参数
opt_string_list: ?StringList
std.Build.Configuration.OptionalStringList.slice
函数
pub fn slice(this: @This(), c: *const Configuration) ?[]const String
参数
this: @This()
c: *const Configuration
std.Build.Configuration.OptionalStringList.unwrap
函数
pub fn unwrap(this: @This()) ?StringList
参数
this: @This()
std.Build.Configuration.Package
容器
字段
std.Build.Configuration.Package.Index
容器
字段
root = max_u32
_
std.Build.Configuration.Package.Index.depPrefixSlice
函数
pub fn depPrefixSlice(i: @This(), c: *const Configuration) [:0]const u8
参数
i: @This()
c: *const Configuration
std.Build.Configuration.Package.Index.get
函数
根包返回 null。
pub fn get(i: @This(), c: *const Configuration) ?Package
参数
i: @This()
c: *const Configuration
std.Build.Configuration.Package.OptionalIndex
容器
字段
std.Build.Configuration.Package.OptionalIndex.init
函数
pub fn init(i: Index) OptionalIndex
参数
i: Index
std.Build.Configuration.Package.OptionalIndex.unwrap
函数
pub fn unwrap(this: @This()) ?Index
参数
this: @This()
std.Build.Configuration.PathDep
容器
字段
std.Build.Configuration.PathDep.Flags
容器
字段
std.Build.Configuration.RcSourceFile
容器
字段
std.Build.Configuration.RcSourceFile.Flags
容器
字段
args_len: u31C 编译器命令行标志。
include_paths: bool
std.Build.Configuration.RcSourceFile.Index
类型
std.Build.Configuration.ResolvedTarget
容器
字段
std.Build.Configuration.ResolvedTarget.Index
类型
std.Build.Configuration.ResolvedTarget.OptionalIndex
容器
字段
none = max_u32
_
std.Build.Configuration.ResolvedTarget.OptionalIndex.get
函数
pub fn get(this: @This(), c: *const Configuration) ?ResolvedTarget
参数
this: @This()
c: *const Configuration
std.Build.Configuration.ResolvedTarget.OptionalIndex.init
函数
pub fn init(i: Index) OptionalIndex
参数
i: Index
std.Build.Configuration.ResolvedTarget.OptionalIndex.unwrap
函数
pub fn unwrap(this: @This()) ?Index
参数
this: @This()
std.Build.Configuration.ResolvedTarget.unwrapQuery
函数
pub fn unwrapQuery(rt: *const ResolvedTarget, c: *const Configuration) ?std.Target.Query
参数
rt: *const ResolvedTarget
c: *const Configuration
std.Build.Configuration.std
别名
别名目标 std
std.Build.Configuration.Step
容器
字段
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
容器
字段
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
容器
字段
std.Build.Configuration.Step.Compile
容器
字段
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
容器
字段
none
fast
uuid
sha1
md5
hexstring
default
std.Build.Configuration.Step.Compile.BuildId.init
函数
pub fn init(build_id: ?std.zig.BuildId) BuildId
参数
std.Build.Configuration.Step.Compile.BuildId.unwrap
函数
pub fn unwrap(this: @This(), hexstring: ?String, c: *const Configuration) ?std.zig.BuildId
参数
std.Build.Configuration.Step.Compile.Entry
容器
字段
default
disabled
enabled
symbol_name
std.Build.Configuration.Step.Compile.ExpectErrors
容器
字段
std.Build.Configuration.Step.Compile.ExpectErrors.Tag
容器
字段
contains
exact
starts_with
stderr_contains
none
std.Build.Configuration.Step.Compile.Flags
容器
字段
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
容器
字段
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
容器
字段
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
容器
字段
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
容器
字段
std.Build.Configuration.Step.Compile.InstalledHeader.Directory
容器
字段
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
容器
字段
std.Build.Configuration.Step.Compile.InstalledHeader.File
容器
字段
std.Build.Configuration.Step.Compile.InstalledHeader.File.Flags
容器
字段
tag: InstalledHeader.Tag = .file
_: u24 = 0
std.Build.Configuration.Step.Compile.InstalledHeader.Flags
容器
字段
tag: InstalledHeader.Tag
_: u24 = 0
std.Build.Configuration.Step.Compile.InstalledHeader.Tag
容器
字段
file
directory
std.Build.Configuration.Step.Compile.isDll
函数
pub fn isDll(compile: *const Compile, c: *const Configuration) bool
参数
compile: *const Compile
c: *const Configuration
std.Build.Configuration.Step.Compile.isDynamicLibrary
函数
pub fn isDynamicLibrary(compile: *const Compile) bool
参数
compile: *const Compile
std.Build.Configuration.Step.Compile.isStaticLibrary
函数
pub fn isStaticLibrary(compile: *const Compile) bool
参数
compile: *const Compile
std.Build.Configuration.Step.Compile.Kind
容器
字段
exe
lib
obj
@"test"
test_obj
std.Build.Configuration.Step.Compile.Kind.isTest
函数
pub fn isTest(kind: Kind) bool
参数
kind: Kind
std.Build.Configuration.Step.Compile.Kind.toOutputMode
函数
pub fn toOutputMode(kind: Kind) std.builtin.OutputMode
参数
kind: Kind
std.Build.Configuration.Step.Compile.Linkage
容器
字段
static
dynamic
default
std.Build.Configuration.Step.Compile.Linkage.init
函数
pub fn init(link_mode: ?std.builtin.LinkMode) Linkage
参数
std.Build.Configuration.Step.Compile.Linkage.unwrap
函数
pub fn unwrap(this: @This()) ?std.builtin.LinkMode
参数
this: @This()
std.Build.Configuration.Step.Compile.Lto
容器
字段
none
full
thin
default
std.Build.Configuration.Step.Compile.Lto.init
函数
pub fn init(lto: ?std.zig.LtoMode) Lto
参数
std.Build.Configuration.Step.Compile.producesImplib
函数
pub fn producesImplib(compile: *const Compile, c: *const Configuration) bool
参数
compile: *const Compile
c: *const Configuration
std.Build.Configuration.Step.Compile.rootModuleTarget
函数
pub fn rootModuleTarget(compile: *const Compile, c: *const Configuration) TargetQuery
参数
compile: *const Compile
c: *const Configuration
std.Build.Configuration.Step.Compile.Subsystem
容器
字段
console
windows
posix
native
efi_application
efi_boot_service_driver
efi_rom
efi_runtime_driver
default
std.Build.Configuration.Step.Compile.Subsystem.init
函数
pub fn init(subsystem: ?std.zig.Subsystem) Subsystem
参数
std.Build.Configuration.Step.Compile.TestRunner
容器
字段
std.Build.Configuration.Step.Compile.TestRunner.Tag
容器
字段
default
simple
server
std.Build.Configuration.Step.Compile.WasiExecModel
容器
字段
default
command
reactor
std.Build.Configuration.Step.Compile.WasiExecModel.init
函数
pub fn init(wasi_exec_model: ?std.builtin.WasiExecModel) WasiExecModel
参数
wasi_exec_model: ?std.builtin.WasiExecModel
std.Build.Configuration.Step.ConfigHeader
容器
字段
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
容器
字段
std.Build.Configuration.Step.ConfigHeader.Style
容器
字段
autoconf_undef
autoconf_at
cmake
meson
blank
nasm
std.Build.Configuration.Step.ConfigHeader.Style.init
函数
pub fn init(s: std.Build.Step.ConfigHeader.Style) Style
参数
std.Build.Configuration.Step.ConfigHeader.Value
容器
字段
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
容器
字段
std.Build.Configuration.Step.ConfigHeader.Value.Index
容器
字段
std.Build.Configuration.Step.ConfigHeader.Value.Index.unpack
函数
pub fn unpack(this: @This(), c: *const Configuration) Unpacked
参数
this: @This()
c: *const Configuration
std.Build.Configuration.Step.ConfigHeader.Value.initSigned
函数
pub fn initSigned(x: i64) @This()
参数
x: i64
std.Build.Configuration.Step.ConfigHeader.Value.Pair
容器
字段
std.Build.Configuration.Step.ConfigHeader.Value.Tag
容器
字段
ident
string
small_unsigned
small_signed
i64
u64
std.Build.Configuration.Step.ConfigHeader.Value.Unpacked
容器
字段
bool: bool
undef
defined
i64: i64
u64: u64
ident: []const u8
string: []const u8
std.Build.Configuration.Step.Fail
容器
字段
flags: @This().Flags = .{}
msg: String
std.Build.Configuration.Step.Fail.Flags
容器
字段
tag: Tag = .fail
_: u27 = 0
std.Build.Configuration.Step.FindProgram
容器
字段
std.Build.Configuration.Step.FindProgram.Flags
容器
字段
tag: Tag = .find_program
_: u27 = 0
std.Build.Configuration.Step.flags
函数
pub fn flags(s: *const Step, c: *const Configuration) Flags
参数
s: *const Step
c: *const Configuration
std.Build.Configuration.Step.Flags
容器
由所有步骤共享。
字段
tag: Tag
_: u27 = 0
std.Build.Configuration.Step.Fmt
容器
字段
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
容器
字段
std.Build.Configuration.Step.Index
容器
指向 steps 内部。
字段
_
std.Build.Configuration.Step.Index.ptr
函数
pub fn ptr(i: Index, c: *const Configuration) *const Step
参数
i: Index
c: *const Configuration
std.Build.Configuration.Step.InstallArtifact
容器
首个依赖步骤索引为编译步骤, 其产物由当前步骤安装。
字段
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
容器
字段
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
容器
字段
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
容器
字段
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
容器
字段
std.Build.Configuration.Step.InstallFile.Flags
容器
字段
tag: Tag = .install_file
_: u27 = 0
std.Build.Configuration.Step.ObjCopy
容器
字段
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
容器
字段
std.Build.Configuration.Step.ObjCopy.Flags
容器
字段
std.Build.Configuration.Step.ObjCopy.Format
容器
字段
binary
hex
elf
default
std.Build.Configuration.Step.ObjCopy.Format.init
函数
pub fn init(f: ?std.Build.Step.ObjCopy.Format) @This()
参数
std.Build.Configuration.Step.ObjCopy.SectionFlags
容器
字段
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
常量
@This()
std.Build.Configuration.Step.ObjCopy.Strip
容器
字段
none
debug
debug_and_symbols
std.Build.Configuration.Step.ObjCopy.UpdateSection
容器
字段
section_name: String
flags: @This().Flags
std.Build.Configuration.Step.ObjCopy.UpdateSection.Flags
容器
字段
std.Build.Configuration.Step.Options
容器
字段
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
容器
字段
std.Build.Configuration.Step.Options.NamedPath
容器
字段
std.Build.Configuration.Step.Run
容器
字段
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
容器
字段
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
容器
字段
std.Build.Configuration.Step.Run.Arg.Index
类型
std.Build.Configuration.Step.Run.Arg.Tag
容器
字段
artifact
path_filepath 包含该文件。
path_directory
stringprefix 包含此字符串。
file_content
output_file
output_directory
passthru
enable_darlingprefix 包含启用状态的字符串。
suffix 包含禁用状态的字符串。
enable_qemu
enable_rosetta
enable_wasmtime
enable_wine
std.Build.Configuration.Step.Run.CapturedStream
容器
字段
generated_file: GeneratedFileIndex
basename: String
std.Build.Configuration.Step.Run.Color
容器
字段
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
容器
字段
exited
signal
stopped
unknown
std.Build.Configuration.Step.Run.Flags
容器
字段
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
容器
字段
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
容器
字段
std.Build.Configuration.Step.Run.StdIn
容器
字段
std.Build.Configuration.Step.Run.StdIn.Tag
容器
字段
none
bytes
lazy_path
std.Build.Configuration.Step.Run.StdIo
容器
字段
infer_from_args
inherit
check
zig_test
protocol
std.Build.Configuration.Step.Run.TrimWhitespace
容器
字段
none
all
leading
trailing
std.Build.Configuration.Step.Tag
容器
字段
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
容器
字段
flags: @This().Flags = .{}
description: String
std.Build.Configuration.Step.TopLevel.Flags
容器
字段
tag: Tag = .top_level
_: u27 = 0
std.Build.Configuration.Step.TranslateC
容器
字段
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
容器
字段
std.Build.Configuration.Step.UpdateSourceFiles
容器
字段
flags: @This().Flags
embeds: Storage.FlagLengthPrefixedList(.flags, .embeds, Embed)
copies: Storage.FlagLengthPrefixedList(.flags, .copies, Copy)
std.Build.Configuration.Step.UpdateSourceFiles.Copy
别名
std.Build.Configuration.Step.UpdateSourceFiles.Embed
别名
std.Build.Configuration.Step.UpdateSourceFiles.Flags
容器
字段
std.Build.Configuration.Step.WriteFile
容器
字段
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
容器
字段
std.Build.Configuration.Step.WriteFile.Directory
容器
字段
sub_path: String
src_path: LazyPath.Index
exclude_extensions: OptionalStringList
include_extensions: OptionalStringList
std.Build.Configuration.Step.WriteFile.Embed
容器
字段
std.Build.Configuration.Step.WriteFile.Flags
容器
字段
std.Build.Configuration.Step.WriteFile.Mode
容器
字段
whole_cached
tmp
mutate
std.Build.Configuration.Storage
容器
字段
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
函数
pub fn data(buffer: []const u32, i: *usize, comptime T: type) T
参数
buffer: []const u32
i: *usize
T: type
std.Build.Configuration.Storage.dataField
函数
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
函数
pub fn dataLength(buffer: []const u32, i: usize, comptime S: type) usize
参数
buffer: []const u32
i: usize
S: type
std.Build.Configuration.Storage.EnumOptional
类型函数
当 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
常量
std.Build.Configuration.Storage.EnumOptional.flags
常量
std.Build.Configuration.Storage.EnumOptional.storage
常量
Storage
std.Build.Configuration.Storage.EnumOptional.tag
常量
std.Build.Configuration.Storage.EnumOptional.Value
常量
std.Build.Configuration.Storage.Extended
类型函数
该字段是辅助缓冲区中的索引,其首元素 是包含标签的打包结构体。
pub fn Extended(comptime BaseFlags: type, comptime U: type) type
参数
BaseFlags: type
U: type
字段
_
std.Build.Configuration.Storage.Extended.cast
函数
pub fn cast(this: @This(), c: *const Configuration, comptime S: type) ?S
参数
std.Build.Configuration.Storage.Extended.get
函数
pub fn get(this: @This(), buffer: []const u32) U
参数
this: @This()
buffer: []const u32
std.Build.Configuration.Storage.Extended.storage
常量
Storage
std.Build.Configuration.Storage.Extended.tag
函数
pub fn tag(this: @This(), c: *const Configuration) @FieldType(BaseFlags, "tag")
参数
this: @This()
c: *const Configuration
std.Build.Configuration.Storage.extraFieldLen
函数
fn extraFieldLen(field: anytype) usize
std.Build.Configuration.Storage.extraLen
函数
fn extraLen(extra: anytype) usize
std.Build.Configuration.Storage.FlagLengthPrefixedList
类型函数
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
常量
std.Build.Configuration.Storage.FlagLengthPrefixedList.flag
常量
std.Build.Configuration.Storage.FlagLengthPrefixedList.flags
常量
std.Build.Configuration.Storage.FlagLengthPrefixedList.initErased
函数
pub fn initErased(s: []const u32) @This()
参数
s: []const u32
std.Build.Configuration.Storage.FlagLengthPrefixedList.storage
常量
Storage
std.Build.Configuration.Storage.FlagList
类型函数
此字段为列表,长度是 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
常量
std.Build.Configuration.Storage.FlagList.flag
常量
std.Build.Configuration.Storage.FlagList.flags
常量
std.Build.Configuration.Storage.FlagList.initErased
函数
pub fn initErased(s: []const u32) @This()
参数
s: []const u32
std.Build.Configuration.Storage.FlagList.storage
常量
Storage
std.Build.Configuration.Storage.FlagOptional
类型函数
字段是否存在由紧凑结构体中的 一个布尔值决定。
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
常量
std.Build.Configuration.Storage.FlagOptional.flags
常量
std.Build.Configuration.Storage.FlagOptional.storage
常量
Storage
std.Build.Configuration.Storage.FlagOptional.Value
常量
std.Build.Configuration.Storage.FlagUnion
类型函数
字段类型由紧凑结构体中的枚举决定。
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
常量
std.Build.Configuration.Storage.FlagUnion.flags
常量
std.Build.Configuration.Storage.FlagUnion.storage
常量
Storage
std.Build.Configuration.Storage.FlagUnion.Tag
常量
std.Build.Configuration.Storage.FlagUnion.Union
常量
std.Build.Configuration.Storage.LengthPrefixedList
类型函数
字段包含一个 u32 长度,后跟相应数量的元素。 每个元素必须具有明确定义的内存布局,此外其大小 可为任意个 u32 的整数倍。长度是元素数量, 而不是 u32 的数量。
pub fn LengthPrefixedList(comptime ElemArg: type) type
参数
ElemArg: type
字段
slice: []const Elem
std.Build.Configuration.Storage.LengthPrefixedList.Elem
常量
std.Build.Configuration.Storage.LengthPrefixedList.initErased
函数
pub fn initErased(s: []const u32) @This()
参数
s: []const u32
std.Build.Configuration.Storage.LengthPrefixedList.storage
常量
Storage
std.Build.Configuration.Storage.MultiList
类型函数
字段包含 u32 长度,其后先跟该数量的第一个字段元素, 再跟该数量的第二个字段元素,依此类推。
pub fn MultiList(comptime ElemArg: type) type
参数
ElemArg: type
字段
mal: std.MultiArrayList(Elem)
std.Build.Configuration.Storage.MultiList.Elem
常量
std.Build.Configuration.Storage.MultiList.storage
常量
Storage
std.Build.Configuration.Storage.setExtra
函数
返回新的结束索引。
fn setExtra(buffer: []u32, index: usize, extra: anytype) usize
参数
buffer: []u32
index: usize
std.Build.Configuration.Storage.setExtraField
函数
inline fn setExtraField(buffer: []u32, i: usize, comptime Field: type, value: anytype) usize
参数
buffer: []u32
i: usize
Field: type
std.Build.Configuration.Storage.UnionList
类型函数
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
函数
fn extraLen(len: usize) usize
参数
len: usize
std.Build.Configuration.Storage.UnionList.flag
常量
std.Build.Configuration.Storage.UnionList.flags
常量
std.Build.Configuration.Storage.UnionList.get
函数
仅在反序列化时允许调用。
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
函数
仅在序列化时调用才有效。
pub fn init(s: []const Union) @This()
参数
s: []const Union
std.Build.Configuration.Storage.UnionList.Meta
容器
字段
tag: Tag
last: bool
std.Build.Configuration.Storage.UnionList.MetaInt
常量
std.Build.Configuration.Storage.UnionList.slice
函数
仅在反序列化时允许调用。
pub fn slice(this: *const @This(), extra: []const u32) []const u32
参数
this: *const @This()
extra: []const u32
std.Build.Configuration.Storage.UnionList.storage
常量
Storage
std.Build.Configuration.Storage.UnionList.tag
函数
仅在反序列化时允许调用。
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
常量
std.Build.Configuration.Storage.UnionList.Union
常量
std.Build.Configuration.storeBits
函数
当 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
容器
指向 string_bytes 内部,以空字符终止。
字段
empty = 0
root = 1字符串 "root"。
_
std.Build.Configuration.String.slice
函数
pub fn slice(index: String, c: *const Configuration) [:0]const u8
参数
index: String
c: *const Configuration
std.Build.Configuration.StringList
容器
字段
_
std.Build.Configuration.StringList.slice
函数
pub fn slice(this: @This(), c: *const Configuration) []const String
参数
this: @This()
c: *const Configuration
std.Build.Configuration.SystemIntegration
容器
字段
std.Build.Configuration.SystemIntegration.Status
容器
字段
disabled = 0
enabled = 1
std.Build.Configuration.SystemLib
容器
字段
std.Build.Configuration.SystemLib.Flags
容器
字段
needed: bool
weak: bool
use_pkg_config: UsePkgConfig
preferred_link_mode: LinkMode
search_strategy: SearchStrategy
_: u25 = 0
std.Build.Configuration.SystemLib.Index
类型
std.Build.Configuration.SystemLib.LinkMode
别名
别名目标 std.lang.LinkMode
std.Build.Configuration.SystemLib.SearchStrategy
容器
字段
paths_first
mode_first
no_fallback
std.Build.Configuration.SystemLib.UsePkgConfig
容器
字段
no不使用 pkg-config,仅传入 -lfoo,其中 foo 为名称。
yes尝试从 pkg-config 获取库链接信息。 若失败,则退回传递 -lfoo,其中 foo 为 name。
force尝试从 pkg-config 获取库链接方式的信息。 失败则返回错误。
std.Build.Configuration.TargetQuery
容器
字段
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
容器
字段
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
函数
pub fn init(x: ?std.Target.Abi) @This()
参数
std.Build.Configuration.TargetQuery.Abi.unwrap
函数
pub fn unwrap(this: @This()) ?std.Target.Abi
参数
this: @This()
std.Build.Configuration.TargetQuery.CpuArch
容器
字段
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
函数
pub fn init(x: ?std.Target.Cpu.Arch) @This()
参数
std.Build.Configuration.TargetQuery.CpuArch.unwrap
函数
pub fn unwrap(this: @This()) ?std.Target.Cpu.Arch
参数
this: @This()
std.Build.Configuration.TargetQuery.CpuModel
容器
字段
native
baseline
determined_by_arch_os
explicit
std.Build.Configuration.TargetQuery.CpuModel.init
函数
pub fn init(x: std.Target.Query.CpuModel) @This()
参数
std.Build.Configuration.TargetQuery.Flags
容器
字段
std.Build.Configuration.TargetQuery.Index
容器
字段
_
std.Build.Configuration.TargetQuery.Index.extraSlice
函数
pub fn extraSlice(i: Index, extra: []const u32) []const u32
参数
i: Index
extra: []const u32
std.Build.Configuration.TargetQuery.Index.get
函数
pub fn get(this: @This(), c: *const Configuration) TargetQuery
参数
this: @This()
c: *const Configuration
std.Build.Configuration.TargetQuery.Index.length
函数
pub fn length(i: Index, extra: []const u32) usize
参数
i: Index
extra: []const u32
std.Build.Configuration.TargetQuery.ObjectFormat
容器
字段
c
coff
elf
hex
macho
plan9
raw
spirv
wasm
default
std.Build.Configuration.TargetQuery.ObjectFormat.init
函数
pub fn init(x: ?std.Target.ObjectFormat) @This()
参数
x: ?std.Target.ObjectFormat
std.Build.Configuration.TargetQuery.ObjectFormat.unwrap
函数
pub fn unwrap(this: @This()) ?std.Target.ObjectFormat
参数
this: @This()
std.Build.Configuration.TargetQuery.OptionalIndex
容器
字段
none = max_u32
_
std.Build.Configuration.TargetQuery.OptionalIndex.get
函数
pub fn get(this: @This(), c: *const Configuration) ?TargetQuery
参数
this: @This()
c: *const Configuration
std.Build.Configuration.TargetQuery.OptionalIndex.init
函数
pub fn init(i: Index) OptionalIndex
参数
i: Index
std.Build.Configuration.TargetQuery.OptionalIndex.unwrap
函数
pub fn unwrap(this: @This()) ?Index
参数
this: @This()
std.Build.Configuration.TargetQuery.OsTag
容器
字段
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
函数
pub fn init(x: ?std.Target.Os.Tag) @This()
参数
std.Build.Configuration.TargetQuery.OsTag.unwrap
函数
pub fn unwrap(this: @This()) ?std.Target.Os.Tag
参数
this: @This()
std.Build.Configuration.TargetQuery.OsVersion
容器
字段
std.Build.Configuration.TargetQuery.OsVersion.Tag
容器
字段
none
semver
windows
default
std.Build.Configuration.TargetQuery.OsVersion.unwrap
函数
pub fn unwrap(this: @This(), c: *const Configuration) ?std.Target.Query.OsVersion
参数
this: @This()
c: *const Configuration
std.Build.Configuration.TargetQuery.unwrapTarget
函数
pub fn unwrapTarget(tq: *const TargetQuery, c: *const Configuration) std.Target
参数
tq: *const TargetQuery
c: *const Configuration
std.Build.Configuration.Wip
容器
字段
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
DedupeTableTargetsTableExtraSliceTargetsTableContextStringTableStringTableContextStringTableIndexAdapterinitdeinitStaticwriteaddStringaddOptionalStringaddStringListaddBytesaddSemVeraddTargetQueryaddTargetaddExtraaddExtraErasedaddDedupedaddExtraReservedaddExtraReservedErasedaddExtraOptionalStringAssumeCapacityaddGeneratedFilestringSlice
std.Build.Configuration.Wip.addBytes
函数
pub fn addBytes(wip: *Wip, bytes: []const u8) Allocator.Error!Bytes
参数
wip: *Wip
bytes: []const u8
错误
- OutOfMemory
std.Build.Configuration.Wip.addDeduped
函数
类似 addExtra,但使用哈希表,可能返回已有索引,
而非追加到 extra。
pub fn addDeduped(wip: *Wip, comptime T: type, v: T) Allocator.Error!T.Index
参数
错误
- OutOfMemory
std.Build.Configuration.Wip.addExtra
函数
pub fn addExtra(wip: *Wip, comptime T: type, v: T) Allocator.Error!T.Index
参数
错误
- OutOfMemory
std.Build.Configuration.Wip.addExtraErased
函数
pub fn addExtraErased(wip: *Wip, comptime T: type, v: T) Allocator.Error!u32
参数
错误
- OutOfMemory
std.Build.Configuration.Wip.addExtraOptionalStringAssumeCapacity
函数
fn addExtraOptionalStringAssumeCapacity(wip: *Wip, optional_string: ?String) void
参数
std.Build.Configuration.Wip.addExtraReserved
函数
pub fn addExtraReserved(wip: *Wip, comptime T: type, v: T) T.Index
参数
std.Build.Configuration.Wip.addExtraReservedErased
函数
pub fn addExtraReservedErased(wip: *Wip, comptime T: type, v: T) u32
参数
std.Build.Configuration.Wip.addGeneratedFile
函数
pub fn addGeneratedFile(wip: *Wip) GeneratedFileIndex
参数
wip: *Wip
std.Build.Configuration.Wip.addOptionalString
函数
pub fn addOptionalString(wip: *Wip, bytes: ?[]const u8) Allocator.Error!OptionalString
参数
wip: *Wip
bytes: ?[]const u8
错误
- OutOfMemory
std.Build.Configuration.Wip.addSemVer
函数
pub fn addSemVer(wip: *Wip, sv: std.SemanticVersion) Allocator.Error!String
参数
wip: *Wip
sv: std.SemanticVersion
错误
- OutOfMemory
std.Build.Configuration.Wip.addString
函数
pub fn addString(wip: *Wip, bytes: []const u8) Allocator.Error!String
参数
wip: *Wip
bytes: []const u8
错误
- OutOfMemory
std.Build.Configuration.Wip.addStringList
函数
pub fn addStringList(wip: *Wip, list: []const []const u8) Allocator.Error!StringList
参数
wip: *Wip
list: []const []const u8
错误
- OutOfMemory
std.Build.Configuration.Wip.addTarget
函数
pub fn addTarget(wip: *Wip, t: std.Target) !TargetQuery.Index
参数
std.Build.Configuration.Wip.addTargetQuery
函数
pub fn addTargetQuery(wip: *Wip, q: *const std.Target.Query) !TargetQuery.OptionalIndex
参数
std.Build.Configuration.Wip.DedupeTable
类型
std.Build.Configuration.Wip.deinit
函数
pub fn deinit(wip: *Wip) void
参数
wip: *Wip
std.Build.Configuration.Wip.ExtraSlice
容器
字段
index: u32
len: u32
std.Build.Configuration.Wip.ExtraSlice.Context
容器
字段
extra: []const u32
std.Build.Configuration.Wip.ExtraSlice.Context.eql
函数
pub fn eql(ctx: @This(), a: ExtraSlice, b: ExtraSlice) bool
参数
std.Build.Configuration.Wip.ExtraSlice.Context.hash
函数
pub fn hash(ctx: @This(), key: ExtraSlice) u64
参数
ctx: @This()
key: ExtraSlice
std.Build.Configuration.Wip.init
函数
pub fn init(gpa: Allocator) Wip
参数
gpa: Allocator
std.Build.Configuration.Wip.Static
容器
字段
std.Build.Configuration.Wip.stringSlice
函数
下一次向配置追加内容时,返回的切片失效。
pub fn stringSlice(wip: *const Wip, s: String) [:0]const u8
参数
std.Build.Configuration.Wip.StringTable
类型
std.Build.Configuration.Wip.StringTableContext
容器
字段
bytes: []const u8
std.Build.Configuration.Wip.StringTableContext.eql
函数
pub fn eql(_: @This(), a: String, b: String) bool
参数
std.Build.Configuration.Wip.StringTableContext.hash
函数
pub fn hash(ctx: @This(), key: String) u64
参数
ctx: @This()
key: String
std.Build.Configuration.Wip.StringTableIndexAdapter
容器
字段
bytes: []const u8
std.Build.Configuration.Wip.StringTableIndexAdapter.eql
函数
pub fn eql(ctx: @This(), a: []const u8, b: String) bool
参数
std.Build.Configuration.Wip.StringTableIndexAdapter.hash
函数
pub fn hash(_: @This(), adapted_key: []const u8) u64
参数
_: @This()
adapted_key: []const u8
std.Build.Configuration.Wip.TargetsTable
类型
std.Build.Configuration.Wip.TargetsTableContext
容器
字段
extra: []const u32
std.Build.Configuration.Wip.TargetsTableContext.eql
函数
pub fn eql(ctx: @This(), a: TargetQuery.Index, b: TargetQuery.Index) bool
参数
std.Build.Configuration.Wip.TargetsTableContext.hash
函数
pub fn hash(ctx: @This(), key: TargetQuery.Index) u64
参数
ctx: @This()
key: TargetQuery.Index
std.Build.Configuration.Wip.write
函数
pub fn write(wip: *Wip, w: *Io.Writer, static: Static) Io.Writer.Error!void
参数
错误
- 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;
};
}
}
}