srctree

\\syscall

// Next is the output. It is possible in the future Zig will

// support multiple outputs, depending on how

// https://github.com/ziglang/zig/issues/215 is resolved.

// It is allowed for there to be no outputs, in which case

// this colon would be directly followed by the colon for the inputs.

// This specifies the name to be used in `%[ret]` syntax in

// the above assembly string. This example does not use it,

// but the syntax is mandatory.

[ret]

// Next is the output constraint string. This feature is still

// considered unstable in Zig, and so LLVM/GCC documentation

// must be used to understand the semantics.

// http://releases.llvm.org/10.0.0/docs/LangRef.html#inline-asm-constraint-string

// https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html

// In this example, the constraint string means "the result value of

// this inline assembly instruction is whatever is in $rax".

"={rax}"

// Next is either a value binding, or `->` and then a type. The

// type is the result type of the inline assembly expression.

// If it is a value binding, then `%[ret]` syntax would be used

// to refer to the register bound to the value.

(-> usize),

// Next is the list of inputs.

// The constraint for these inputs means, "when the assembly code is

// executed, $rax shall have the value of `number` and $rdi shall have

// the value of `arg1`". Any number of input parameters is allowed,

// including none.

[arg1] "{rdi}" (arg1),

// Next is the list of clobbers. These declare a set of registers whose

// values will not be preserved by the execution of this assembly code.

// These do not include output or input registers. The special clobber

// value of "memory" means that the assembly writes to arbitrary undeclared

// memory locations - not only the memory pointed to by a declared indirect

// output. In this example we list $rcx and $r11 because it is known the

// kernel syscall does not preserve these registers.

.root_source_file = b.path("example.zig"),

.root_source_file = b.path("mathtest.zig"),

exe.addCSourceFile(.{ .file = b.path("test.c"), .flags = &.{"-std=c99"} });

.root_source_file = b.path("base64.zig"),

exe.addCSourceFile(.{ .file = b.path("test.c"), .flags = &.{"-std=c99"} });

const Foo = struct {};

fn doSomethingWithFoo(foo: *Foo) void {

_ = foo;

}

doSomethingWithFoo(foo);

seconds: i64, // signed so we can represent pre-1970 (not a doc comment)

export fn entry(foo: Foo) void {

_ = foo;

}

export fn entry(foo: Foo) void {

_ = foo;

}

'0'...'9' => c - '0',

'A'...'Z' => c - 'A' + 10,

'a'...'z' => c - 'a' + 10,

red,

@"really red",

print("here is a string: '{s}' here is a number: {}\n", .{ a_string, a_number });

print(fmt, .{ a_string, a_number });

const err = (error{FileNotFound}).FileNotFound;

print("{}\n", .{@TypeOf(bytes)}); // *const [5:0]u8

print("{d}\n", .{bytes.len}); // 5

print("{c}\n", .{bytes[1]}); // 'e'

print("{d}\n", .{bytes[5]}); // 0

print("{}\n", .{'e' == '\x65'}); // true

print("{d}\n", .{'\u{1f4a9}'}); // 128169

print("{d}\n", .{'💯'}); // 128175

print("{}\n", .{mem.eql(u8, "hello", "h\x65llo")}); // true

const invalid_utf8 = "\xff\xfe"; // non-UTF-8 strings are possible with \xNN notation.

print("0x{x}\n", .{"💯"[1]}); // ...as does indexing part-way through non-ASCII characters

try expect(@call(.auto, add, .{ 3, 9 }) == 12);

const FileOpenError = error{

const AllocationError = error{

const FileOpenError = error{

const AllocationError = error{

const Tuple = struct { u8, u8 };

const tuple: Tuple = .{ 5, 6 };

const array: [2]u8 = tuple;

_ = array;

func: fn (i32) i32,

CmdFn{ .name = "one", .func = one },

CmdFn{ .name = "two", .func = two },

CmdFn{ .name = "three", .func = three },

fn one(value: i32) i32 {

return value + 1;

}

fn two(value: i32) i32 {

return value + 2;

}

fn three(value: i32) i32 {

return value + 3;

}

const Foo = struct { data: *u32 };

const Foo = struct { data: *u32 };

if (i >= 3) return error.TooManyFoos;

const items = [_]i32{ 4, 5, 3, 4, 0 };

var sum3: usize = 0;

export fn sub(a: i8, b: i8) i8 {

return a - b;

}

inline fn shiftLeftOne(a: u32) u32 {

pub fn sub2(a: i8, b: i8) i8 {

return a - b;

}

const Error = error{

const nums = [_]i32{ 2, 4, 6 };

},

const array = [_:0]u8{ 1, 2, 3, 4 };

const array = [_:0]u8{ 1, 0, 0, 4 };

const Point = struct { x: i32, y: i32 };

const p = Point{

var p2 = Point{

return Vec3{

const does_nothing = Empty{};

var point = Point{

last: ?*Node,

len: usize,

.two, .three => false,

const result = max(if (condition) f32 else u64, 1234, 5678);

while (i * j < 2000) : ({

i *= 2;

j *= 3;

}) {

@TypeOf(number_or_error),

number_or_error,

});

const File = fs.File;

pub fn hash(ctx: @This(), k: InitializedDepKey) u64 {

hashUserInputOptionsMap(ctx.allocator, k.user_input_options, &hasher);

pub fn eql(_: @This(), lhs: InitializedDepKey, rhs: InitializedDepKey) bool {

pub const base_id: Step.Id = .top_level;

const b = try arena.create(Build);

b.* = .{

.id = TopLevelStep.base_id,

.owner = b,

.id = TopLevelStep.base_id,

.owner = b,

try b.top_level_steps.put(arena, b.install_tls.step.name, &b.install_tls);

try b.top_level_steps.put(arena, b.uninstall_tls.step.name, &b.uninstall_tls);

b.default_step = &b.install_tls.step;

return b;

.id = TopLevelStep.base_id,

.id = TopLevelStep.base_id,

fn hash(val: OrderedUserValue, hasher: *std.hash.Wyhash) void {

switch (val) {

fn hash(opt: OrderedUserInputOption, hasher: *std.hash.Wyhash) void {

hasher.update(opt.name);

opt.value.hash(hasher);

pub fn resolveInstallPrefix(b: *Build, install_prefix: ?[]const u8, dir_list: DirList) void {

if (b.dest_dir) |dest_dir| {

b.install_prefix = install_prefix orelse "/usr";

b.install_path = b.pathJoin(&.{ dest_dir, b.install_prefix });

b.install_prefix = install_prefix orelse

(b.build_root.join(b.allocator, &.{"zig-out"}) catch @panic("unhandled error"));

b.install_path = b.install_prefix;

var lib_list = [_][]const u8{ b.install_path, "lib" };

var exe_list = [_][]const u8{ b.install_path, "bin" };

var h_list = [_][]const u8{ b.install_path, "include" };

if (fs.path.isAbsolute(dir)) lib_list[0] = b.dest_dir orelse "";

if (fs.path.isAbsolute(dir)) exe_list[0] = b.dest_dir orelse "";

if (fs.path.isAbsolute(dir)) h_list[0] = b.dest_dir orelse "";

b.lib_dir = b.pathJoin(&lib_list);

b.exe_dir = b.pathJoin(&exe_list);

b.h_dir = b.pathJoin(&h_list);

pub fn addOptions(b: *Build) *Step.Options {

return Step.Options.create(b);

pub fn addSystemCommand(b: *Build, argv: []const []const u8) *Step.Run {

const run_step = Step.Run.create(b, b.fmt("run {s}", .{argv[0]}));

pub fn dupe(b: *Build, bytes: []const u8) []u8 {

return b.allocator.dupe(u8, bytes) catch @panic("OOM");

pub fn dupeStrings(b: *Build, strings: []const []const u8) [][]u8 {

const array = b.allocator.alloc([]u8, strings.len) catch @panic("OOM");

for (array, strings) |*dest, source| dest.* = b.dupe(source);

pub fn dupePath(b: *Build, bytes: []const u8) []u8 {

const the_copy = b.dupe(bytes);

pub fn addWriteFile(b: *Build, file_path: []const u8, data: []const u8) *Step.WriteFile {

const write_file_step = b.addWriteFiles();

pub fn addRemoveDirTree(b: *Build, dir_path: []const u8) *Step.RemoveDir {

return Step.RemoveDir.create(b, dir_path);

pub fn addTranslateC(b: *Build, options: Step.TranslateC.Options) *Step.TranslateC {

return Step.TranslateC.create(b, options);

pub fn getInstallStep(b: *Build) *Step {

return &b.install_tls.step;

pub fn getUninstallStep(b: *Build) *Step {

return &b.uninstall_tls.step;

const b: *Build = @fieldParentPtr("uninstall_tls", uninstall_tls);

for (b.installed_files.items) |installed_file| {

const full_path = b.getInstallPath(installed_file.dir, installed_file.path);

if (b.verbose) {

pub fn option(b: *Build, comptime T: type, name_raw: []const u8, description_raw: []const u8) ?T {

const name = b.dupe(name_raw);

const description = b.dupe(description_raw);

var options = ArrayList([]const u8).initCapacity(b.allocator, fields.len) catch @panic("OOM");

if ((b.available_options_map.fetchPut(name, available_option) catch @panic("OOM")) != null) {

b.available_options_list.append(available_option) catch @panic("OOM");

const option_ptr = b.user_input_options.getPtr(name) orelse return null;

b.markInvalidUserInput();

b.markInvalidUserInput();

b.markInvalidUserInput();

b.markInvalidUserInput();

b.markInvalidUserInput();

b.markInvalidUserInput();

b.markInvalidUserInput();

b.markInvalidUserInput();

b.markInvalidUserInput();

b.markInvalidUserInput();

b.markInvalidUserInput();

b.markInvalidUserInput();

b.markInvalidUserInput();

return b.allocator.dupe([]const u8, &[_][]const u8{s}) catch @panic("OOM");

pub fn step(b: *Build, name: []const u8, description: []const u8) *Step {

const step_info = b.allocator.create(TopLevelStep) catch @panic("OOM");

.id = TopLevelStep.base_id,

.owner = b,

.description = b.dupe(description),

const gop = b.top_level_steps.getOrPut(b.allocator, name) catch @panic("OOM");

pub fn addUserInputOption(b: *Build, name_raw: []const u8, value_raw: []const u8) !bool {

const name = b.dupe(name_raw);

const value = b.dupe(value_raw);

const gop = try b.user_input_options.getOrPut(name);

var list = ArrayList([]const u8).init(b.allocator);

try b.user_input_options.put(name, .{

try b.user_input_options.put(name, .{

pub fn addUserInputFlag(b: *Build, name_raw: []const u8) !bool {

const name = b.dupe(name_raw);

const gop = try b.user_input_options.getOrPut(name);

fn markInvalidUserInput(b: *Build) void {

b.invalid_user_input = true;

pub fn installArtifact(b: *Build, artifact: *Step.Compile) void {

b.getInstallStep().dependOn(&b.addInstallArtifact(artifact, .{}).step);

b: *Build,

return Step.InstallArtifact.create(b, artifact, options);

b: *Build,

return Step.InstallFile.create(b, source, install_dir, dest_rel_path);

pub fn addInstallDirectory(b: *Build, options: Step.InstallDir.Options) *Step.InstallDir {

return Step.InstallDir.create(b, options);

pub fn pushInstalledFile(b: *Build, dir: InstallDir, dest_rel_path: []const u8) void {

b.installed_files.append(file.dupe(b)) catch @panic("OOM");

pub fn truncateFile(b: *Build, dest_path: []const u8) !void {

if (b.verbose) {

pub fn pathFromRoot(b: *Build, sub_path: []const u8) []u8 {

return b.pathResolve(&.{ b.build_root.path orelse ".", sub_path });

fn pathFromCwd(b: *Build, sub_path: []const u8) []u8 {

return b.pathResolve(&.{ cwd, sub_path });

pub fn pathJoin(b: *Build, paths: []const []const u8) []u8 {

return fs.path.join(b.allocator, paths) catch @panic("OOM");

pub fn pathResolve(b: *Build, paths: []const []const u8) []u8 {

return fs.path.resolve(b.allocator, paths) catch @panic("OOM");

pub fn fmt(b: *Build, comptime format: []const u8, args: anytype) []u8 {

return std.fmt.allocPrint(b.allocator, format, args) catch @panic("OOM");

}

 

pub fn findProgram(b: *Build, names: []const []const u8, paths: []const []const u8) ![]const u8 {

const exe_extension = b.host.result.exeFileExt();

for (b.search_prefixes.items) |search_prefix| {

const full_path = b.pathJoin(&.{

b.fmt("{s}{s}", .{ name, exe_extension }),

return fs.realpathAlloc(b.allocator, full_path) catch continue;

if (b.graph.env_map.get("PATH")) |PATH| {

const full_path = b.pathJoin(&.{

p, b.fmt("{s}{s}", .{ name, exe_extension }),

return fs.realpathAlloc(b.allocator, full_path) catch continue;

const full_path = b.pathJoin(&.{

p, b.fmt("{s}{s}", .{ name, exe_extension }),

return fs.realpathAlloc(b.allocator, full_path) catch continue;

b: *Build,

var child = std.ChildProcess.init(argv, b.allocator);

child.env_map = &b.graph.env_map;

const stdout = child.stdout.?.reader().readAllAlloc(b.allocator, max_output_size) catch {

errdefer b.allocator.free(stdout);

pub fn getInstallPath(b: *Build, dir: InstallDir, dest_rel_path: []const u8) []const u8 {

.prefix => b.install_path,

.bin => b.exe_dir,

.lib => b.lib_dir,

.header => b.h_dir,

.custom => |p| b.pathJoin(&.{ b.install_path, p }),

return b.pathResolve(&.{ base_dir, dest_rel_path });

pub fn getPath(gen: GeneratedFile) []const u8 {

return gen.step.owner.pathFromRoot(gen.path orelse std.debug.panic(

.{gen.step.name},

));

generated: struct {

file: *const GeneratedFile,

/// 0 means the generated file itself.

/// 1 means the directory of the generated file.

/// 2 means the parent of that directory, and so on.

up: usize = 0,

 

/// Applied after `up`.

sub_path: []const u8 = "",

pub fn dirname(lazy_path: LazyPath) LazyPath {

return switch (lazy_path) {

.generated => |generated| .{ .generated = if (dirnameAllowEmpty(generated.sub_path)) |sub_dirname| .{

.file = generated.file,

.up = generated.up,

.sub_path = sub_dirname,

} else .{

.file = generated.file,

.up = generated.up + 1,

.sub_path = "",

} },

.cwd_relative => |rel_path| .{

.cwd_relative = dirnameAllowEmpty(rel_path) orelse {

// - rel_path was absolute, and is now root

// - rel_path was relative, and is now ""

if (fs.path.isAbsolute(rel_path)) {

pub fn path(lazy_path: LazyPath, b: *Build, sub_path: []const u8) LazyPath {

return switch (lazy_path) {

.src_path => |src| .{ .src_path = .{

.owner = src.owner,

.sub_path = b.pathResolve(&.{ src.sub_path, sub_path }),

} },

.generated => |gen| .{ .generated = .{

.file = gen.file,

.up = gen.up,

.sub_path = b.pathResolve(&.{ gen.sub_path, sub_path }),

} },

.cwd_relative => |cwd_relative| .{

.cwd_relative = b.pathResolve(&.{ cwd_relative, sub_path }),

},

.dependency => |dep| .{ .dependency = .{

.dependency = dep.dependency,

.sub_path = b.pathResolve(&.{ dep.sub_path, sub_path }),

} },

};

}

 

/// Either returns the path, `"generated"`, or `"dependency"`.

pub fn getDisplayName(lazy_path: LazyPath) []const u8 {

return switch (lazy_path) {

.cwd_relative => |p| p,

pub fn addStepDependencies(lazy_path: LazyPath, other_step: *Step) void {

switch (lazy_path) {

.src_path, .cwd_relative, .dependency => {},

.generated => |gen| other_step.dependOn(gen.file.step),

pub fn getPath(lazy_path: LazyPath, src_builder: *Build) []const u8 {

return getPath2(lazy_path, src_builder, null);

pub fn getPath2(lazy_path: LazyPath, src_builder: *Build, asking_step: ?*Step) []const u8 {

switch (lazy_path) {

.generated => |gen| {

var file_path: []const u8 = gen.file.step.owner.pathFromRoot(gen.file.path orelse {

std.debug.getStderrMutex().lock();

const stderr = std.io.getStdErr();

dumpBadGetPathHelp(gen.file.step, stderr, src_builder, asking_step) catch {};

std.debug.getStderrMutex().unlock();

@panic("misconfigured build script");

});

if (gen.up > 0) {

const cache_root_path = src_builder.cache_root.path orelse

(src_builder.cache_root.join(src_builder.allocator, &.{"."}) catch @panic("OOM"));

for (0..gen.up) |_| {

if (mem.eql(u8, file_path, cache_root_path)) {

// If we hit the cache root and there's still more to go,

// the script attempted to go too far.

dumpBadDirnameHelp(gen.file.step, asking_step,

\\dirname() attempted to traverse outside the cache root.

\\This is not allowed.

\\

, .{}) catch {};

@panic("misconfigured build script");

}

 

// path is absolute.

// dirname will return null only if we're at root.

// Typically, we'll stop well before that at the cache root.

file_path = fs.path.dirname(file_path) orelse {

dumpBadDirnameHelp(gen.file.step, asking_step,

\\dirname() reached root.

\\No more directories left to go up.

\\

, .{}) catch {};

@panic("misconfigured build script");

};

 

return src_builder.pathResolve(&.{ file_path, gen.sub_path });

.dependency => |dep| return dep.dependency.builder.pathFromRoot(dep.sub_path),

pub fn dupe(lazy_path: LazyPath, b: *Build) LazyPath {

return switch (lazy_path) {

.generated => |gen| .{ .generated = .{

.file = gen.file,

.up = gen.up,

.sub_path = b.dupePath(gen.sub_path),

} },

pub fn dupe(dir: InstallDir, builder: *Build) InstallDir {

if (dir == .custom) {

return .{ .custom = builder.dupe(dir.custom) };

return dir;

pub fn dupe(file: InstalledFile, builder: *Build) InstalledFile {

.dir = file.dir.dupe(builder),

.path = builder.dupe(file.path),

pub fn dupe(file: CSourceFile, b: *std.Build) CSourceFile {

.file = file.file.dupe(b),

.flags = b.dupeStrings(file.flags),

pub fn dupe(file: RcSourceFile, b: *std.Build) RcSourceFile {

const include_paths = b.allocator.alloc(LazyPath, file.include_paths.len) catch @panic("OOM");

for (include_paths, file.include_paths) |*dest, lazy_path| dest.* = lazy_path.dupe(b);

.file = file.file.dupe(b),

.flags = b.dupeStrings(file.flags),

try zig_args.appendSlice(&.{ "-I", include_path.getPath2(b, asking_step) });

try zig_args.appendSlice(&.{ "-isystem", include_path.getPath2(b, asking_step) });

try zig_args.appendSlice(&.{ "-idirafter", include_path.getPath2(b, asking_step) });

try zig_args.appendSlice(&.{ "-F", include_path.getPath2(b, asking_step) });

try zig_args.appendSlice(&.{ "-iframework", include_path.getPath2(b, asking_step) });

pub const MakeFn = *const fn (step: *Step, prog_node: *std.Progress.Node) anyerror!void;

pub fn dependOn(step: *Step, other: *Step) void {

step.dependencies.append(other) catch @panic("OOM");

pub const base_id: Step.Id = .check_file;

const check_file = owner.allocator.create(CheckFile) catch @panic("OOM");

check_file.* = .{

.id = base_id,

check_file.source.addStepDependencies(&check_file.step);

return check_file;

pub fn setName(check_file: *CheckFile, name: []const u8) void {

check_file.step.name = name;

const check_file: *CheckFile = @fieldParentPtr("step", step);

const src_path = check_file.source.getPath2(b, step);

const contents = fs.cwd().readFileAlloc(b.allocator, src_path, check_file.max_bytes) catch |err| {

for (check_file.expected_matches) |expected_match| {

if (check_file.expected_exact) |expected_exact| {

pub const base_id: Step.Id = .check_object;

const check_object = gpa.create(CheckObject) catch @panic("OOM");

check_object.* = .{

.id = base_id,

check_object.source.addStepDependencies(&check_object.step);

return check_object;

fn extract(check: *Check, phrase: SearchPhrase) void {

check.actions.append(.{

fn exact(check: *Check, phrase: SearchPhrase) void {

check.actions.append(.{

fn contains(check: *Check, phrase: SearchPhrase) void {

check.actions.append(.{

fn notPresent(check: *Check, phrase: SearchPhrase) void {

check.actions.append(.{

fn computeCmp(check: *Check, phrase: SearchPhrase, expected: ComputeCompareExpected) void {

check.actions.append(.{

fn checkStart(check_object: *CheckObject, kind: Check.Kind) void {

const check = Check.create(check_object.step.owner.allocator, kind);

check_object.checks.append(check) catch @panic("OOM");

pub fn checkExact(check_object: *CheckObject, phrase: []const u8) void {

check_object.checkExactInner(phrase, null);

pub fn checkExactPath(check_object: *CheckObject, phrase: []const u8, lazy_path: std.Build.LazyPath) void {

check_object.checkExactInner(phrase, lazy_path);

fn checkExactInner(check_object: *CheckObject, phrase: []const u8, lazy_path: ?std.Build.LazyPath) void {

assert(check_object.checks.items.len > 0);

const last = &check_object.checks.items[check_object.checks.items.len - 1];

last.exact(.{ .string = check_object.step.owner.dupe(phrase), .lazy_path = lazy_path });

pub fn checkContains(check_object: *CheckObject, phrase: []const u8) void {

check_object.checkContainsInner(phrase, null);

check_object: *CheckObject,

check_object.checkContainsInner(phrase, lazy_path);

fn checkContainsInner(check_object: *CheckObject, phrase: []const u8, lazy_path: ?std.Build.LazyPath) void {

assert(check_object.checks.items.len > 0);

const last = &check_object.checks.items[check_object.checks.items.len - 1];

last.contains(.{ .string = check_object.step.owner.dupe(phrase), .lazy_path = lazy_path });

pub fn checkExtract(check_object: *CheckObject, phrase: []const u8) void {

check_object.checkExtractInner(phrase, null);

pub fn checkExtractLazyPath(check_object: *CheckObject, phrase: []const u8, lazy_path: std.Build.LazyPath) void {

check_object.checkExtractInner(phrase, lazy_path);

fn checkExtractInner(check_object: *CheckObject, phrase: []const u8, lazy_path: ?std.Build.LazyPath) void {

assert(check_object.checks.items.len > 0);

const last = &check_object.checks.items[check_object.checks.items.len - 1];

last.extract(.{ .string = check_object.step.owner.dupe(phrase), .lazy_path = lazy_path });

pub fn checkNotPresent(check_object: *CheckObject, phrase: []const u8) void {

check_object.checkNotPresentInner(phrase, null);

pub fn checkNotPresentLazyPath(check_object: *CheckObject, phrase: []const u8, lazy_path: std.Build.LazyPath) void {

check_object.checkNotPresentInner(phrase, lazy_path);

fn checkNotPresentInner(check_object: *CheckObject, phrase: []const u8, lazy_path: ?std.Build.LazyPath) void {

assert(check_object.checks.items.len > 0);

const last = &check_object.checks.items[check_object.checks.items.len - 1];

last.notPresent(.{ .string = check_object.step.owner.dupe(phrase), .lazy_path = lazy_path });

pub fn checkInHeaders(check_object: *CheckObject) void {

check_object.checkStart(.headers);

pub fn checkInSymtab(check_object: *CheckObject) void {

const label = switch (check_object.obj_format) {

check_object.checkStart(.symtab);

check_object.checkExact(label);

pub fn checkInDyldRebase(check_object: *CheckObject) void {

const label = switch (check_object.obj_format) {

check_object.checkStart(.dyld_rebase);

check_object.checkExact(label);

pub fn checkInDyldBind(check_object: *CheckObject) void {

const label = switch (check_object.obj_format) {

check_object.checkStart(.dyld_bind);

check_object.checkExact(label);

pub fn checkInDyldWeakBind(check_object: *CheckObject) void {

const label = switch (check_object.obj_format) {

check_object.checkStart(.dyld_weak_bind);

check_object.checkExact(label);

pub fn checkInDyldLazyBind(check_object: *CheckObject) void {

const label = switch (check_object.obj_format) {

check_object.checkStart(.dyld_lazy_bind);

check_object.checkExact(label);

pub fn checkInExports(check_object: *CheckObject) void {

const label = switch (check_object.obj_format) {

check_object.checkStart(.exports);

check_object.checkExact(label);

pub fn checkInIndirectSymtab(check_object: *CheckObject) void {

const label = switch (check_object.obj_format) {

check_object.checkStart(.indirect_symtab);

check_object.checkExact(label);

pub fn checkInDynamicSymtab(check_object: *CheckObject) void {

const label = switch (check_object.obj_format) {

check_object.checkStart(.dynamic_symtab);

check_object.checkExact(label);

pub fn checkInDynamicSection(check_object: *CheckObject) void {

const label = switch (check_object.obj_format) {

check_object.checkStart(.dynamic_section);

check_object.checkExact(label);

pub fn checkInArchiveSymtab(check_object: *CheckObject) void {

const label = switch (check_object.obj_format) {

check_object.checkStart(.archive_symtab);

check_object.checkExact(label);

pub fn dumpSection(check_object: *CheckObject, name: [:0]const u8) void {

const check = Check.dumpSection(check_object.step.owner.allocator, name);

check_object.checks.append(check) catch @panic("OOM");

check_object: *CheckObject,

var check = Check.create(check_object.step.owner.allocator, .compute_compare);

check.computeCmp(.{ .string = check_object.step.owner.dupe(program) }, expected);

check_object.checks.append(check) catch @panic("OOM");

const check_object: *CheckObject = @fieldParentPtr("step", step);

const src_path = check_object.source.getPath2(b, step);

check_object.max_bytes,

for (check_object.checks.items) |chk| {

const output = switch (check_object.obj_format) {

inline fn rankByTag(@"export": Export) u3 {

return switch (@"export".tag) {

pub fn dupe(file: File, b: *std.Build) File {

.source = file.source.dupe(b),

.dest_rel_path = b.dupePath(file.dest_rel_path),

pub fn dupe(opts: Directory.Options, b: *std.Build) Directory.Options {

.exclude_extensions = b.dupeStrings(opts.exclude_extensions),

.include_extensions = if (opts.include_extensions) |incs| b.dupeStrings(incs) else null,

pub fn dupe(dir: Directory, b: *std.Build) Directory {

.source = dir.source.dupe(b),

.dest_rel_path = b.dupePath(dir.dest_rel_path),

.options = dir.options.dupe(b),

pub fn getSource(installation: HeaderInstallation) LazyPath {

return switch (installation) {

pub fn dupe(installation: HeaderInstallation, b: *std.Build) HeaderInstallation {

return switch (installation) {

const compile = owner.allocator.create(Compile) catch @panic("OOM");

compile.* = .{

compile.root_module.init(owner, options.root_module, compile);

compile.zig_lib_dir = lp.dupe(compile.step.owner);

lp.addStepDependencies(&compile.step);

compile.test_runner = lp.dupe(compile.step.owner);

lp.addStepDependencies(&compile.step);

compile.win32_manifest = lp.dupe(compile.step.owner);

lp.addStepDependencies(&compile.step);

if (compile.kind == .lib) {

if (compile.linkage != null and compile.linkage.? == .static) {

compile.out_lib_filename = compile.out_filename;

} else if (compile.version) |version| {

compile.major_only_filename = owner.fmt("lib{s}.{d}.dylib", .{

compile.name,

compile.name_only_filename = owner.fmt("lib{s}.dylib", .{compile.name});

compile.out_lib_filename = compile.out_filename;

compile.out_lib_filename = owner.fmt("{s}.lib", .{compile.name});

compile.major_only_filename = owner.fmt("lib{s}.so.{d}", .{ compile.name, version.major });

compile.name_only_filename = owner.fmt("lib{s}.so", .{compile.name});

compile.out_lib_filename = compile.out_filename;

compile.out_lib_filename = compile.out_filename;

compile.out_lib_filename = owner.fmt("{s}.lib", .{compile.name});

compile.out_lib_filename = compile.out_filename;

return compile;

pub fn checkObject(compile: *Compile) *Step.CheckObject {

return Step.CheckObject.create(compile.step.owner, compile.getEmittedBin(), compile.rootModuleTarget().ofmt);

pub fn setLinkerScript(compile: *Compile, source: LazyPath) void {

const b = compile.step.owner;

compile.linker_script = source.dupe(b);

source.addStepDependencies(&compile.step);

pub fn setVersionScript(compile: *Compile, source: LazyPath) void {

const b = compile.step.owner;

compile.version_script = source.dupe(b);

source.addStepDependencies(&compile.step);

pub fn forceUndefinedSymbol(compile: *Compile, symbol_name: []const u8) void {

const b = compile.step.owner;

compile.force_undefined_symbols.put(b.dupe(symbol_name), {}) catch @panic("OOM");

pub fn dependsOnSystemLibrary(compile: *const Compile, name: []const u8) bool {

var dep_it = compile.root_module.iterateDependencies(compile, true);

while (dep_it.next()) |module| {

if (compile.rootModuleTarget().is_libc_lib_name(name)) {

if (compile.rootModuleTarget().is_libcpp_lib_name(name)) {

pub fn isDynamicLibrary(compile: *const Compile) bool {

return compile.kind == .lib and compile.linkage == .dynamic;

pub fn isStaticLibrary(compile: *const Compile) bool {

return compile.kind == .lib and compile.linkage != .dynamic;

pub fn isDll(compile: *Compile) bool {

return compile.isDynamicLibrary() and compile.rootModuleTarget().os.tag == .windows;

pub fn producesPdbFile(compile: *Compile) bool {

const target = compile.rootModuleTarget();

if (compile.root_module.strip == true or

(compile.root_module.strip == null and compile.root_module.optimize == .ReleaseSmall))

return compile.isDynamicLibrary() or compile.kind == .exe or compile.kind == .@"test";

pub fn producesImplib(compile: *Compile) bool {

return compile.isDll();

pub fn linkLibC(compile: *Compile) void {

compile.root_module.link_libc = true;

pub fn linkLibCpp(compile: *Compile) void {

compile.root_module.link_libcpp = true;

fn runPkgConfig(compile: *Compile, lib_name: []const u8) !PkgConfigResult {

const b = compile.step.owner;

var arg_it = mem.tokenizeAny(u8, stdout, " \r\n\t");

while (arg_it.next()) |arg| {

if (mem.eql(u8, arg, "-I")) {

const dir = arg_it.next() orelse return error.PkgConfigInvalidOutput;

} else if (mem.startsWith(u8, arg, "-I")) {

try zig_cflags.append(arg);

} else if (mem.eql(u8, arg, "-L")) {

const dir = arg_it.next() orelse return error.PkgConfigInvalidOutput;

} else if (mem.startsWith(u8, arg, "-L")) {

try zig_libs.append(arg);

} else if (mem.eql(u8, arg, "-l")) {

const lib = arg_it.next() orelse return error.PkgConfigInvalidOutput;

} else if (mem.startsWith(u8, arg, "-l")) {

try zig_libs.append(arg);

} else if (mem.eql(u8, arg, "-D")) {

const macro = arg_it.next() orelse return error.PkgConfigInvalidOutput;

} else if (mem.startsWith(u8, arg, "-D")) {

try zig_cflags.append(arg);

return compile.step.fail("unknown pkg-config flag '{s}'", .{arg});

pub fn linkSystemLibrary(compile: *Compile, name: []const u8) void {

return compile.root_module.linkSystemLibrary(name, .{});

compile: *Compile,

return compile.root_module.linkSystemLibrary(name, options);

pub fn addCSourceFiles(compile: *Compile, options: Module.AddCSourceFilesOptions) void {

compile.root_module.addCSourceFiles(options);

pub fn addCSourceFile(compile: *Compile, source: Module.CSourceFile) void {

compile.root_module.addCSourceFile(source);

pub fn addWin32ResourceFile(compile: *Compile, source: Module.RcSourceFile) void {

compile.root_module.addWin32ResourceFile(source);

pub fn setVerboseLink(compile: *Compile, value: bool) void {

compile.verbose_link = value;

pub fn setVerboseCC(compile: *Compile, value: bool) void {

compile.verbose_cc = value;

pub fn setLibCFile(compile: *Compile, libc_file: ?LazyPath) void {

const b = compile.step.owner;

compile.libc_file = if (libc_file) |f| f.dupe(b) else null;

fn getEmittedFileGeneric(compile: *Compile, output_file: *?*GeneratedFile) LazyPath {

if (output_file.*) |file| return .{ .generated = .{ .file = file } };

const arena = compile.step.owner.allocator;

generated_file.* = .{ .step = &compile.step };

return .{ .generated = .{ .file = generated_file } };

pub fn getEmittedBinDirectory(compile: *Compile) LazyPath {

_ = compile.getEmittedBin();

return compile.getEmittedFileGeneric(&compile.emit_directory);

pub fn getEmittedBin(compile: *Compile) LazyPath {

return compile.getEmittedFileGeneric(&compile.generated_bin);

pub fn getEmittedImplib(compile: *Compile) LazyPath {

assert(compile.kind == .lib);

return compile.getEmittedFileGeneric(&compile.generated_implib);

pub fn getEmittedH(compile: *Compile) LazyPath {

assert(compile.kind != .exe and compile.kind != .@"test");

return compile.getEmittedFileGeneric(&compile.generated_h);

pub fn getEmittedPdb(compile: *Compile) LazyPath {

_ = compile.getEmittedBin();

return compile.getEmittedFileGeneric(&compile.generated_pdb);

pub fn getEmittedDocs(compile: *Compile) LazyPath {

return compile.getEmittedFileGeneric(&compile.generated_docs);

pub fn getEmittedAsm(compile: *Compile) LazyPath {

return compile.getEmittedFileGeneric(&compile.generated_asm);

pub fn getEmittedLlvmIr(compile: *Compile) LazyPath {

return compile.getEmittedFileGeneric(&compile.generated_llvm_ir);

pub fn getEmittedLlvmBc(compile: *Compile) LazyPath {

return compile.getEmittedFileGeneric(&compile.generated_llvm_bc);

pub fn addAssemblyFile(compile: *Compile, source: LazyPath) void {

compile.root_module.addAssemblyFile(source);

pub fn addObjectFile(compile: *Compile, source: LazyPath) void {

compile.root_module.addObjectFile(source);

pub fn addObject(compile: *Compile, object: *Compile) void {

compile.root_module.addObject(object);

pub fn linkLibrary(compile: *Compile, library: *Compile) void {

compile.root_module.linkLibrary(library);

pub fn addAfterIncludePath(compile: *Compile, lazy_path: LazyPath) void {

compile.root_module.addAfterIncludePath(lazy_path);

pub fn addSystemIncludePath(compile: *Compile, lazy_path: LazyPath) void {

compile.root_module.addSystemIncludePath(lazy_path);

pub fn addIncludePath(compile: *Compile, lazy_path: LazyPath) void {

compile.root_module.addIncludePath(lazy_path);

pub fn addConfigHeader(compile: *Compile, config_header: *Step.ConfigHeader) void {

compile.root_module.addConfigHeader(config_header);

pub fn addLibraryPath(compile: *Compile, directory_path: LazyPath) void {

compile.root_module.addLibraryPath(directory_path);

pub fn addRPath(compile: *Compile, directory_path: LazyPath) void {

compile.root_module.addRPath(directory_path);

pub fn addSystemFrameworkPath(compile: *Compile, directory_path: LazyPath) void {

compile.root_module.addSystemFrameworkPath(directory_path);

pub fn addFrameworkPath(compile: *Compile, directory_path: LazyPath) void {

compile.root_module.addFrameworkPath(directory_path);

pub fn setExecCmd(compile: *Compile, args: []const ?[]const u8) void {

const b = compile.step.owner;

assert(compile.kind == .@"test");

compile.exec_cmd_args = duped_args;

var compile: CliNamedModules = .{

var dep_it = root_module.iterateDependencies(null, false);

const item = dep_it.next().?;

try compile.modules.put(arena, root_module, {});

try compile.names.put(arena, "root", {});

while (dep_it.next()) |item| {

const gop = try compile.names.getOrPut(arena, name);

try compile.modules.putNoClobber(arena, item.module, {});

return compile;

fn getGeneratedFilePath(compile: *Compile, comptime tag_name: []const u8, asking_step: ?*Step) []const u8 {

const maybe_path: ?*GeneratedFile = @field(compile, tag_name);

std.Build.dumpBadGetPathHelp(&compile.step, stderr, compile.step.owner, asking_step) catch {};

std.Build.dumpBadGetPathHelp(&compile.step, stderr, compile.step.owner, asking_step) catch {};

const compile: *Compile = @fieldParentPtr("step", step);

const cmd = switch (compile.kind) {

try addFlag(&zig_args, "llvm", compile.use_llvm);

try addFlag(&zig_args, "lld", compile.use_lld);

if (compile.root_module.resolved_target.?.query.ofmt) |ofmt| {

switch (compile.entry) {

var symbol_it = compile.force_undefined_symbols.keyIterator();

while (symbol_it.next()) |symbol_name| {

if (compile.stack_size) |stack_size| {

var total_linker_objects: usize = @intFromBool(compile.root_module.root_source_file != null);

var dep_it = compile.root_module.iterateDependencies(compile, true);

while (dep_it.next()) |key| {

if (key.module.link_libc == true) compile.is_linking_libc = true;

if (key.module.link_libcpp == true) compile.is_linking_libcpp = true;

var cli_named_modules = try CliNamedModules.init(arena, &compile.root_module);

var dep_it = compile.root_module.iterateDependencies(compile, false);

while (dep_it.next()) |dep| {

const my_responsibility = dep.compile.? == compile;

const already_linked = !my_responsibility and dep.compile.?.isDynamicLibrary();

for (dep.module.frameworks.keys(), dep.module.frameworks.values()) |name, info| {

for (dep.module.link_objects.items) |link_object| {

try zig_args.append(static_path.getPath2(dep.module.owner, step));

compile.linkage != .static)

if (compile.runPkgConfig(system_lib.name)) |result| {

const included_in_lib_or_obj = !my_responsibility and

(dep.compile.?.kind == .lib or dep.compile.?.kind == .obj);

try zig_args.append(other.getEmittedBin().getPath2(b, step));

if (compile.isStaticLibrary() and other_is_static) {

other.getGeneratedFilePath("generated_implib", &compile.step)

other.getGeneratedFilePath("generated_bin", &compile.step);

compile.rootModuleTarget().os.tag != .windows)

try zig_args.append(asm_file.getPath2(dep.module.owner, step));

try zig_args.append(c_source_file.file.getPath2(dep.module.owner, step));

const root_path = c_source_files.root.getPath2(dep.module.owner, step);

try zig_args.append(include_path.getPath2(dep.module.owner, step));

try zig_args.append(rc_source_file.file.getPath2(dep.module.owner, step));

if (cli_named_modules.modules.getIndex(dep.module)) |module_cli_index| {

try dep.module.appendZigProcessFlags(&zig_args, step);

try zig_args.ensureUnusedCapacity(dep.module.import_table.count() * 2);

for (dep.module.import_table.keys(), dep.module.import_table.values()) |name, import| {

const import_index = cli_named_modules.modules.getIndex(import).?;

const import_cli_name = cli_named_modules.names.keys()[import_index];

if (std.mem.eql(u8, import_cli_name, name)) {

zig_args.appendAssumeCapacity(import_cli_name);

zig_args.appendAssumeCapacity(b.fmt("{s}={s}", .{ name, import_cli_name }));

if (dep.module.root_source_file) |lp| {

const src = lp.getPath2(dep.module.owner, step);

} else if (moduleNeedsCliArg(dep.module)) {

if (compile.is_linking_libcpp) {

if (compile.is_linking_libc) {

if (compile.win32_manifest) |manifest_file| {

try zig_args.append(manifest_file.getPath2(b, step));

if (compile.image_base) |image_base| {

for (compile.filters) |filter| {

if (compile.test_runner) |test_runner| {

try zig_args.append(test_runner.getPath2(b, step));

if (b.verbose_link or compile.verbose_link) try zig_args.append("--verbose-link");

if (b.verbose_cc or compile.verbose_cc) try zig_args.append("--verbose-cc");

if (compile.generated_asm != null) try zig_args.append("-femit-asm");

if (compile.generated_bin == null) try zig_args.append("-fno-emit-bin");

if (compile.generated_docs != null) try zig_args.append("-femit-docs");

if (compile.generated_implib != null) try zig_args.append("-femit-implib");

if (compile.generated_llvm_bc != null) try zig_args.append("-femit-llvm-bc");

if (compile.generated_llvm_ir != null) try zig_args.append("-femit-llvm-ir");

if (compile.generated_h != null) try zig_args.append("-femit-h");

try addFlag(&zig_args, "formatted-panics", compile.formatted_panics);

switch (compile.compress_debug_sections) {

if (compile.link_eh_frame_hdr) {

if (compile.link_emit_relocs) {

if (compile.link_function_sections) {

if (compile.link_data_sections) {

if (compile.link_gc_sections) |x| {

if (!compile.linker_dynamicbase) {

if (compile.linker_allow_shlib_undefined) |x| {

if (compile.link_z_notext) {

if (!compile.link_z_relro) {

if (compile.link_z_lazy) {

if (compile.link_z_common_page_size) |size| {

if (compile.link_z_max_page_size) |size| {

if (compile.libc_file) |libc_file| {

try zig_args.append(libc_file.getPath2(b, step));

try zig_args.append(compile.name);

if (compile.linkage) |some| switch (some) {

if (compile.kind == .lib and compile.linkage != null and compile.linkage.? == .dynamic) {

if (compile.version) |version| {

if (compile.rootModuleTarget().isDarwin()) {

const install_name = compile.install_name orelse b.fmt("@rpath/{s}{s}{s}", .{

compile.rootModuleTarget().libPrefix(),

compile.name,

compile.rootModuleTarget().dynamicLibSuffix(),

if (compile.entitlements) |entitlements| {

if (compile.pagezero_size) |pagezero_size| {

if (compile.headerpad_size) |headerpad_size| {

if (compile.headerpad_max_install_names) {

if (compile.dead_strip_dylibs) {

if (compile.force_load_objc) {

try addFlag(&zig_args, "compiler-rt", compile.bundle_compiler_rt);

try addFlag(&zig_args, "dll-export-fns", compile.dll_export_fns);

if (compile.rdynamic) {

if (compile.import_memory) {

if (compile.export_memory) {

if (compile.import_symbols) {

if (compile.import_table) {

if (compile.export_table) {

if (compile.initial_memory) |initial_memory| {

if (compile.max_memory) |max_memory| {

if (compile.shared_memory) {

if (compile.global_base) |global_base| {

if (compile.wasi_exec_model) |model| {

if (compile.linker_script) |linker_script| {

try zig_args.append(linker_script.getPath2(b, step));

if (compile.version_script) |version_script| {

try zig_args.append(version_script.getPath2(b, step));

if (compile.linker_allow_undefined_version) |x| {

if (compile.linker_enable_new_dtags) |enabled| {

if (compile.kind == .@"test") {

if (compile.exec_cmd_args) |exec_cmd_args| {

"-L", b.pathJoin(&.{ search_prefix, "lib" }),

"-I", b.pathJoin(&.{ search_prefix, "include" }),

if (compile.rc_includes != .any) {

try zig_args.append(@tagName(compile.rc_includes));

try addFlag(&zig_args, "each-lib-rpath", compile.each_lib_rpath);

if (compile.build_id) |build_id| {

if (compile.zig_lib_dir) |dir| {

try zig_args.append(dir.getPath2(b, step));

try addFlag(&zig_args, "PIE", compile.pie);

try addFlag(&zig_args, "lto", compile.want_lto);

if (compile.subsystem) |subsystem| {

if (compile.mingw_unicode_entry_point) {

if (compile.error_limit) |err_limit| try zig_args.appendSlice(&.{

assert(compile.expect_errors != null);

try checkCompileErrors(compile);

if (compile.emit_directory) |lp| {

if (compile.generated_bin) |bin| {

bin.path = b.pathJoin(&.{ output_dir, compile.out_filename });

if (compile.generated_pdb) |pdb| {

pdb.path = b.fmt("{s}{c}{s}.pdb", .{ output_dir, sep, compile.name });

if (compile.generated_implib) |implib| {

implib.path = b.fmt("{s}{c}{s}.lib", .{ output_dir, sep, compile.name });

if (compile.generated_h) |lp| {

lp.path = b.fmt("{s}{c}{s}.h", .{ output_dir, sep, compile.name });

if (compile.generated_docs) |generated_docs| {

if (compile.generated_asm) |lp| {

lp.path = b.fmt("{s}{c}{s}.s", .{ output_dir, sep, compile.name });

if (compile.generated_llvm_ir) |lp| {

lp.path = b.fmt("{s}{c}{s}.ll", .{ output_dir, sep, compile.name });

if (compile.generated_llvm_bc) |lp| {

lp.path = b.fmt("{s}{c}{s}.bc", .{ output_dir, sep, compile.name });

if (compile.kind == .lib and compile.linkage != null and compile.linkage.? == .dynamic and

compile.version != null and std.Build.wantSharedLibSymLinks(compile.rootModuleTarget()))

compile.getEmittedBin().getPath2(b, step),

compile.major_only_filename.?,

compile.name_only_filename.?,

const b = step.owner;

const arena = b.allocator;

const major_only_path = b.pathJoin(&.{ out_dir, filename_major_only });

const name_only_path = b.pathJoin(&.{ out_dir, filename_name_only });

fn execPkgConfigList(compile: *std.Build, out_code: *u8) (PkgConfigError || RunError)![]const PkgConfigPkg {

const stdout = try compile.runAllowFail(&[_][]const u8{ "pkg-config", "--list-all" }, out_code, .Ignore);

var list = ArrayList(PkgConfigPkg).init(compile.allocator);

fn getPkgConfigList(compile: *std.Build) ![]const PkgConfigPkg {

if (compile.pkg_config_pkg_list) |res| {

if (execPkgConfigList(compile, &code)) |list| {

compile.pkg_config_pkg_list = list;

compile.pkg_config_pkg_list = result;

fn checkCompileErrors(compile: *Compile) !void {

const actual_eb = compile.step.result_error_bundle;

compile.step.result_error_bundle = std.zig.ErrorBundle.empty;

const arena = compile.step.owner.allocator;

const expect_errors = compile.expect_errors.?;

return compile.step.fail(

return compile.step.fail(

const config_header = owner.allocator.create(ConfigHeader) catch @panic("OOM");

.generated => break :default_include_path,

config_header.* = .{

.output_file = .{ .step = &config_header.step },

return config_header;

pub fn addValues(config_header: *ConfigHeader, values: anytype) void {

return addValuesInner(config_header, values) catch @panic("OOM");

pub fn getOutput(config_header: *ConfigHeader) std.Build.LazyPath {

return .{ .generated = .{ .file = &config_header.output_file } };

fn addValuesInner(config_header: *ConfigHeader, values: anytype) !void {

try putValue(config_header, field.name, field.type, @field(values, field.name));

fn putValue(config_header: *ConfigHeader, field_name: []const u8, comptime T: type, v: T) !void {

try config_header.values.put(field_name, .undef);

try config_header.values.put(field_name, .defined);

try config_header.values.put(field_name, .{ .boolean = v });

try config_header.values.put(field_name, .{ .int = v });

try config_header.values.put(field_name, .{ .int = v });

try config_header.values.put(field_name, .{ .ident = @tagName(v) });

return putValue(config_header, field_name, @TypeOf(x), x);

try config_header.values.put(field_name, .undef);

try config_header.values.put(field_name, .{ .string = v });

try config_header.values.put(field_name, .{ .string = v });

const config_header: *ConfigHeader = @fieldParentPtr("step", step);

man.hash.addBytes(config_header.include_path);

man.hash.addOptionalBytes(config_header.include_guard_override);

switch (config_header.style) {

const src_path = file_source.getPath2(b, step);

const contents = std.fs.cwd().readFileAlloc(arena, src_path, config_header.max_bytes) catch |err| {

try render_autoconf(step, contents, &output, config_header.values, src_path);

const src_path = file_source.getPath2(b, step);

const contents = std.fs.cwd().readFileAlloc(arena, src_path, config_header.max_bytes) catch |err| {

try render_cmake(step, contents, &output, config_header.values, src_path);

try render_blank(&output, config_header.values, config_header.include_path, config_header.include_guard_override);

try render_nasm(&output, config_header.values);

config_header.output_file.path = try b.cache_root.join(arena, &.{

"o", &digest, config_header.include_path,

const sub_path = b.pathJoin(&.{ "o", &digest, config_header.include_path });

config_header.output_file.path = try b.cache_root.join(arena, &.{sub_path});

pub const base_id: Step.Id = .fmt;

const fmt = owner.allocator.create(Fmt) catch @panic("OOM");

fmt.* = .{

return fmt;

const fmt: *Fmt = @fieldParentPtr("step", step);

try argv.ensureUnusedCapacity(arena, 2 + 1 + fmt.paths.len + 2 * fmt.exclude_paths.len);

if (fmt.check) {

for (fmt.paths) |p| {

for (fmt.exclude_paths) |p| {

pub const base_id: Step.Id = .install_artifact;

const install_artifact = owner.allocator.create(InstallArtifact) catch @panic("OOM");

install_artifact.* = .{

install_artifact.step.dependOn(&artifact.step);

if (install_artifact.dest_dir != null) install_artifact.emitted_bin = artifact.getEmittedBin();

if (install_artifact.pdb_dir != null) install_artifact.emitted_pdb = artifact.getEmittedPdb();

//if (install_artifact.h_dir != null) install_artifact.emitted_h = artifact.getEmittedH();

if (install_artifact.implib_dir != null) install_artifact.emitted_implib = artifact.getEmittedImplib();

return install_artifact;

const install_artifact: *InstallArtifact = @fieldParentPtr("step", step);

if (install_artifact.dest_dir) |dest_dir| {

const full_dest_path = b.getInstallPath(dest_dir, install_artifact.dest_sub_path);

const full_src_path = install_artifact.emitted_bin.?.getPath2(b, step);

if (install_artifact.dylib_symlinks) |dls| {

install_artifact.artifact.installed_path = full_dest_path;

if (install_artifact.implib_dir) |implib_dir| {

const full_src_path = install_artifact.emitted_implib.?.getPath2(b, step);

if (install_artifact.pdb_dir) |pdb_dir| {

const full_src_path = install_artifact.emitted_pdb.?.getPath2(b, step);

if (install_artifact.h_dir) |h_dir| {

if (install_artifact.emitted_h) |emitted_h| {

for (install_artifact.artifact.installed_headers.items) |installation| switch (installation) {

const InstallDir = @This();

pub const base_id: Step.Id = .install_dir;

install_dir: std.Build.InstallDir,

fn dupe(opts: Options, b: *std.Build) Options {

.source_dir = opts.source_dir.dupe(b),

.install_dir = opts.install_dir.dupe(b),

.install_subdir = b.dupe(opts.install_subdir),

.exclude_extensions = b.dupeStrings(opts.exclude_extensions),

.include_extensions = if (opts.include_extensions) |incs| b.dupeStrings(incs) else null,

.blank_extensions = b.dupeStrings(opts.blank_extensions),

pub fn create(owner: *std.Build, options: Options) *InstallDir {

const install_dir = owner.allocator.create(InstallDir) catch @panic("OOM");

install_dir.* = .{

.id = base_id,

options.source_dir.addStepDependencies(&install_dir.step);

return install_dir;

const install_dir: *InstallDir = @fieldParentPtr("step", step);

const dest_prefix = b.getInstallPath(install_dir.options.install_dir, install_dir.options.install_subdir);

const src_dir_path = install_dir.options.source_dir.getPath2(b, step);

for (install_dir.options.exclude_extensions) |ext| {

if (install_dir.options.include_extensions) |incs| {

const src_sub_path = b.pathJoin(&.{ src_dir_path, entry.path });

const dest_path = b.pathJoin(&.{ dest_prefix, entry.path });

for (install_dir.options.blank_extensions) |ext| {

pub const base_id: Step.Id = .install_file;

const install_file = owner.allocator.create(InstallFile) catch @panic("OOM");

install_file.* = .{

source.addStepDependencies(&install_file.step);

return install_file;

const install_file: *InstallFile = @fieldParentPtr("step", step);

const full_src_path = install_file.source.getPath2(b, step);

const full_dest_path = b.getInstallPath(install_file.dir, install_file.dest_rel_path);

const objcopy = owner.allocator.create(ObjCopy) catch @panic("OOM");

objcopy.* = ObjCopy{

.output_file = std.Build.GeneratedFile{ .step = &objcopy.step },

.output_file_debug = if (options.strip != .none and options.extract_to_separate_file) std.Build.GeneratedFile{ .step = &objcopy.step } else null,

input_file.addStepDependencies(&objcopy.step);

return objcopy;

pub fn getOutput(objcopy: *const ObjCopy) std.Build.LazyPath {

return .{ .generated = .{ .file = &objcopy.output_file } };

pub fn getOutputSeparatedDebug(objcopy: *const ObjCopy) ?std.Build.LazyPath {

return if (objcopy.output_file_debug) |*file| .{ .generated = .{ .file = file } } else null;

const objcopy: *ObjCopy = @fieldParentPtr("step", step);

const full_src_path = objcopy.input_file.getPath2(b, step);

man.hash.addOptionalListOfBytes(objcopy.only_sections);

man.hash.addOptional(objcopy.pad_to);

man.hash.addOptional(objcopy.format);

man.hash.add(objcopy.compress_debug);

man.hash.add(objcopy.strip);

man.hash.add(objcopy.output_file_debug != null);

objcopy.output_file.path = try b.cache_root.join(b.allocator, &.{

"o", &digest, objcopy.basename,

if (objcopy.output_file_debug) |*file| {

"o", &digest, b.fmt("{s}.debug", .{objcopy.basename}),

const full_dest_path = try b.cache_root.join(b.allocator, &.{ cache_path, objcopy.basename });

const full_dest_path_debug = try b.cache_root.join(b.allocator, &.{ cache_path, b.fmt("{s}.debug", .{objcopy.basename}) });

if (objcopy.only_sections) |only_sections| {

switch (objcopy.strip) {

if (objcopy.pad_to) |pad_to| {

if (objcopy.format) |format| switch (format) {

if (objcopy.compress_debug) {

if (objcopy.output_file_debug != null) {

objcopy.output_file.path = full_dest_path;

if (objcopy.output_file_debug) |*file| file.path = full_dest_path_debug;

pub const base_id: Step.Id = .options;

const options = owner.allocator.create(Options) catch @panic("OOM");

options.* = .{

options.generated_file = .{ .step = &options.step };

return options;

pub fn addOption(options: *Options, comptime T: type, name: []const u8, value: T) void {

return addOptionFallible(options, T, name, value) catch @panic("unhandled error");

fn addOptionFallible(options: *Options, comptime T: type, name: []const u8, value: T) !void {

const out = options.contents.writer();

try printType(options, out, T, value, 0, name);

fn printType(options: *Options, out: anytype, comptime T: type, value: T, indent: u8, name: ?[]const u8) !void {

try printType(options, out, @TypeOf(item), item, indent + 4, null);

try printType(options, out, @TypeOf(item), item, indent + 4, null);

try printType(options, out, @TypeOf(inner), inner, indent + 4, null);

_ = options.contents.pop();

_ = options.contents.pop();

try printEnum(options, out, T, info, indent);

try printStruct(options, out, T, info, indent);

try printStructValue(options, out, info, value, indent);

fn printUserDefinedType(options: *Options, out: anytype, comptime T: type, indent: u8) !void {

return try printEnum(options, out, T, info, indent);

return try printStruct(options, out, T, info, indent);

fn printEnum(options: *Options, out: anytype, comptime T: type, comptime val: std.builtin.Type.Enum, indent: u8) !void {

const gop = try options.encountered_types.getOrPut(@typeName(T));

fn printStruct(options: *Options, out: anytype, comptime T: type, comptime val: std.builtin.Type.Struct, indent: u8) !void {

const gop = try options.encountered_types.getOrPut(@typeName(T));

try printStructValue(options, out, info, default_value, indent + 4);

else => try printType(options, out, @TypeOf(default_value), default_value, indent, null),

try printUserDefinedType(options, out, field.type, 0);

fn printStructValue(options: *Options, out: anytype, comptime struct_val: std.builtin.Type.Struct, val: anytype, indent: u8) !void {

try printType(options, out, @TypeOf(@field(val, field.name)), @field(val, field.name), indent, null);

try printStructValue(options, out, struct_info, field_name, indent + 4);

else => try printType(options, out, @TypeOf(field_name), field_name, indent, null),

options: *Options,

options.args.append(.{

.name = options.step.owner.dupe(name),

.path = path.dupe(options.step.owner),

path.addStepDependencies(&options.step);

pub fn addOptionArtifact(options: *Options, name: []const u8, artifact: *Step.Compile) void {

return addOptionPath(options, name, artifact.getEmittedBin());

pub fn createModule(options: *Options) *std.Build.Module {

return options.step.owner.createModule(.{

.root_source_file = options.getOutput(),

pub fn getOutput(options: *Options) LazyPath {

return .{ .generated = .{ .file = &options.generated_file } };

const options: *Options = @fieldParentPtr("step", step);

for (options.args.items) |item| {

options.addOption(

item.path.getPath2(b, step),

hash.addBytes(options.contents.items);

options.generated_file.path = try b.cache_root.join(b.allocator, &.{sub_path});

b.cache_root.handle.writeFile(.{ .sub_path = tmp_sub_path, .data = options.contents.items }) catch |err| {

pub const base_id: Step.Id = .remove_dir;

const remove_dir = owner.allocator.create(RemoveDir) catch @panic("OOM");

remove_dir.* = .{

.id = base_id,

return remove_dir;

const remove_dir: *RemoveDir = @fieldParentPtr("step", step);

b.build_root.handle.deleteTree(remove_dir.dir_path) catch |err| {

base, remove_dir.dir_path, @errorName(err),

remove_dir.dir_path, @errorName(err),

argv: std.ArrayListUnmanaged(Arg),

stdio: StdIo,

stdin: StdIn,

/// Deprecated: use `addFileInput`

extra_file_dependencies: []const []const u8,

 

/// Additional input files that, when modified, indicate that the Run step

/// should be re-executed.

/// If the Run step is determined to have side-effects, the Run step is always

/// executed when it appears in the build graph, regardless of whether these

/// files have been modified.

file_inputs: std.ArrayListUnmanaged(std.Build.LazyPath),

rename_step_with_output_arg: bool,

skip_foreign_checks: bool,

failing_to_execute_foreign_is_an_error: bool,

max_stdio_size: usize,

captured_stdout: ?*Output,

captured_stderr: ?*Output,

dep_output_file: ?*Output,

has_side_effects: bool,

check: std.ArrayListUnmanaged(Check),

output_file: *Output,

output_directory: *Output,

const run = owner.allocator.create(Run) catch @panic("OOM");

run.* = .{

.argv = .{},

.stdio = .infer_from_args,

.stdin = .none,

.extra_file_dependencies = &.{},

.file_inputs = .{},

.rename_step_with_output_arg = true,

.skip_foreign_checks = false,

.failing_to_execute_foreign_is_an_error = true,

.max_stdio_size = 10 * 1024 * 1024,

.captured_stdout = null,

.captured_stderr = null,

.dep_output_file = null,

.has_side_effects = false,

return run;

pub fn setName(run: *Run, name: []const u8) void {

run.step.name = name;

run.rename_step_with_output_arg = false;

pub fn enableTestRunnerMode(run: *Run) void {

run.stdio = .zig_test;

run.addArgs(&.{"--listen=-"});

pub fn addArtifactArg(run: *Run, artifact: *Step.Compile) void {

const b = run.step.owner;

bin_file.addStepDependencies(&run.step);

run.argv.append(b.allocator, Arg{ .artifact = artifact }) catch @panic("OOM");

pub fn addOutputFileArg(run: *Run, basename: []const u8) std.Build.LazyPath {

return run.addPrefixedOutputFileArg("", basename);

/// Asserts `basename` is not empty.

run: *Run,

const b = run.step.owner;

if (basename.len == 0) @panic("basename must not be empty");

.prefix = b.dupe(prefix),

.basename = b.dupe(basename),

.generated_file = .{ .step = &run.step },

run.argv.append(b.allocator, .{ .output_file = output }) catch @panic("OOM");

if (run.rename_step_with_output_arg) {

run.setName(b.fmt("{s} ({s})", .{ run.step.name, basename }));

return .{ .generated = .{ .file = &output.generated_file } };

pub fn addFileArg(run: *Run, lp: std.Build.LazyPath) void {

run.addPrefixedFileArg("", lp);

pub fn addPrefixedFileArg(run: *Run, prefix: []const u8, lp: std.Build.LazyPath) void {

const b = run.step.owner;

run.argv.append(b.allocator, .{ .lazy_path = prefixed_file_source }) catch @panic("OOM");

lp.addStepDependencies(&run.step);

}

 

/// Provides a directory path as a command line argument to the command being run.

///

/// Returns a `std.Build.LazyPath` which can be used as inputs to other APIs

/// throughout the build system.

///

/// Related:

/// * `addPrefixedOutputDirectoryArg` - same thing but prepends a string to the argument

/// * `addDirectoryArg` - for input directories given to the child process

pub fn addOutputDirectoryArg(run: *Run, basename: []const u8) std.Build.LazyPath {

return run.addPrefixedOutputDirectoryArg("", basename);

}

 

/// Provides a directory path as a command line argument to the command being run.

/// Asserts `basename` is not empty.

///

/// For example, a prefix of "-o" and basename of "output_dir" will result in

/// the child process seeing something like this: "-ozig-cache/.../output_dir"

///

/// The child process will see a single argument, regardless of whether the

/// prefix or basename have spaces.

///

/// The returned `std.Build.LazyPath` can be used as inputs to other APIs

/// throughout the build system.

///

/// Related:

/// * `addOutputDirectoryArg` - same thing but without the prefix

/// * `addDirectoryArg` - for input directories given to the child process

pub fn addPrefixedOutputDirectoryArg(

run: *Run,

prefix: []const u8,

basename: []const u8,

) std.Build.LazyPath {

if (basename.len == 0) @panic("basename must not be empty");

const b = run.step.owner;

 

const output = b.allocator.create(Output) catch @panic("OOM");

output.* = .{

.prefix = b.dupe(prefix),

.basename = b.dupe(basename),

.generated_file = .{ .step = &run.step },

};

run.argv.append(b.allocator, .{ .output_directory = output }) catch @panic("OOM");

 

if (run.rename_step_with_output_arg) {

run.setName(b.fmt("{s} ({s})", .{ run.step.name, basename }));

}

 

return .{ .generated = .{ .file = &output.generated_file } };

pub fn addDirectoryArg(run: *Run, directory_source: std.Build.LazyPath) void {

run.addPrefixedDirectoryArg("", directory_source);

pub fn addPrefixedDirectoryArg(run: *Run, prefix: []const u8, directory_source: std.Build.LazyPath) void {

const b = run.step.owner;

run.argv.append(b.allocator, .{ .directory_source = prefixed_directory_source }) catch @panic("OOM");

directory_source.addStepDependencies(&run.step);

pub fn addDepFileOutputArg(run: *Run, basename: []const u8) std.Build.LazyPath {

return run.addPrefixedDepFileOutputArg("", basename);

pub fn addPrefixedDepFileOutputArg(run: *Run, prefix: []const u8, basename: []const u8) std.Build.LazyPath {

const b = run.step.owner;

assert(run.dep_output_file == null);

.generated_file = .{ .step = &run.step },

run.dep_output_file = dep_file;

run.argv.append(b.allocator, .{ .output_file = dep_file }) catch @panic("OOM");

return .{ .generated = .{ .file = &dep_file.generated_file } };

pub fn addArg(run: *Run, arg: []const u8) void {

const b = run.step.owner;

run.argv.append(b.allocator, .{ .bytes = b.dupe(arg) }) catch @panic("OOM");

pub fn addArgs(run: *Run, args: []const []const u8) void {

for (args) |arg| run.addArg(arg);

pub fn setStdIn(run: *Run, stdin: StdIn) void {

.lazy_path => |lazy_path| lazy_path.addStepDependencies(&run.step),

run.stdin = stdin;

pub fn setCwd(run: *Run, cwd: Build.LazyPath) void {

cwd.addStepDependencies(&run.step);

run.cwd = cwd.dupe(run.step.owner);

pub fn clearEnvironment(run: *Run) void {

const b = run.step.owner;

run.env_map = new_env_map;

pub fn addPathDir(run: *Run, search_path: []const u8) void {

const b = run.step.owner;

const env_map = getEnvMapInternal(run);

pub fn getEnvMap(run: *Run) *EnvMap {

return getEnvMapInternal(run);

fn getEnvMapInternal(run: *Run) *EnvMap {

const arena = run.step.owner.allocator;

return run.env_map orelse {

run.env_map = env_map;

pub fn setEnvironmentVariable(run: *Run, key: []const u8, value: []const u8) void {

const b = run.step.owner;

const env_map = run.getEnvMap();

pub fn removeEnvironmentVariable(run: *Run, key: []const u8) void {

run.getEnvMap().remove(key);

pub fn expectStdErrEqual(run: *Run, bytes: []const u8) void {

const new_check: StdIo.Check = .{ .expect_stderr_exact = run.step.owner.dupe(bytes) };

run.addCheck(new_check);

pub fn expectStdOutEqual(run: *Run, bytes: []const u8) void {

const new_check: StdIo.Check = .{ .expect_stdout_exact = run.step.owner.dupe(bytes) };

run.addCheck(new_check);

if (!run.hasTermCheck()) {

run.expectExitCode(0);

pub fn expectExitCode(run: *Run, code: u8) void {

run.addCheck(new_check);

pub fn hasTermCheck(run: Run) bool {

for (run.stdio.check.items) |check| switch (check) {

pub fn addCheck(run: *Run, new_check: StdIo.Check) void {

const b = run.step.owner;

 

switch (run.stdio) {

run.stdio = .{ .check = .{} };

run.stdio.check.append(b.allocator, new_check) catch @panic("OOM");

.check => |*checks| checks.append(b.allocator, new_check) catch @panic("OOM"),

pub fn captureStdErr(run: *Run) std.Build.LazyPath {

assert(run.stdio != .inherit);

if (run.captured_stderr) |output| return .{ .generated = .{ .file = &output.generated_file } };

const output = run.step.owner.allocator.create(Output) catch @panic("OOM");

.generated_file = .{ .step = &run.step },

run.captured_stderr = output;

return .{ .generated = .{ .file = &output.generated_file } };

pub fn captureStdOut(run: *Run) std.Build.LazyPath {

assert(run.stdio != .inherit);

if (run.captured_stdout) |output| return .{ .generated = .{ .file = &output.generated_file } };

const output = run.step.owner.allocator.create(Output) catch @panic("OOM");

.generated_file = .{ .step = &run.step },

run.captured_stdout = output;

return .{ .generated = .{ .file = &output.generated_file } };

}

 

/// Adds an additional input files that, when modified, indicates that this Run

/// step should be re-executed.

/// If the Run step is determined to have side-effects, the Run step is always

/// executed when it appears in the build graph, regardless of whether this

/// file has been modified.

pub fn addFileInput(self: *Run, file_input: std.Build.LazyPath) void {

file_input.addStepDependencies(&self.step);

self.file_inputs.append(self.step.owner.allocator, file_input.dupe(self.step.owner)) catch @panic("OOM");

fn hasSideEffects(run: Run) bool {

if (run.has_side_effects) return true;

return switch (run.stdio) {

.infer_from_args => !run.hasAnyOutputArgs(),

fn hasAnyOutputArgs(run: Run) bool {

if (run.captured_stdout != null) return true;

if (run.captured_stderr != null) return true;

for (run.argv.items) |arg| switch (arg) {

.output_file, .output_directory => return true,

tag: @typeInfo(Arg).Union.tag_type.?,

const run: *Run = @fieldParentPtr("step", step);

const has_side_effects = run.hasSideEffects();

var argv_list = std.ArrayList([]const u8).init(arena);

var output_placeholders = std.ArrayList(IndexedOutput).init(arena);

for (run.argv.items) |arg| {

const file_path = file.lazy_path.getPath2(b, step);

const file_path = file.lazy_path.getPath2(b, step);

run.addPathForDynLibs(artifact);

.output_file, .output_directory => |output| {

.index = argv_list.items.len,

.tag = arg,

_ = try argv_list.addOne();

switch (run.stdin) {

const file_path = lazy_path.getPath2(b, step);

if (run.captured_stdout) |output| {

if (run.captured_stderr) |output| {

hashStdIo(&man.hash, run.stdio);

for (run.extra_file_dependencies) |file_path| {

for (run.file_inputs.items) |lazy_path| {

_ = try man.addFile(lazy_path.getPath2(b, step), null);

}

if (try step.cacheHit(&man) and !has_side_effects) {

run.captured_stdout,

run.captured_stderr,

const dep_output_file = run.dep_output_file orelse {

// We already know the final output paths, use them directly.

const digest = man.final();

 

try populateGeneratedPaths(

arena,

output_placeholders.items,

run.captured_stdout,

run.captured_stderr,

b.cache_root,

&digest,

);

 

const output_dir_path = "o" ++ fs.path.sep_str ++ &digest;

for (output_placeholders.items) |placeholder| {

const output_sub_path = b.pathJoin(&.{ output_dir_path, placeholder.output.basename });

const output_sub_dir_path = switch (placeholder.tag) {

.output_file => fs.path.dirname(output_sub_path).?,

.output_directory => output_sub_path,

else => unreachable,

};

b.cache_root.handle.makePath(output_sub_dir_path) catch |err| {

return step.fail("unable to make path '{}{s}': {s}", .{

b.cache_root, output_sub_dir_path, @errorName(err),

});

};

const output_path = placeholder.output.generated_file.path.?;

argv_list.items[placeholder.index] = if (placeholder.output.prefix.len == 0)

output_path

else

b.fmt("{s}{s}", .{ placeholder.output.prefix, output_path });

}

 

return runCommand(run, argv_list.items, has_side_effects, output_dir_path, prog_node);

};

 

// We do not know the final output paths yet, use temp paths to run the command.

const output_sub_path = b.pathJoin(&output_components);

const output_sub_dir_path = switch (placeholder.tag) {

.output_file => fs.path.dirname(output_sub_path).?,

.output_directory => output_sub_path,

else => unreachable,

};

argv_list.items[placeholder.index] = if (placeholder.output.prefix.len == 0)

try runCommand(run, argv_list.items, has_side_effects, tmp_dir_path, prog_node);

try man.addDepFilePost(std.fs.cwd(), dep_output_file.generated_file.getPath());

run.captured_stdout != null or run.captured_stderr != null;

run.captured_stdout,

run.captured_stderr,

run: *Run,

output_dir_path: []const u8,

const step = &run.step;

const cwd: ?[]const u8 = if (run.cwd) |lazy_cwd| lazy_cwd.getPath2(b, step) else null;

try Step.handleVerbose2(step.owner, cwd, run.env_map, argv);

const allow_skip = switch (run.stdio) {

.check, .zig_test => run.skip_foreign_checks,

const result = spawnChildAndCollect(run, argv, has_side_effects, prog_node) catch |err| term: {

const exe = switch (run.argv.items[0]) {

return failForeign(run, "-fwine", argv[0], exe);

return failForeign(run, "--glibc-runtimes", argv[0], exe)

return failForeign(run, "-fqemu", argv[0], exe);

return failForeign(run, "-fdarling", argv[0], exe);

return failForeign(run, "-fwasmtime", argv[0], exe);

run.addPathForDynLibs(exe);

try Step.handleVerbose2(step.owner, cwd, run.env_map, interp_argv.items);

break :term spawnChildAndCollect(run, interp_argv.items, has_side_effects, prog_node) catch |e| {

if (!run.failing_to_execute_foreign_is_an_error) return error.MakeSkipped;

.captured = run.captured_stdout,

.captured = run.captured_stderr,

const output_components = .{ output_dir_path, output.basename };

const sub_path = b.pathJoin(&output_components);

switch (run.stdio) {

run: *Run,

const b = run.step.owner;

if (run.cwd) |lazy_cwd| {

child.cwd = lazy_cwd.getPath2(b, &run.step);

child.env_map = run.env_map orelse &b.graph.env_map;

child.stdin_behavior = switch (run.stdio) {

child.stdout_behavior = switch (run.stdio) {

child.stderr_behavior = switch (run.stdio) {

if (run.captured_stdout != null) child.stdout_behavior = .Pipe;

if (run.captured_stderr != null) child.stderr_behavior = .Pipe;

if (run.stdin != .none) {

assert(run.stdio != .inherit);

const result = if (run.stdio == .zig_test)

evalZigTest(run, &child, prog_node)

evalGeneric(run, &child);

run: *Run,

const gpa = run.step.owner.allocator;

const arena = run.step.owner.allocator;

return run.step.fail(

try run.step.addError("'{s}' {s}: {s}", .{ name, label, msg });

try run.step.addError("'{s}' {s}", .{ name, label });

if (msg.len > 0) run.step.result_stderr = msg;

fn evalGeneric(run: *Run, child: *std.process.Child) !StdIoResult {

const b = run.step.owner;

const arena = b.allocator;

switch (run.stdin) {

return run.step.fail("unable to write stdin: {s}", .{@errorName(err)});

const path = lazy_path.getPath2(b, &run.step);

const file = b.build_root.handle.openFile(path, .{}) catch |err| {

return run.step.fail("unable to open stdin file: {s}", .{@errorName(err)});

return run.step.fail("unable to write file to stdin: {s}", .{@errorName(err)});

if (poller.fifo(.stdout).count > run.max_stdio_size)

if (poller.fifo(.stderr).count > run.max_stdio_size)

stdout_bytes = try stdout.reader().readAllAlloc(arena, run.max_stdio_size);

stderr_bytes = try stderr.reader().readAllAlloc(arena, run.max_stdio_size);

const stderr_is_diagnostic = run.captured_stderr == null and switch (run.stdio) {

run.step.result_stderr = bytes;

fn addPathForDynLibs(run: *Run, artifact: *Step.Compile) void {

const b = run.step.owner;

addPathDir(run, fs.path.dirname(other.getEmittedBin().getPath2(b, &run.step)).?);

run: *Run,

switch (run.stdio) {

if (run.skip_foreign_checks)

const b = run.step.owner;

return run.step.fail(

return run.step.fail("unable to spawn foreign binary '{s}'", .{argv0});

pub const base_id: Step.Id = .translate_c;

const translate_c = owner.allocator.create(TranslateC) catch @panic("OOM");

translate_c.* = TranslateC{

.id = base_id,

.output_file = std.Build.GeneratedFile{ .step = &translate_c.step },

source.addStepDependencies(&translate_c.step);

return translate_c;

pub fn getOutput(translate_c: *TranslateC) std.Build.LazyPath {

return .{ .generated = .{ .file = &translate_c.output_file } };

pub fn addExecutable(translate_c: *TranslateC, options: AddExecutableOptions) *Step.Compile {

return translate_c.step.owner.addExecutable(.{

.root_source_file = translate_c.getOutput(),

.target = options.target orelse translate_c.target,

.optimize = options.optimize orelse translate_c.optimize,

pub fn addModule(translate_c: *TranslateC, name: []const u8) *std.Build.Module {

return translate_c.step.owner.addModule(name, .{

.root_source_file = translate_c.getOutput(),

pub fn createModule(translate_c: *TranslateC) *std.Build.Module {

return translate_c.step.owner.createModule(.{

.root_source_file = translate_c.getOutput(),

pub fn addIncludeDir(translate_c: *TranslateC, include_dir: []const u8) void {

translate_c.include_dirs.append(translate_c.step.owner.dupePath(include_dir)) catch @panic("OOM");

pub fn addCheckFile(translate_c: *TranslateC, expected_matches: []const []const u8) *Step.CheckFile {

translate_c.step.owner,

translate_c.getOutput(),

pub fn defineCMacro(translate_c: *TranslateC, name: []const u8, value: ?[]const u8) void {

const macro = std.Build.constructranslate_cMacro(translate_c.step.owner.allocator, name, value);

translate_c.c_macros.append(macro) catch @panic("OOM");

pub fn defineCMacroRaw(translate_c: *TranslateC, name_and_value: []const u8) void {

translate_c.c_macros.append(translate_c.step.owner.dupe(name_and_value)) catch @panic("OOM");

const translate_c: *TranslateC = @fieldParentPtr("step", step);

if (translate_c.link_libc) {

if (!translate_c.use_clang) {

if (!translate_c.target.query.isNative()) {

try argv_list.append(try translate_c.target.query.zigTriple(b.allocator));

switch (translate_c.optimize) {

else => try argv_list.append(b.fmt("-O{s}", .{@tagName(translate_c.optimize)})),

for (translate_c.include_dirs.items) |include_dir| {

for (translate_c.c_macros.items) |c_macro| {

try argv_list.append(translate_c.source.getPath2(b, step));

translate_c.out_basename = fs.path.basename(output_path.?);

translate_c.output_file.path = b.pathJoin(&.{ output_dir, translate_c.out_basename });

pub const base_id: Step.Id = .write_file;

pub fn getPath(file: *File) std.Build.LazyPath {

return .{ .generated = .{ .file = &file.generated_file } };

pub fn dupe(opts: Options, b: *std.Build) Options {

.exclude_extensions = b.dupeStrings(opts.exclude_extensions),

.include_extensions = if (opts.include_extensions) |incs| b.dupeStrings(incs) else null,

pub fn getPath(dir: *Directory) std.Build.LazyPath {

return .{ .generated = .{ .file = &dir.generated_dir } };

const write_file = owner.allocator.create(WriteFile) catch @panic("OOM");

write_file.* = .{

.id = base_id,

.generated_directory = .{ .step = &write_file.step },

return write_file;

pub fn add(write_file: *WriteFile, sub_path: []const u8, bytes: []const u8) std.Build.LazyPath {

const b = write_file.step.owner;

.generated_file = .{ .step = &write_file.step },

write_file.files.append(gpa, file) catch @panic("OOM");

write_file.maybeUpdateName();

pub fn addCopyFile(write_file: *WriteFile, source: std.Build.LazyPath, sub_path: []const u8) std.Build.LazyPath {

const b = write_file.step.owner;

.generated_file = .{ .step = &write_file.step },

write_file.files.append(gpa, file) catch @panic("OOM");

write_file.maybeUpdateName();

source.addStepDependencies(&write_file.step);

write_file: *WriteFile,

const b = write_file.step.owner;

.generated_dir = .{ .step = &write_file.step },

write_file.directories.append(gpa, dir) catch @panic("OOM");

write_file.maybeUpdateName();

source.addStepDependencies(&write_file.step);

pub fn addCopyFileToSource(write_file: *WriteFile, source: std.Build.LazyPath, sub_path: []const u8) void {

const b = write_file.step.owner;

write_file.output_source_files.append(b.allocator, .{

source.addStepDependencies(&write_file.step);

pub fn addBytesToSource(write_file: *WriteFile, bytes: []const u8, sub_path: []const u8) void {

const b = write_file.step.owner;

write_file.output_source_files.append(b.allocator, .{

pub fn getDirectory(write_file: *WriteFile) std.Build.LazyPath {

return .{ .generated = .{ .file = &write_file.generated_directory } };

fn maybeUpdateName(write_file: *WriteFile) void {

if (write_file.files.items.len == 1 and write_file.directories.items.len == 0) {

if (std.mem.eql(u8, write_file.step.name, "WriteFile")) {

write_file.step.name = write_file.step.owner.fmt("WriteFile {s}", .{write_file.files.items[0].sub_path});

} else if (write_file.directories.items.len == 1 and write_file.files.items.len == 0) {

if (std.mem.eql(u8, write_file.step.name, "WriteFile")) {

write_file.step.name = write_file.step.owner.fmt("WriteFile {s}", .{write_file.directories.items[0].sub_path});

const write_file: *WriteFile = @fieldParentPtr("step", step);

for (write_file.output_source_files.items) |output_source_file| {

const source_path = file_source.getPath2(b, step);

for (write_file.files.items) |file| {

_ = try man.addFile(file_source.getPath2(b, step), null);

for (write_file.directories.items) |dir| {

for (write_file.files.items) |file| {

write_file.generated_directory.path = try b.cache_root.join(b.allocator, &.{ "o", &digest });

write_file.generated_directory.path = try b.cache_root.join(b.allocator, &.{ "o", &digest });

for (write_file.files.items) |file| {

const source_path = file_source.getPath2(b, step);

for (write_file.directories.items) |dir| {

.run_output_paths = .{

.path = "run_output_paths",

},

.root_source_file = b.path("main.zig"),

lib.addCSourceFile(.{ .file = b.path("shared_lib.c"), .flags = &.{"-gdwarf"} });

.root_source_file = b.path("main.zig"),

.root_source_file = b.path("main.zig"),

.root_source_file = b.path("test_root/empty.zig"),

.root_source_file = b.path("src/empty.zig"),

.root_source_file = b.path("empty.zig"),

.root_source_file = b.path("main.zig"),

.root_source_file = b.path("src/main.zig"),

const std = @import("std");

 

pub fn build(b: *std.Build) void {

const test_step = b.step("test", "Test it");

b.default_step = test_step;

 

const target = b.standardTargetOptions(.{});

const optimize = b.standardOptimizeOption(.{});

 

const create_file_exe = b.addExecutable(.{

.name = "create_file",

.root_source_file = b.path("create_file.zig"),

.target = target,

.optimize = optimize,

});

 

const create_first = b.addRunArtifact(create_file_exe);

const first_dir = create_first.addOutputDirectoryArg("first");

create_first.addArg("hello1.txt");

test_step.dependOn(&b.addCheckFile(first_dir.path(b, "hello1.txt"), .{ .expected_matches = &.{

std.fs.path.sep_str ++

\\first

\\hello1.txt

\\Hello, world!

\\

,

} }).step);

 

const create_second = b.addRunArtifact(create_file_exe);

const second_dir = create_second.addPrefixedOutputDirectoryArg("--dir=", "second");

create_second.addArg("hello2.txt");

test_step.dependOn(&b.addCheckFile(second_dir.path(b, "hello2.txt"), .{ .expected_matches = &.{

std.fs.path.sep_str ++

\\second

\\hello2.txt

\\Hello, world!

\\

,

} }).step);

}

const std = @import("std");

 

pub fn main() !void {

var args = try std.process.argsWithAllocator(std.heap.page_allocator);

_ = args.skip();

const dir_name = args.next().?;

const dir = try std.fs.cwd().openDir(if (std.mem.startsWith(u8, dir_name, "--dir="))

dir_name["--dir=".len..]

else

dir_name, .{});

const file_name = args.next().?;

const file = try dir.createFile(file_name, .{});

try file.writer().print(

\\{s}

\\{s}

\\Hello, world!

\\

, .{ dir_name, file_name });

}

.root_source_file = b.path("breakpipe.zig"),

.root_source_file = b.path("lib.zig"),

.file = b.path("verify.c"),

.root_source_file = b.path("fuzz.zig"),

.root_source_file = b.path("lib.zig"),

.file = b.path("verify.c"),

.{ .generated = .{ .file = &generated_h_step.generated_directory } },

.root_source_file = b.path("hello.zig"),

.root_source_file = b.path("main.zig"),