Nixyri/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2024-11-14 16:13:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

combine std.build and std.build.Builder into std.Build

Browse Source 
I've been wanting to do this for along time.
This commit is contained in:
Andrew Kelley 2023-01-31 00:19:51 -07:00
parent 73cf7b6429
commit 36e2d992dd
97 changed files with 2197 additions and 2257 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
build.zig
View File

@ -1,19 +1,18 @@
const std = @import("std");
const builtin = std.builtin;
const Builder = std.build.Builder;
const tests = @import("test/tests.zig");
const BufMap = std.BufMap;
const mem = std.mem;
const ArrayList = std.ArrayList;
const io = std.io;
const fs = std.fs;
const InstallDirectoryOptions = std.build.InstallDirectoryOptions;
const InstallDirectoryOptions = std.Build.InstallDirectoryOptions;
const assert = std.debug.assert;
const zig_version = std.builtin.Version{ .major = 0, .minor = 11, .patch = 0 };
const stack_size = 32 * 1024 * 1024;
pub fn build(b: *Builder) !void {
pub fn build(b: *std.Build) !void {
const release = b.option(bool, "release", "Build in release mode") orelse false;
const only_c = b.option(bool, "only-c", "Translate the Zig compiler to C code, with only the C backend enabled") orelse false;
const target = t: {
@ -477,7 +476,7 @@ pub fn build(b: *Builder) !void {
try addWasiUpdateStep(b, version);
}
fn addWasiUpdateStep(b: *Builder, version: [:0]const u8) !void {
fn addWasiUpdateStep(b: *std.Build, version: [:0]const u8) !void {
const semver = try std.SemanticVersion.parse(version);
var target: std.zig.CrossTarget = .{
@ -514,10 +513,10 @@ fn addWasiUpdateStep(b: *Builder, version: [:0]const u8) !void {
}
fn addCompilerStep(
b: *Builder,
b: *std.Build,
optimize: std.builtin.OptimizeMode,
target: std.zig.CrossTarget,
) *std.build.LibExeObjStep {
) *std.Build.LibExeObjStep {
const exe = b.addExecutable(.{
.name = "zig",
.root_source_file = .{ .path = "src/main.zig" },
@ -543,9 +542,9 @@ const exe_cflags = [_][]const u8{
};
fn addCmakeCfgOptionsToExe(
b: *Builder,
b: *std.Build,
cfg: CMakeConfig,
exe: *std.build.LibExeObjStep,
exe: *std.Build.LibExeObjStep,
use_zig_libcxx: bool,
) !void {
if (exe.target.isDarwin()) {
@ -624,7 +623,7 @@ fn addCmakeCfgOptionsToExe(
}
}
fn addStaticLlvmOptionsToExe(exe: *std.build.LibExeObjStep) !void {
fn addStaticLlvmOptionsToExe(exe: *std.Build.LibExeObjStep) !void {
// Adds the Zig C++ sources which both stage1 and stage2 need.
//
// We need this because otherwise zig_clang_cc1_main.cpp ends up pulling
@ -661,9 +660,9 @@ fn addStaticLlvmOptionsToExe(exe: *std.build.LibExeObjStep) !void {
}
fn addCxxKnownPath(
b: *Builder,
b: *std.Build,
ctx: CMakeConfig,
exe: *std.build.LibExeObjStep,
exe: *std.Build.LibExeObjStep,
objname: []const u8,
errtxt: ?[]const u8,
need_cpp_includes: bool,
@ -696,7 +695,7 @@ fn addCxxKnownPath(
}
}
fn addCMakeLibraryList(exe: *std.build.LibExeObjStep, list: []const u8) void {
fn addCMakeLibraryList(exe: *std.Build.LibExeObjStep, list: []const u8) void {
var it = mem.tokenize(u8, list, ";");
while (it.next()) |lib| {
if (mem.startsWith(u8, lib, "-l")) {
@ -710,7 +709,7 @@ fn addCMakeLibraryList(exe: *std.build.LibExeObjStep, list: []const u8) void {
}
const CMakeConfig = struct {
llvm_linkage: std.build.LibExeObjStep.Linkage,
llvm_linkage: std.Build.LibExeObjStep.Linkage,
cmake_binary_dir: []const u8,
cmake_prefix_path: []const u8,
cmake_static_library_prefix: []const u8,
@ -727,7 +726,7 @@ const CMakeConfig = struct {
const max_config_h_bytes = 1 * 1024 * 1024;
fn findConfigH(b: *Builder, config_h_path_option: ?[]const u8) ?[]const u8 {
fn findConfigH(b: *std.Build, config_h_path_option: ?[]const u8) ?[]const u8 {
if (config_h_path_option) |path| {
var config_h_or_err = fs.cwd().openFile(path, .{});
if (config_h_or_err) |*file| {
@ -773,7 +772,7 @@ fn findConfigH(b: *Builder, config_h_path_option: ?[]const u8) ?[]const u8 {
} else unreachable; // TODO should not need `else unreachable`.
}
fn parseConfigH(b: *Builder, config_h_text: []const u8) ?CMakeConfig {
fn parseConfigH(b: *std.Build, config_h_text: []const u8) ?CMakeConfig {
var ctx: CMakeConfig = .{
.llvm_linkage = undefined,
.cmake_binary_dir = undefined,
@ -862,7 +861,7 @@ fn parseConfigH(b: *Builder, config_h_text: []const u8) ?CMakeConfig {
return ctx;
}
fn toNativePathSep(b: *Builder, s: []const u8) []u8 {
fn toNativePathSep(b: *std.Build, s: []const u8) []u8 {
const duplicated = b.allocator.dupe(u8, s) catch unreachable;
for (duplicated) |*byte| switch (byte.*) {
'/' => byte.* = fs.path.sep,

20
doc/langref.html.in
View File

@ -9528,9 +9528,9 @@ fn foo(comptime T: type, ptr: *T) T {
To add standard build options to a <code class="file">build.zig</code> file:
</p>
{#code_begin|syntax|build#}
const Builder = @import("std").build.Builder;
const std = @import("std");
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const exe = b.addExecutable(.{
.name = "example",
@ -10551,9 +10551,9 @@ const separator = if (builtin.os.tag == .windows) '\\' else '/';
<p>This <code class="file">build.zig</code> file is automatically generated
by <kbd>zig init-exe</kbd>.</p>
{#code_begin|syntax|build_executable#}
const Builder = @import("std").build.Builder;
const std = @import("std");
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
// Standard target options allows the person running `zig build` to choose
// what target to build for. Here we do not override the defaults, which
// means any target is allowed, and the default is native. Other options
@ -10588,9 +10588,9 @@ pub fn build(b: *Builder) void {
<p>This <code class="file">build.zig</code> file is automatically generated
by <kbd>zig init-lib</kbd>.</p>
{#code_begin|syntax|build_library#}
const Builder = @import("std").build.Builder;
const std = @import("std");
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const lib = b.addStaticLibrary(.{
.name = "example",
@ -10961,9 +10961,9 @@ int main(int argc, char **argv) {
}
{#end_syntax_block#}
{#code_begin|syntax|build_c#}
const Builder = @import("std").build.Builder;
const std = @import("std");
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const lib = b.addSharedLibrary("mathtest", "mathtest.zig", b.version(1, 0, 0));
const exe = b.addExecutable(.{
@ -11025,9 +11025,9 @@ int main(int argc, char **argv) {
}
{#end_syntax_block#}
{#code_begin|syntax|build_object#}
const Builder = @import("std").build.Builder;
const std = @import("std");
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const obj = b.addObject("base64", "base64.zig");
const exe = b.addExecutable(.{

9
lib/build_runner.zig
View File

@ -3,7 +3,6 @@ const std = @import("std");
const builtin = @import("builtin");
const io = std.io;
const fmt = std.fmt;
const Builder = std.build.Builder;
const mem = std.mem;
const process = std.process;
const ArrayList = std.ArrayList;
@ -42,7 +41,7 @@ pub fn main() !void {
return error.InvalidArgs;
};
const builder = try Builder.create(
const builder = try std.Build.create(
allocator,
zig_exe,
build_root,
@ -58,7 +57,7 @@ pub fn main() !void {
const stdout_stream = io.getStdOut().writer();
var install_prefix: ?[]const u8 = null;
var dir_list = Builder.DirList{};
var dir_list = std.Build.DirList{};
// before arg parsing, check for the NO_COLOR environment variable
// if it exists, default the color setting to .off
@ -230,7 +229,7 @@ pub fn main() !void {
};
}
fn usage(builder: *Builder, already_ran_build: bool, out_stream: anytype) !void {
fn usage(builder: *std.Build, already_ran_build: bool, out_stream: anytype) !void {
// run the build script to collect the options
if (!already_ran_build) {
builder.resolveInstallPrefix(null, .{});
@ -330,7 +329,7 @@ fn usage(builder: *Builder, already_ran_build: bool, out_stream: anytype) !void
);
}
fn usageAndErr(builder: *Builder, already_ran_build: bool, out_stream: anytype) void {
fn usageAndErr(builder: *std.Build, already_ran_build: bool, out_stream: anytype) void {
usage(builder, already_ran_build, out_stream) catch {};
process.exit(1);
}

2
lib/init-exe/build.zig
View File

@ -3,7 +3,7 @@ const std = @import("std");
// Although this function looks imperative, note that its job is to
// declaratively construct a build graph that will be executed by an external
// runner.
pub fn build(b: *std.build.Builder) void {
pub fn build(b: *std.Build) void {
// Standard target options allows the person running `zig build` to choose
// what target to build for. Here we do not override the defaults, which
// means any target is allowed, and the default is native. Other options

2
lib/init-lib/build.zig
View File

@ -3,7 +3,7 @@ const std = @import("std");
// Although this function looks imperative, note that its job is to
// declaratively construct a build graph that will be executed by an external
// runner.
pub fn build(b: *std.build.Builder) void {
pub fn build(b: *std.Build) void {
// Standard target options allows the person running `zig build` to choose
// what target to build for. Here we do not override the defaults, which
// means any target is allowed, and the default is native. Other options

1771
lib/std/Build.zig Normal file
View File

File diff suppressed because it is too large Load Diff

12
lib/std/build/CheckFileStep.zig → lib/std/Build/CheckFileStep.zig
View File

@ -1,7 +1,5 @@
const std = @import("../std.zig");
const build = std.build;
const Step = build.Step;
const Builder = build.Builder;
const Step = std.Build.Step;
const fs = std.fs;
const mem = std.mem;
@ -10,14 +8,14 @@ const CheckFileStep = @This();
pub const base_id = .check_file;
step: Step,
builder: *Builder,
builder: *std.Build,
expected_matches: []const []const u8,
source: build.FileSource,
source: std.Build.FileSource,
max_bytes: usize = 20 * 1024 * 1024,
pub fn create(
builder: *Builder,
source: build.FileSource,
builder: *std.Build,
source: std.Build.FileSource,
expected_matches: []const []const u8,
) *CheckFileStep {
const self = builder.allocator.create(CheckFileStep) catch unreachable;

18
lib/std/build/CheckObjectStep.zig → lib/std/Build/CheckObjectStep.zig
View File

@ -1,6 +1,5 @@
const std = @import("../std.zig");
const assert = std.debug.assert;
const build = std.build;
const fs = std.fs;
const macho = std.macho;
const math = std.math;
@ -10,21 +9,20 @@ const testing = std.testing;
const CheckObjectStep = @This();
const Allocator = mem.Allocator;
const Builder = build.Builder;
const Step = build.Step;
const EmulatableRunStep = build.EmulatableRunStep;
const Step = std.Build.Step;
const EmulatableRunStep = std.Build.EmulatableRunStep;
pub const base_id = .check_object;
step: Step,
builder: *Builder,
source: build.FileSource,
builder: *std.Build,
source: std.Build.FileSource,
max_bytes: usize = 20 * 1024 * 1024,
checks: std.ArrayList(Check),
dump_symtab: bool = false,
obj_format: std.Target.ObjectFormat,
pub fn create(builder: *Builder, source: build.FileSource, obj_format: std.Target.ObjectFormat) *CheckObjectStep {
pub fn create(builder: *std.Build, source: std.Build.FileSource, obj_format: std.Target.ObjectFormat) *CheckObjectStep {
const gpa = builder.allocator;
const self = gpa.create(CheckObjectStep) catch unreachable;
self.* = .{
@ -44,7 +42,7 @@ pub fn runAndCompare(self: *CheckObjectStep) *EmulatableRunStep {
const dependencies_len = self.step.dependencies.items.len;
assert(dependencies_len > 0);
const exe_step = self.step.dependencies.items[dependencies_len - 1];
const exe = exe_step.cast(std.build.LibExeObjStep).?;
const exe = exe_step.cast(std.Build.LibExeObjStep).?;
const emulatable_step = EmulatableRunStep.create(self.builder, "EmulatableRun", exe);
emulatable_step.step.dependOn(&self.step);
return emulatable_step;
@ -216,10 +214,10 @@ const ComputeCompareExpected = struct {
};
const Check = struct {
builder: *Builder,
builder: *std.Build,
actions: std.ArrayList(Action),
fn create(b: *Builder) Check {
fn create(b: *std.Build) Check {
return .{
.builder = b,
.actions = std.ArrayList(Action).init(b.allocator),

9
lib/std/build/ConfigHeaderStep.zig → lib/std/Build/ConfigHeaderStep.zig
View File

@ -1,7 +1,6 @@
const std = @import("../std.zig");
const ConfigHeaderStep = @This();
const Step = std.build.Step;
const Builder = std.build.Builder;
const Step = std.Build.Step;
pub const base_id: Step.Id = .config_header;
@ -24,15 +23,15 @@ pub const Value = union(enum) {
};
step: Step,
builder: *Builder,
source: std.build.FileSource,
builder: *std.Build,
source: std.Build.FileSource,
style: Style,
values: std.StringHashMap(Value),
max_bytes: usize = 2 * 1024 * 1024,
output_dir: []const u8,
output_basename: []const u8,
pub fn create(builder: *Builder, source: std.build.FileSource, style: Style) *ConfigHeaderStep {
pub fn create(builder: *std.Build, source: std.Build.FileSource, style: Style) *ConfigHeaderStep {
const self = builder.allocator.create(ConfigHeaderStep) catch @panic("OOM");
const name = builder.fmt("configure header {s}", .{source.getDisplayName()});
self.* = .{

12
lib/std/build/EmulatableRunStep.zig → lib/std/Build/EmulatableRunStep.zig
View File

@ -5,11 +5,9 @@
//! without having to verify if it's possible to be ran against.
const std = @import("../std.zig");
const build = std.build;
const Step = std.build.Step;
const Builder = std.build.Builder;
const LibExeObjStep = std.build.LibExeObjStep;
const RunStep = std.build.RunStep;
const Step = std.Build.Step;
const LibExeObjStep = std.Build.LibExeObjStep;
const RunStep = std.Build.RunStep;
const fs = std.fs;
const process = std.process;
@ -22,7 +20,7 @@ pub const base_id = .emulatable_run;
const max_stdout_size = 1 * 1024 * 1024; // 1 MiB
step: Step,
builder: *Builder,
builder: *std.Build,
/// The artifact (executable) to be run by this step
exe: *LibExeObjStep,
@ -47,7 +45,7 @@ hide_foreign_binaries_warning: bool,
/// binary through emulation when any of the emulation options such as `enable_rosetta` are set to true.
/// When set to false, and the binary is foreign, running the executable is skipped.
/// Asserts given artifact is an executable.
pub fn create(builder: *Builder, name: []const u8, artifact: *LibExeObjStep) *EmulatableRunStep {
pub fn create(builder: *std.Build, name: []const u8, artifact: *LibExeObjStep) *EmulatableRunStep {
std.debug.assert(artifact.kind == .exe or artifact.kind == .test_exe);
const self = builder.allocator.create(EmulatableRunStep) catch unreachable;

11
lib/std/build/FmtStep.zig → lib/std/Build/FmtStep.zig
View File

@ -1,19 +1,14 @@
const std = @import("../std.zig");
const build = @import("../build.zig");
const Step = build.Step;
const Builder = build.Builder;
const BufMap = std.BufMap;
const mem = std.mem;
const Step = std.Build.Step;
const FmtStep = @This();
pub const base_id = .fmt;
step: Step,
builder: *Builder,
builder: *std.Build,
argv: [][]const u8,
pub fn create(builder: *Builder, paths: []const []const u8) *FmtStep {
pub fn create(builder: *std.Build, paths: []const []const u8) *FmtStep {
const self = builder.allocator.create(FmtStep) catch unreachable;
const name = "zig fmt";
self.* = FmtStep{

21
lib/std/build/InstallArtifactStep.zig → lib/std/Build/InstallArtifactStep.zig
View File

@ -1,26 +1,23 @@
const std = @import("../std.zig");
const build = @import("../build.zig");
const Step = build.Step;
const Builder = build.Builder;
const LibExeObjStep = std.build.LibExeObjStep;
const InstallDir = std.build.InstallDir;
const Step = std.Build.Step;
const LibExeObjStep = std.Build.LibExeObjStep;
const InstallDir = std.Build.InstallDir;
const InstallArtifactStep = @This();
pub const base_id = .install_artifact;
step: Step,
builder: *Builder,
builder: *std.Build,
artifact: *LibExeObjStep,
dest_dir: InstallDir,
pdb_dir: ?InstallDir,
h_dir: ?InstallDir,
const Self = @This();
pub fn create(builder: *Builder, artifact: *LibExeObjStep) *Self {
pub fn create(builder: *std.Build, artifact: *LibExeObjStep) *InstallArtifactStep {
if (artifact.install_step) |s| return s;
const self = builder.allocator.create(Self) catch unreachable;
self.* = Self{
const self = builder.allocator.create(InstallArtifactStep) catch unreachable;
self.* = InstallArtifactStep{
.builder = builder,
.step = Step.init(.install_artifact, builder.fmt("install {s}", .{artifact.step.name}), builder.allocator, make),
.artifact = artifact,
@ -64,7 +61,7 @@ pub fn create(builder: *Builder, artifact: *LibExeObjStep) *Self {
}
fn make(step: *Step) !void {
const self = @fieldParentPtr(Self, "step", step);
const self = @fieldParentPtr(InstallArtifactStep, "step", step);
const builder = self.builder;
const full_dest_path = builder.getInstallPath(self.dest_dir, self.artifact.out_filename);

14
lib/std/build/InstallDirStep.zig → lib/std/Build/InstallDirStep.zig
View File

@ -1,19 +1,17 @@
const std = @import("../std.zig");
const mem = std.mem;
const fs = std.fs;
const build = @import("../build.zig");
const Step = build.Step;
const Builder = build.Builder;
const InstallDir = std.build.InstallDir;
const Step = std.Build.Step;
const InstallDir = std.Build.InstallDir;
const InstallDirStep = @This();
const log = std.log;
step: Step,
builder: *Builder,
builder: *std.Build,
options: Options,
/// This is used by the build system when a file being installed comes from one
/// package but is being installed by another.
override_source_builder: ?*Builder = null,
override_source_builder: ?*std.Build = null,
pub const base_id = .install_dir;
@ -31,7 +29,7 @@ pub const Options = struct {
/// `@import("test.zig")` would be a compile error.
blank_extensions: []const []const u8 = &.{},
fn dupe(self: Options, b: *Builder) Options {
fn dupe(self: Options, b: *std.Build) Options {
return .{
.source_dir = b.dupe(self.source_dir),
.install_dir = self.install_dir.dupe(b),
@ -43,7 +41,7 @@ pub const Options = struct {
};
pub fn init(
builder: *Builder,
builder: *std.Build,
options: Options,
) InstallDirStep {
builder.pushInstalledFile(options.install_dir, options.install_subdir);

14
lib/std/build/InstallFileStep.zig → lib/std/Build/InstallFileStep.zig
View File

@ -1,24 +1,22 @@
const std = @import("../std.zig");
const build = @import("../build.zig");
const Step = build.Step;
const Builder = build.Builder;
const FileSource = std.build.FileSource;
const InstallDir = std.build.InstallDir;
const Step = std.Build.Step;
const FileSource = std.Build.FileSource;
const InstallDir = std.Build.InstallDir;
const InstallFileStep = @This();
pub const base_id = .install_file;
step: Step,
builder: *Builder,
builder: *std.Build,
source: FileSource,
dir: InstallDir,
dest_rel_path: []const u8,
/// This is used by the build system when a file being installed comes from one
/// package but is being installed by another.
override_source_builder: ?*Builder = null,
override_source_builder: ?*std.Build = null,
pub fn init(
builder: *Builder,
builder: *std.Build,
source: FileSource,
dir: InstallDir,
dest_rel_path: []const u8,

24
lib/std/build/InstallRawStep.zig → lib/std/Build/InstallRawStep.zig
View File

@ -7,11 +7,10 @@ const InstallRawStep = @This();
const Allocator = std.mem.Allocator;
const ArenaAllocator = std.heap.ArenaAllocator;
const ArrayListUnmanaged = std.ArrayListUnmanaged;
const Builder = std.build.Builder;
const File = std.fs.File;
const InstallDir = std.build.InstallDir;
const LibExeObjStep = std.build.LibExeObjStep;
const Step = std.build.Step;
const InstallDir = std.Build.InstallDir;
const LibExeObjStep = std.Build.LibExeObjStep;
const Step = std.Build.Step;
const elf = std.elf;
const fs = std.fs;
const io = std.io;
@ -25,12 +24,12 @@ pub const RawFormat = enum {
};
step: Step,
builder: *Builder,
builder: *std.Build,
artifact: *LibExeObjStep,
dest_dir: InstallDir,
dest_filename: []const u8,
options: CreateOptions,
output_file: std.build.GeneratedFile,
output_file: std.Build.GeneratedFile,
pub const CreateOptions = struct {
format: ?RawFormat = null,
@ -39,7 +38,12 @@ pub const CreateOptions = struct {
pad_to: ?u64 = null,
};
pub fn create(builder: *Builder, artifact: *LibExeObjStep, dest_filename: []const u8, options: CreateOptions) *InstallRawStep {
pub fn create(
builder: *std.Build,
artifact: *LibExeObjStep,
dest_filename: []const u8,
options: CreateOptions,
) *InstallRawStep {
const self = builder.allocator.create(InstallRawStep) catch unreachable;
self.* = InstallRawStep{
.step = Step.init(.install_raw, builder.fmt("install raw binary {s}", .{artifact.step.name}), builder.allocator, make),
@ -53,7 +57,7 @@ pub fn create(builder: *Builder, artifact: *LibExeObjStep, dest_filename: []cons
},
.dest_filename = dest_filename,
.options = options,
.output_file = std.build.GeneratedFile{ .step = &self.step },
.output_file = std.Build.GeneratedFile{ .step = &self.step },
};
self.step.dependOn(&artifact.step);
@ -61,8 +65,8 @@ pub fn create(builder: *Builder, artifact: *LibExeObjStep, dest_filename: []cons
return self;
}
pub fn getOutputSource(self: *const InstallRawStep) std.build.FileSource {
return std.build.FileSource{ .generated = &self.output_file };
pub fn getOutputSource(self: *const InstallRawStep) std.Build.FileSource {
return std.Build.FileSource{ .generated = &self.output_file };
}
fn make(step: *Step) !void {

62
lib/std/build/LibExeObjStep.zig → lib/std/Build/LibExeObjStep.zig
View File

@ -9,32 +9,30 @@ const ArrayList = std.ArrayList;
const StringHashMap = std.StringHashMap;
const Sha256 = std.crypto.hash.sha2.Sha256;
const Allocator = mem.Allocator;
const build = @import("../build.zig");
const Step = build.Step;
const Builder = build.Builder;
const Step = std.Build.Step;
const CrossTarget = std.zig.CrossTarget;
const NativeTargetInfo = std.zig.system.NativeTargetInfo;
const FileSource = std.build.FileSource;
const PkgConfigPkg = Builder.PkgConfigPkg;
const PkgConfigError = Builder.PkgConfigError;
const ExecError = Builder.ExecError;
const Pkg = std.build.Pkg;
const VcpkgRoot = std.build.VcpkgRoot;
const InstallDir = std.build.InstallDir;
const InstallArtifactStep = std.build.InstallArtifactStep;
const GeneratedFile = std.build.GeneratedFile;
const InstallRawStep = std.build.InstallRawStep;
const EmulatableRunStep = std.build.EmulatableRunStep;
const CheckObjectStep = std.build.CheckObjectStep;
const RunStep = std.build.RunStep;
const OptionsStep = std.build.OptionsStep;
const ConfigHeaderStep = std.build.ConfigHeaderStep;
const FileSource = std.Build.FileSource;
const PkgConfigPkg = std.Build.PkgConfigPkg;
const PkgConfigError = std.Build.PkgConfigError;
const ExecError = std.Build.ExecError;
const Pkg = std.Build.Pkg;
const VcpkgRoot = std.Build.VcpkgRoot;
const InstallDir = std.Build.InstallDir;
const InstallArtifactStep = std.Build.InstallArtifactStep;
const GeneratedFile = std.Build.GeneratedFile;
const InstallRawStep = std.Build.InstallRawStep;
const EmulatableRunStep = std.Build.EmulatableRunStep;
const CheckObjectStep = std.Build.CheckObjectStep;
const RunStep = std.Build.RunStep;
const OptionsStep = std.Build.OptionsStep;
const ConfigHeaderStep = std.Build.ConfigHeaderStep;
const LibExeObjStep = @This();
pub const base_id = .lib_exe_obj;
step: Step,
builder: *Builder,
builder: *std.Build,
name: []const u8,
target: CrossTarget,
target_info: NativeTargetInfo,
@ -84,7 +82,7 @@ initial_memory: ?u64 = null,
max_memory: ?u64 = null,
shared_memory: bool = false,
global_base: ?u64 = null,
c_std: Builder.CStd,
c_std: std.Build.CStd,
override_lib_dir: ?[]const u8,
main_pkg_path: ?[]const u8,
exec_cmd_args: ?[]const ?[]const u8,
@ -108,7 +106,7 @@ object_src: []const u8,
link_objects: ArrayList(LinkObject),
include_dirs: ArrayList(IncludeDir),
c_macros: ArrayList([]const u8),
installed_headers: ArrayList(*std.build.Step),
installed_headers: ArrayList(*Step),
output_dir: ?[]const u8,
is_linking_libc: bool = false,
is_linking_libcpp: bool = false,
@ -226,7 +224,7 @@ pub const CSourceFile = struct {
source: FileSource,
args: []const []const u8,
pub fn dupe(self: CSourceFile, b: *Builder) CSourceFile {
pub fn dupe(self: CSourceFile, b: *std.Build) CSourceFile {
return .{
.source = self.source.dupe(b),
.args = b.dupeStrings(self.args),
@ -297,7 +295,7 @@ pub const EmitOption = union(enum) {
emit: void,
emit_to: []const u8,
fn getArg(self: @This(), b: *Builder, arg_name: []const u8) ?[]const u8 {
fn getArg(self: @This(), b: *std.Build, arg_name: []const u8) ?[]const u8 {
return switch (self) {
.no_emit => b.fmt("-fno-{s}", .{arg_name}),
.default => null,
@ -307,7 +305,7 @@ pub const EmitOption = union(enum) {
}
};
pub fn create(builder: *Builder, options: Options) *LibExeObjStep {
pub fn create(builder: *std.Build, options: Options) *LibExeObjStep {
const name = builder.dupe(options.name);
const root_src: ?FileSource = if (options.root_source_file) |rsrc| rsrc.dupe(builder) else null;
if (mem.indexOf(u8, name, "/") != null or mem.indexOf(u8, name, "\\") != null) {
@ -343,9 +341,9 @@ pub fn create(builder: *Builder, options: Options) *LibExeObjStep {
.lib_paths = ArrayList([]const u8).init(builder.allocator),
.rpaths = ArrayList([]const u8).init(builder.allocator),
.framework_dirs = ArrayList([]const u8).init(builder.allocator),
.installed_headers = ArrayList(*std.build.Step).init(builder.allocator),
.installed_headers = ArrayList(*Step).init(builder.allocator),
.object_src = undefined,
.c_std = Builder.CStd.C99,
.c_std = std.Build.CStd.C99,
.override_lib_dir = null,
.main_pkg_path = null,
.exec_cmd_args = null,
@ -461,7 +459,7 @@ pub fn installHeadersDirectory(
pub fn installHeadersDirectoryOptions(
a: *LibExeObjStep,
options: std.build.InstallDirStep.Options,
options: std.Build.InstallDirStep.Options,
) void {
const install_dir = a.builder.addInstallDirectory(options);
a.builder.getInstallStep().dependOn(&install_dir.step);
@ -600,7 +598,7 @@ pub fn linkLibCpp(self: *LibExeObjStep) void {
/// If the value is omitted, it is set to 1.
/// `name` and `value` need not live longer than the function call.
pub fn defineCMacro(self: *LibExeObjStep, name: []const u8, value: ?[]const u8) void {
const macro = std.build.constructCMacro(self.builder.allocator, name, value);
const macro = std.Build.constructCMacro(self.builder.allocator, name, value);
self.c_macros.append(macro) catch unreachable;
}
@ -1460,7 +1458,7 @@ fn make(step: *Step) !void {
if (!self.target.isNative()) {
try zig_args.appendSlice(&.{
"-target", try self.target.zigTriple(builder.allocator),
"-mcpu", try build.serializeCpu(builder.allocator, self.target.getCpu()),
"-mcpu", try std.Build.serializeCpu(builder.allocator, self.target.getCpu()),
});
if (self.target.dynamic_linker.get()) |dynamic_linker| {
@ -1902,7 +1900,7 @@ pub fn doAtomicSymLinks(allocator: Allocator, output_path: []const u8, filename_
};
}
fn execPkgConfigList(self: *Builder, out_code: *u8) (PkgConfigError || ExecError)![]const PkgConfigPkg {
fn execPkgConfigList(self: *std.Build, out_code: *u8) (PkgConfigError || ExecError)![]const PkgConfigPkg {
const stdout = try self.execAllowFail(&[_][]const u8{ "pkg-config", "--list-all" }, out_code, .Ignore);
var list = ArrayList(PkgConfigPkg).init(self.allocator);
errdefer list.deinit();
@ -1918,7 +1916,7 @@ fn execPkgConfigList(self: *Builder, out_code: *u8) (PkgConfigError || ExecError
return list.toOwnedSlice();
}
fn getPkgConfigList(self: *Builder) ![]const PkgConfigPkg {
fn getPkgConfigList(self: *std.Build) ![]const PkgConfigPkg {
if (self.pkg_config_pkg_list) |res| {
return res;
}
@ -1948,7 +1946,7 @@ test "addPackage" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var builder = try Builder.create(
var builder = try std.Build.create(
arena.allocator(),
"test",
"test",

8
lib/std/build/LogStep.zig → lib/std/Build/LogStep.zig
View File

@ -1,17 +1,15 @@
const std = @import("../std.zig");
const log = std.log;
const build = @import("../build.zig");
const Step = build.Step;
const Builder = build.Builder;
const Step = std.Build.Step;
const LogStep = @This();
pub const base_id = .log;
step: Step,
builder: *Builder,
builder: *std.Build,
data: []const u8,
pub fn init(builder: *Builder, data: []const u8) LogStep {
pub fn init(builder: *std.Build, data: []const u8) LogStep {
return LogStep{
.builder = builder,
.step = Step.init(.log, builder.fmt("log {s}", .{data}), builder.allocator, make),

18
lib/std/build/OptionsStep.zig → lib/std/Build/OptionsStep.zig
View File

@ -1,12 +1,10 @@
const std = @import("../std.zig");
const builtin = @import("builtin");
const build = std.build;
const fs = std.fs;
const Step = build.Step;
const Builder = build.Builder;
const GeneratedFile = build.GeneratedFile;
const LibExeObjStep = build.LibExeObjStep;
const FileSource = build.FileSource;
const Step = std.Build.Step;
const GeneratedFile = std.Build.GeneratedFile;
const LibExeObjStep = std.Build.LibExeObjStep;
const FileSource = std.Build.FileSource;
const OptionsStep = @This();
@ -14,13 +12,13 @@ pub const base_id = .options;
step: Step,
generated_file: GeneratedFile,
builder: *Builder,
builder: *std.Build,
contents: std.ArrayList(u8),
artifact_args: std.ArrayList(OptionArtifactArg),
file_source_args: std.ArrayList(OptionFileSourceArg),
pub fn create(builder: *Builder) *OptionsStep {
pub fn create(builder: *std.Build) *OptionsStep {
const self = builder.allocator.create(OptionsStep) catch unreachable;
self.* = .{
.builder = builder,
@ -202,7 +200,7 @@ pub fn addOptionArtifact(self: *OptionsStep, name: []const u8, artifact: *LibExe
self.step.dependOn(&artifact.step);
}
pub fn getPackage(self: *OptionsStep, package_name: []const u8) build.Pkg {
pub fn getPackage(self: *OptionsStep, package_name: []const u8) std.Build.Pkg {
return .{ .name = package_name, .source = self.getSource() };
}
@ -281,7 +279,7 @@ test "OptionsStep" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var builder = try Builder.create(
var builder = try std.Build.create(
arena.allocator(),
"test",
"test",

8
lib/std/build/RemoveDirStep.zig → lib/std/Build/RemoveDirStep.zig
View File

@ -1,18 +1,16 @@
const std = @import("../std.zig");
const log = std.log;
const fs = std.fs;
const build = @import("../build.zig");
const Step = build.Step;
const Builder = build.Builder;
const Step = std.Build.Step;
const RemoveDirStep = @This();
pub const base_id = .remove_dir;
step: Step,
builder: *Builder,
builder: *std.Build,
dir_path: []const u8,
pub fn init(builder: *Builder, dir_path: []const u8) RemoveDirStep {
pub fn init(builder: *std.Build, dir_path: []const u8) RemoveDirStep {
return RemoveDirStep{
.builder = builder,
.step = Step.init(.remove_dir, builder.fmt("RemoveDir {s}", .{dir_path}), builder.allocator, make),

26
lib/std/build/RunStep.zig → lib/std/Build/RunStep.zig
View File

@ -1,17 +1,15 @@
const std = @import("../std.zig");
const builtin = @import("builtin");
const build = std.build;
const Step = build.Step;
const Builder = build.Builder;
const LibExeObjStep = build.LibExeObjStep;
const WriteFileStep = build.WriteFileStep;
const Step = std.Build.Step;
const LibExeObjStep = std.Build.LibExeObjStep;
const WriteFileStep = std.Build.WriteFileStep;
const fs = std.fs;
const mem = std.mem;
const process = std.process;
const ArrayList = std.ArrayList;
const EnvMap = process.EnvMap;
const Allocator = mem.Allocator;
const ExecError = build.Builder.ExecError;
const ExecError = std.Build.ExecError;
const max_stdout_size = 1 * 1024 * 1024; // 1 MiB
@ -20,7 +18,7 @@ const RunStep = @This();
pub const base_id: Step.Id = .run;
step: Step,
builder: *Builder,
builder: *std.Build,
/// See also addArg and addArgs to modifying this directly
argv: ArrayList(Arg),
@ -51,11 +49,11 @@ pub const StdIoAction = union(enum) {
pub const Arg = union(enum) {
artifact: *LibExeObjStep,
file_source: build.FileSource,
file_source: std.Build.FileSource,
bytes: []u8,
};
pub fn create(builder: *Builder, name: []const u8) *RunStep {
pub fn create(builder: *std.Build, name: []const u8) *RunStep {
const self = builder.allocator.create(RunStep) catch unreachable;
self.* = RunStep{
.builder = builder,
@ -73,7 +71,7 @@ pub fn addArtifactArg(self: *RunStep, artifact: *LibExeObjStep) void {
self.step.dependOn(&artifact.step);
}
pub fn addFileSourceArg(self: *RunStep, file_source: build.FileSource) void {
pub fn addFileSourceArg(self: *RunStep, file_source: std.Build.FileSource) void {
self.argv.append(Arg{
.file_source = file_source.dupe(self.builder),
}) catch unreachable;
@ -101,7 +99,7 @@ pub fn addPathDir(self: *RunStep, search_path: []const u8) void {
}
/// For internal use only, users of `RunStep` should use `addPathDir` directly.
pub fn addPathDirInternal(step: *Step, builder: *Builder, search_path: []const u8) void {
pub fn addPathDirInternal(step: *Step, builder: *std.Build, search_path: []const u8) void {
const env_map = getEnvMapInternal(step, builder.allocator);
const key = "PATH";
@ -122,7 +120,7 @@ pub fn getEnvMap(self: *RunStep) *EnvMap {
fn getEnvMapInternal(step: *Step, allocator: Allocator) *EnvMap {
const maybe_env_map = switch (step.id) {
.run => step.cast(RunStep).?.env_map,
.emulatable_run => step.cast(build.EmulatableRunStep).?.env_map,
.emulatable_run => step.cast(std.Build.EmulatableRunStep).?.env_map,
else => unreachable,
};
return maybe_env_map orelse {
@ -195,7 +193,7 @@ fn make(step: *Step) !void {
pub fn runCommand(
argv: []const []const u8,
builder: *Builder,
builder: *std.Build,
expected_exit_code: ?u8,
stdout_action: StdIoAction,
stderr_action: StdIoAction,
@ -363,7 +361,7 @@ fn addPathForDynLibs(self: *RunStep, artifact: *LibExeObjStep) void {
/// This should only be used for internal usage, this is called automatically
/// for the user.
pub fn addPathForDynLibsInternal(step: *Step, builder: *Builder, artifact: *LibExeObjStep) void {
pub fn addPathForDynLibsInternal(step: *Step, builder: *std.Build, artifact: *LibExeObjStep) void {
for (artifact.link_objects.items) |link_object| {
switch (link_object) {
.other_step => |other| {

97
lib/std/Build/Step.zig Normal file
View File

@ -0,0 +1,97 @@
id: Id,
name: []const u8,
makeFn: *const fn (self: *Step) anyerror!void,
dependencies: std.ArrayList(*Step),
loop_flag: bool,
done_flag: bool,
pub const Id = enum {
top_level,
lib_exe_obj,
install_artifact,
install_file,
install_dir,
log,
remove_dir,
fmt,
translate_c,
write_file,
run,
emulatable_run,
check_file,
check_object,
config_header,
install_raw,
options,
custom,
pub fn Type(comptime id: Id) type {
return switch (id) {
.top_level => Build.TopLevelStep,
.lib_exe_obj => Build.LibExeObjStep,
.install_artifact => Build.InstallArtifactStep,
.install_file => Build.InstallFileStep,
.install_dir => Build.InstallDirStep,
.log => Build.LogStep,
.remove_dir => Build.RemoveDirStep,
.fmt => Build.FmtStep,
.translate_c => Build.TranslateCStep,
.write_file => Build.WriteFileStep,
.run => Build.RunStep,
.emulatable_run => Build.EmulatableRunStep,
.check_file => Build.CheckFileStep,
.check_object => Build.CheckObjectStep,
.config_header => Build.ConfigHeaderStep,
.install_raw => Build.InstallRawStep,
.options => Build.OptionsStep,
.custom => @compileError("no type available for custom step"),
};
}
};
pub fn init(
id: Id,
name: []const u8,
allocator: Allocator,
makeFn: *const fn (self: *Step) anyerror!void,
) Step {
return Step{
.id = id,
.name = allocator.dupe(u8, name) catch unreachable,
.makeFn = makeFn,
.dependencies = std.ArrayList(*Step).init(allocator),
.loop_flag = false,
.done_flag = false,
};
}
pub fn initNoOp(id: Id, name: []const u8, allocator: Allocator) Step {
return init(id, name, allocator, makeNoOp);
}
pub fn make(self: *Step) !void {
if (self.done_flag) return;
try self.makeFn(self);
self.done_flag = true;
}
pub fn dependOn(self: *Step, other: *Step) void {
self.dependencies.append(other) catch unreachable;
}
fn makeNoOp(self: *Step) anyerror!void {
_ = self;
}
pub fn cast(step: *Step, comptime T: type) ?*T {
if (step.id == T.base_id) {
return @fieldParentPtr(T, "step", step);
}
return null;
}
const Step = @This();
const std = @import("../std.zig");
const Build = std.Build;
const Allocator = std.mem.Allocator;

22
lib/std/build/TranslateCStep.zig → lib/std/Build/TranslateCStep.zig
View File

@ -1,9 +1,7 @@
const std = @import("../std.zig");
const build = std.build;
const Step = build.Step;
const Builder = build.Builder;
const LibExeObjStep = build.LibExeObjStep;
const CheckFileStep = build.CheckFileStep;
const Step = std.Build.Step;
const LibExeObjStep = std.Build.LibExeObjStep;
const CheckFileStep = std.Build.CheckFileStep;
const fs = std.fs;
const mem = std.mem;
const CrossTarget = std.zig.CrossTarget;
@ -13,23 +11,23 @@ const TranslateCStep = @This();
pub const base_id = .translate_c;
step: Step,
builder: *Builder,
source: build.FileSource,
builder: *std.Build,
source: std.Build.FileSource,
include_dirs: std.ArrayList([]const u8),
c_macros: std.ArrayList([]const u8),
output_dir: ?[]const u8,
out_basename: []const u8,
target: CrossTarget,
optimize: std.builtin.OptimizeMode,
output_file: build.GeneratedFile,
output_file: std.Build.GeneratedFile,
pub const Options = struct {
source_file: build.FileSource,
source_file: std.Build.FileSource,
target: CrossTarget,
optimize: std.builtin.OptimizeMode,
};
pub fn create(builder: *Builder, options: Options) *TranslateCStep {
pub fn create(builder: *std.Build, options: Options) *TranslateCStep {
const self = builder.allocator.create(TranslateCStep) catch unreachable;
const source = options.source_file.dupe(builder);
self.* = TranslateCStep{
@ -42,7 +40,7 @@ pub fn create(builder: *Builder, options: Options) *TranslateCStep {
.out_basename = undefined,
.target = options.target,
.optimize = options.optimize,
.output_file = build.GeneratedFile{ .step = &self.step },
.output_file = std.Build.GeneratedFile{ .step = &self.step },
};
source.addStepDependencies(&self.step);
return self;
@ -79,7 +77,7 @@ pub fn addCheckFile(self: *TranslateCStep, expected_matches: []const []const u8)
/// If the value is omitted, it is set to 1.
/// `name` and `value` need not live longer than the function call.
pub fn defineCMacro(self: *TranslateCStep, name: []const u8, value: ?[]const u8) void {
const macro = build.constructCMacro(self.builder.allocator, name, value);
const macro = std.Build.constructCMacro(self.builder.allocator, name, value);
self.c_macros.append(macro) catch unreachable;
}

16
lib/std/build/WriteFileStep.zig → lib/std/Build/WriteFileStep.zig
View File

@ -1,7 +1,5 @@
const std = @import("../std.zig");
const build = @import("../build.zig");
const Step = build.Step;
const Builder = build.Builder;
const Step = std.Build.Step;
const fs = std.fs;
const ArrayList = std.ArrayList;
@ -10,17 +8,17 @@ const WriteFileStep = @This();
pub const base_id = .write_file;
step: Step,
builder: *Builder,
builder: *std.Build,
output_dir: []const u8,
files: std.TailQueue(File),
pub const File = struct {
source: build.GeneratedFile,
source: std.Build.GeneratedFile,
basename: []const u8,
bytes: []const u8,
};
pub fn init(builder: *Builder) WriteFileStep {
pub fn init(builder: *std.Build) WriteFileStep {
return WriteFileStep{
.builder = builder,
.step = Step.init(.write_file, "writefile", builder.allocator, make),
@ -33,7 +31,7 @@ pub fn add(self: *WriteFileStep, basename: []const u8, bytes: []const u8) void {
const node = self.builder.allocator.create(std.TailQueue(File).Node) catch unreachable;
node.* = .{
.data = .{
.source = build.GeneratedFile{ .step = &self.step },
.source = std.Build.GeneratedFile{ .step = &self.step },
.basename = self.builder.dupePath(basename),
.bytes = self.builder.dupe(bytes),
},
@ -43,11 +41,11 @@ pub fn add(self: *WriteFileStep, basename: []const u8, bytes: []const u8) void {
}
/// Gets a file source for the given basename. If the file does not exist, returns `null`.
pub fn getFileSource(step: *WriteFileStep, basename: []const u8) ?build.FileSource {
pub fn getFileSource(step: *WriteFileStep, basename: []const u8) ?std.Build.FileSource {
var it = step.files.first;
while (it) |node| : (it = node.next) {
if (std.mem.eql(u8, node.data.basename, basename))
return build.FileSource{ .generated = &node.data.source };
return std.Build.FileSource{ .generated = &node.data.source };
}
return null;
}

1863
lib/std/build.zig
View File

File diff suppressed because it is too large Load Diff

8
lib/std/std.zig
View File

@ -9,6 +9,7 @@ pub const AutoArrayHashMapUnmanaged = array_hash_map.AutoArrayHashMapUnmanaged;
pub const AutoHashMap = hash_map.AutoHashMap;
pub const AutoHashMapUnmanaged = hash_map.AutoHashMapUnmanaged;
pub const BoundedArray = @import("bounded_array.zig").BoundedArray;
pub const Build = @import("Build.zig");
pub const BufMap = @import("buf_map.zig").BufMap;
pub const BufSet = @import("buf_set.zig").BufSet;
pub const ChildProcess = @import("child_process.zig").ChildProcess;
@ -49,7 +50,6 @@ pub const array_hash_map = @import("array_hash_map.zig");
pub const atomic = @import("atomic.zig");
pub const base64 = @import("base64.zig");
pub const bit_set = @import("bit_set.zig");
pub const build = @import("build.zig");
pub const builtin = @import("builtin.zig");
pub const c = @import("c.zig");
pub const coff = @import("coff.zig");
@ -96,6 +96,12 @@ pub const wasm = @import("wasm.zig");
pub const zig = @import("zig.zig");
pub const start = @import("start.zig");
///// Deprecated. Use `std.Build` instead.
//pub const build = struct {
// /// Deprecated. Use `std.Build` instead.
// pub const Builder = Build;
//};
const root = @import("root");
const options_override = if (@hasDecl(root, "std_options")) root.std_options else struct {};

4
test/link/bss/build.zig
View File

@ -1,6 +1,6 @@
const Builder = @import("std").build.Builder;
const std = @import("std");
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const test_step = b.step("test", "Test");

4
test/link/common_symbols/build.zig
View File

@ -1,6 +1,6 @@
const Builder = @import("std").build.Builder;
const std = @import("std");
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const lib_a = b.addStaticLibrary(.{

4
test/link/common_symbols_alignment/build.zig
View File

@ -1,6 +1,6 @@
const Builder = @import("std").build.Builder;
const std = @import("std");
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const target = b.standardTargetOptions(.{});

4
test/link/interdependent_static_c_libs/build.zig
View File

@ -1,6 +1,6 @@
const Builder = @import("std").build.Builder;
const std = @import("std");
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const target = b.standardTargetOptions(.{});

3
test/link/macho/bugs/13056/build.zig
View File

@ -1,7 +1,6 @@
const std = @import("std");
const Builder = std.build.Builder;
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const target: std.zig.CrossTarget = .{ .os_tag = .macos };

5
test/link/macho/bugs/13457/build.zig
View File

@ -1,8 +1,7 @@
const std = @import("std");
const Builder = std.build.Builder;
const LibExeObjectStep = std.build.LibExeObjStep;
const LibExeObjectStep = std.Build.LibExeObjStep;
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const target: std.zig.CrossTarget = .{ .os_tag = .macos };

7
test/link/macho/dead_strip/build.zig
View File

@ -1,8 +1,7 @@
const std = @import("std");
const Builder = std.build.Builder;
const LibExeObjectStep = std.build.LibExeObjStep;
const LibExeObjectStep = std.Build.LibExeObjStep;
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const target: std.zig.CrossTarget = .{ .os_tag = .macos };
@ -37,7 +36,7 @@ pub fn build(b: *Builder) void {
}
}
fn createScenario(b: *Builder, optimize: std.builtin.OptimizeMode, target: std.zig.CrossTarget) *LibExeObjectStep {
fn createScenario(b: *std.Build, optimize: std.builtin.OptimizeMode, target: std.zig.CrossTarget) *LibExeObjectStep {
const exe = b.addExecutable(.{
.name = "test",
.optimize = optimize,

7
test/link/macho/dead_strip_dylibs/build.zig
View File

@ -1,8 +1,7 @@
const std = @import("std");
const Builder = std.build.Builder;
const LibExeObjectStep = std.build.LibExeObjStep;
const LibExeObjectStep = std.Build.LibExeObjStep;
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const test_step = b.step("test", "Test the program");
@ -36,7 +35,7 @@ pub fn build(b: *Builder) void {
}
}
fn createScenario(b: *Builder, optimize: std.builtin.OptimizeMode) *LibExeObjectStep {
fn createScenario(b: *std.Build, optimize: std.builtin.OptimizeMode) *LibExeObjectStep {
const exe = b.addExecutable(.{
.name = "test",
.optimize = optimize,

3
test/link/macho/dylib/build.zig
View File

@ -1,7 +1,6 @@
const std = @import("std");
const Builder = std.build.Builder;
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const target: std.zig.CrossTarget = .{ .os_tag = .macos };

5
test/link/macho/empty/build.zig
View File

@ -1,7 +1,6 @@
const std = @import("std");
const Builder = std.build.Builder;
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const target: std.zig.CrossTarget = .{ .os_tag = .macos };
@ -17,7 +16,7 @@ pub fn build(b: *Builder) void {
exe.addCSourceFile("empty.c", &[0][]const u8{});
exe.linkLibC();
const run_cmd = std.build.EmulatableRunStep.create(b, "run", exe);
const run_cmd = std.Build.EmulatableRunStep.create(b, "run", exe);
run_cmd.expectStdOutEqual("Hello!\n");
test_step.dependOn(&run_cmd.step);
}

3
test/link/macho/entry/build.zig
View File

@ -1,7 +1,6 @@
const std = @import("std");
const Builder = std.build.Builder;
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const test_step = b.step("test", "Test");

7
test/link/macho/headerpad/build.zig
View File

@ -1,9 +1,8 @@
const std = @import("std");
const builtin = @import("builtin");
const Builder = std.build.Builder;
const LibExeObjectStep = std.build.LibExeObjStep;
const LibExeObjectStep = std.Build.LibExeObjStep;
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const test_step = b.step("test", "Test");
@ -94,7 +93,7 @@ pub fn build(b: *Builder) void {
}
}
fn simpleExe(b: *Builder, optimize: std.builtin.OptimizeMode) *LibExeObjectStep {
fn simpleExe(b: *std.Build, optimize: std.builtin.OptimizeMode) *LibExeObjectStep {
const exe = b.addExecutable(.{
.name = "main",
.optimize = optimize,

2
test/link/macho/linksection/build.zig
View File

@ -1,6 +1,6 @@
const std = @import("std");
pub fn build(b: *std.build.Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const target = std.zig.CrossTarget{ .os_tag = .macos };

5
test/link/macho/needed_framework/build.zig
View File

@ -1,8 +1,7 @@
const std = @import("std");
const Builder = std.build.Builder;
const LibExeObjectStep = std.build.LibExeObjStep;
const LibExeObjectStep = std.Build.LibExeObjStep;
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const test_step = b.step("test", "Test the program");

5
test/link/macho/needed_library/build.zig
View File

@ -1,8 +1,7 @@
const std = @import("std");
const Builder = std.build.Builder;
const LibExeObjectStep = std.build.LibExeObjStep;
const LibExeObjectStep = std.Build.LibExeObjStep;
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const target: std.zig.CrossTarget = .{ .os_tag = .macos };

5
test/link/macho/objc/build.zig
View File

@ -1,7 +1,6 @@
const std = @import("std");
const Builder = std.build.Builder;
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const test_step = b.step("test", "Test the program");
@ -18,6 +17,6 @@ pub fn build(b: *Builder) void {
// populate paths to the sysroot here.
exe.linkFramework("Foundation");
const run_cmd = std.build.EmulatableRunStep.create(b, "run", exe);
const run_cmd = std.Build.EmulatableRunStep.create(b, "run", exe);
test_step.dependOn(&run_cmd.step);
}

3
test/link/macho/objcpp/build.zig
View File

@ -1,7 +1,6 @@
const std = @import("std");
const Builder = std.build.Builder;
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const test_step = b.step("test", "Test the program");

3
test/link/macho/pagezero/build.zig
View File

@ -1,7 +1,6 @@
const std = @import("std");
const Builder = std.build.Builder;
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const target: std.zig.CrossTarget = .{ .os_tag = .macos };

13
test/link/macho/search_strategy/build.zig
View File

@ -1,8 +1,7 @@
const std = @import("std");
const Builder = std.build.Builder;
const LibExeObjectStep = std.build.LibExeObjStep;
const LibExeObjectStep = std.Build.LibExeObjStep;
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const target: std.zig.CrossTarget = .{ .os_tag = .macos };
@ -29,14 +28,14 @@ pub fn build(b: *Builder) void {
const exe = createScenario(b, optimize, target);
exe.search_strategy = .paths_first;
const run = std.build.EmulatableRunStep.create(b, "run", exe);
const run = std.Build.EmulatableRunStep.create(b, "run", exe);
run.cwd = b.pathFromRoot(".");
run.expectStdOutEqual("Hello world");
test_step.dependOn(&run.step);
}
}
fn createScenario(b: *Builder, optimize: std.builtin.OptimizeMode, target: std.zig.CrossTarget) *LibExeObjectStep {
fn createScenario(b: *std.Build, optimize: std.builtin.OptimizeMode, target: std.zig.CrossTarget) *LibExeObjectStep {
const static = b.addStaticLibrary(.{
.name = "a",
.optimize = optimize,
@ -44,7 +43,7 @@ fn createScenario(b: *Builder, optimize: std.builtin.OptimizeMode, target: std.z
});
static.addCSourceFile("a.c", &.{});
static.linkLibC();
static.override_dest_dir = std.build.InstallDir{
static.override_dest_dir = std.Build.InstallDir{
.custom = "static",
};
static.install();
@ -57,7 +56,7 @@ fn createScenario(b: *Builder, optimize: std.builtin.OptimizeMode, target: std.z
});
dylib.addCSourceFile("a.c", &.{});
dylib.linkLibC();
dylib.override_dest_dir = std.build.InstallDir{
dylib.override_dest_dir = std.Build.InstallDir{
.custom = "dynamic",
};
dylib.install();

3
test/link/macho/stack_size/build.zig
View File

@ -1,7 +1,6 @@
const std = @import("std");
const Builder = std.build.Builder;
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const target: std.zig.CrossTarget = .{ .os_tag = .macos };

5
test/link/macho/strict_validation/build.zig
View File

@ -1,9 +1,8 @@
const std = @import("std");
const builtin = @import("builtin");
const Builder = std.build.Builder;
const LibExeObjectStep = std.build.LibExeObjStep;
const LibExeObjectStep = std.Build.LibExeObjStep;
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const target: std.zig.CrossTarget = .{ .os_tag = .macos };

3
test/link/macho/tls/build.zig
View File

@ -1,7 +1,6 @@
const std = @import("std");
const Builder = std.build.Builder;
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const target: std.zig.CrossTarget = .{ .os_tag = .macos };

11
test/link/macho/unwind_info/build.zig
View File

@ -1,9 +1,8 @@
const std = @import("std");
const builtin = @import("builtin");
const Builder = std.build.Builder;
const LibExeObjectStep = std.build.LibExeObjStep;
const LibExeObjectStep = std.Build.LibExeObjStep;
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const target: std.zig.CrossTarget = .{ .os_tag = .macos };
@ -14,8 +13,8 @@ pub fn build(b: *Builder) void {
}
fn testUnwindInfo(
b: *Builder,
test_step: *std.build.Step,
b: *std.Build,
test_step: *std.Build.Step,
optimize: std.builtin.OptimizeMode,
target: std.zig.CrossTarget,
dead_strip: bool,
@ -52,7 +51,7 @@ fn testUnwindInfo(
test_step.dependOn(&run_cmd.step);
}
fn createScenario(b: *Builder, optimize: std.builtin.OptimizeMode, target: std.zig.CrossTarget) *LibExeObjectStep {
fn createScenario(b: *std.Build, optimize: std.builtin.OptimizeMode, target: std.zig.CrossTarget) *LibExeObjectStep {
const exe = b.addExecutable(.{
.name = "test",
.optimize = optimize,

11
test/link/macho/uuid/build.zig
View File

@ -1,8 +1,7 @@
const std = @import("std");
const Builder = std.build.Builder;
const LibExeObjectStep = std.build.LibExeObjStep;
const LibExeObjectStep = std.Build.LibExeObjStep;
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const test_step = b.step("test", "Test");
test_step.dependOn(b.getInstallStep());
@ -27,8 +26,8 @@ pub fn build(b: *Builder) void {
}
fn testUuid(
b: *Builder,
test_step: *std.build.Step,
b: *std.Build,
test_step: *std.Build.Step,
optimize: std.builtin.OptimizeMode,
target: std.zig.CrossTarget,
comptime exp: []const u8,
@ -52,7 +51,7 @@ fn testUuid(
}
}
fn simpleDylib(b: *Builder, optimize: std.builtin.OptimizeMode, target: std.zig.CrossTarget) *LibExeObjectStep {
fn simpleDylib(b: *std.Build, optimize: std.builtin.OptimizeMode, target: std.zig.CrossTarget) *LibExeObjectStep {
const dylib = b.addSharedLibrary(.{
.name = "test",
.version = .{ .major = 1, .minor = 0 },

5
test/link/macho/weak_framework/build.zig
View File

@ -1,8 +1,7 @@
const std = @import("std");
const Builder = std.build.Builder;
const LibExeObjectStep = std.build.LibExeObjStep;
const LibExeObjectStep = std.Build.LibExeObjStep;
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const test_step = b.step("test", "Test the program");

5
test/link/macho/weak_library/build.zig
View File

@ -1,8 +1,7 @@
const std = @import("std");
const Builder = std.build.Builder;
const LibExeObjectStep = std.build.LibExeObjStep;
const LibExeObjectStep = std.Build.LibExeObjStep;
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const target: std.zig.CrossTarget = .{ .os_tag = .macos };

3
test/link/static_lib_as_system_lib/build.zig
View File

@ -1,7 +1,6 @@
const std = @import("std");
const Builder = std.build.Builder;
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const target = b.standardTargetOptions(.{});

3
test/link/wasm/archive/build.zig
View File

@ -1,7 +1,6 @@
const std = @import("std");
const Builder = std.build.Builder;
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const test_step = b.step("test", "Test");
test_step.dependOn(b.getInstallStep());

2
test/link/wasm/basic-features/build.zig
View File

@ -1,6 +1,6 @@
const std = @import("std");
pub fn build(b: *std.build.Builder) void {
pub fn build(b: *std.Build) void {
// Library with explicitly set cpu features
const lib = b.addSharedLibrary(.{
.name = "lib",

3
test/link/wasm/bss/build.zig
View File

@ -1,7 +1,6 @@
const std = @import("std");
const Builder = std.build.Builder;
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const test_step = b.step("test", "Test");
test_step.dependOn(b.getInstallStep());

3
test/link/wasm/export-data/build.zig
View File

@ -1,7 +1,6 @@
const std = @import("std");
const Builder = std.build.Builder;
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const test_step = b.step("test", "Test");
test_step.dependOn(b.getInstallStep());

2
test/link/wasm/export/build.zig
View File

@ -1,6 +1,6 @@
const std = @import("std");
pub fn build(b: *std.build.Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const no_export = b.addSharedLibrary(.{

3
test/link/wasm/extern-mangle/build.zig
View File

@ -1,7 +1,6 @@
const std = @import("std");
const Builder = std.build.Builder;
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const test_step = b.step("test", "Test");
test_step.dependOn(b.getInstallStep());

2
test/link/wasm/extern/build.zig vendored
View File

@ -1,6 +1,6 @@
const std = @import("std");
pub fn build(b: *std.build.Builder) void {
pub fn build(b: *std.Build) void {
const exe = b.addExecutable(.{
.name = "extern",
.root_source_file = .{ .path = "main.zig" },

3
test/link/wasm/function-table/build.zig
View File

@ -1,7 +1,6 @@
const std = @import("std");
const Builder = std.build.Builder;
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const test_step = b.step("test", "Test");

2
test/link/wasm/infer-features/build.zig
View File

@ -1,6 +1,6 @@
const std = @import("std");
pub fn build(b: *std.build.Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
// Wasm Object file which we will use to infer the features from

3
test/link/wasm/producers/build.zig
View File

@ -1,8 +1,7 @@
const std = @import("std");
const builtin = @import("builtin");
const Builder = std.build.Builder;
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const test_step = b.step("test", "Test");
test_step.dependOn(b.getInstallStep());

3
test/link/wasm/segments/build.zig
View File

@ -1,7 +1,6 @@
const std = @import("std");
const Builder = std.build.Builder;
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const test_step = b.step("test", "Test");
test_step.dependOn(b.getInstallStep());

3
test/link/wasm/stack_pointer/build.zig
View File

@ -1,7 +1,6 @@
const std = @import("std");
const Builder = std.build.Builder;
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const test_step = b.step("test", "Test");
test_step.dependOn(b.getInstallStep());

3
test/link/wasm/type/build.zig
View File

@ -1,7 +1,6 @@
const std = @import("std");
const Builder = std.build.Builder;
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const test_step = b.step("test", "Test");
test_step.dependOn(b.getInstallStep());

5
test/src/compare_output.zig
View File

@ -1,7 +1,6 @@
// This is the implementation of the test harness.
// For the actual test cases, see test/compare_output.zig.
const std = @import("std");
const build = std.build;
const ArrayList = std.ArrayList;
const fmt = std.fmt;
const mem = std.mem;
@ -9,8 +8,8 @@ const fs = std.fs;
const OptimizeMode = std.builtin.OptimizeMode;
pub const CompareOutputContext = struct {
b: *build.Builder,
step: *build.Step,
b: *std.Build,
step: *std.Build.Step,
test_index: usize,
test_filter: ?[]const u8,
optimize_modes: []const OptimizeMode,

5
test/src/run_translated_c.zig
View File

@ -1,15 +1,14 @@
// This is the implementation of the test harness for running translated
// C code. For the actual test cases, see test/run_translated_c.zig.
const std = @import("std");
const build = std.build;
const ArrayList = std.ArrayList;
const fmt = std.fmt;
const mem = std.mem;
const fs = std.fs;
pub const RunTranslatedCContext = struct {
b: *build.Builder,
step: *build.Step,
b: *std.Build,
step: *std.Build.Step,
test_index: usize,
test_filter: ?[]const u8,
target: std.zig.CrossTarget,

5
test/src/translate_c.zig
View File

@ -1,7 +1,6 @@
// This is the implementation of the test harness.
// For the actual test cases, see test/translate_c.zig.
const std = @import("std");
const build = std.build;
const ArrayList = std.ArrayList;
const fmt = std.fmt;
const mem = std.mem;
@ -9,8 +8,8 @@ const fs = std.fs;
const CrossTarget = std.zig.CrossTarget;
pub const TranslateCContext = struct {
b: *build.Builder,
step: *build.Step,
b: *std.Build,
step: *std.Build.Step,
test_index: usize,
test_filter: ?[]const u8,

4
test/standalone/brace_expansion/build.zig
View File

@ -1,6 +1,6 @@
const Builder = @import("std").build.Builder;
const std = @import("std");
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const main = b.addTest(.{
.root_source_file = .{ .path = "main.zig" },
.optimize = b.standardOptimizeOption(.{}),

5
test/standalone/c_compiler/build.zig
View File

@ -1,9 +1,8 @@
const std = @import("std");
const builtin = @import("builtin");
const Builder = std.build.Builder;
const CrossTarget = std.zig.CrossTarget;
// TODO integrate this with the std.build executor API
// TODO integrate this with the std.Build executor API
fn isRunnableTarget(t: CrossTarget) bool {
if (t.isNative()) return true;
@ -11,7 +10,7 @@ fn isRunnableTarget(t: CrossTarget) bool {
t.getCpuArch() == builtin.cpu.arch);
}
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const target = b.standardTargetOptions(.{});

4
test/standalone/emit_asm_and_bin/build.zig
View File

@ -1,6 +1,6 @@
const Builder = @import("std").build.Builder;
const std = @import("std");
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const main = b.addTest(.{
.root_source_file = .{ .path = "main.zig" },
.optimize = b.standardOptimizeOption(.{}),

4
test/standalone/empty_env/build.zig
View File

@ -1,6 +1,6 @@
const Builder = @import("std").build.Builder;
const std = @import("std");
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const main = b.addExecutable(.{
.name = "main",
.root_source_file = .{ .path = "main.zig" },

4
test/standalone/global_linkage/build.zig
View File

@ -1,6 +1,6 @@
const Builder = @import("std").build.Builder;
const std = @import("std");
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const obj1 = b.addStaticLibrary(.{

4
test/standalone/install_raw_hex/build.zig
View File

@ -1,8 +1,8 @@
const builtin = @import("builtin");
const std = @import("std");
const CheckFileStep = std.build.CheckFileStep;
const CheckFileStep = std.Build.CheckFileStep;
pub fn build(b: *std.build.Builder) void {
pub fn build(b: *std.Build) void {
const target = .{
.cpu_arch = .thumb,
.cpu_model = .{ .explicit = &std.Target.arm.cpu.cortex_m4 },

5
test/standalone/issue_11595/build.zig
View File

@ -1,9 +1,8 @@
const std = @import("std");
const builtin = @import("builtin");
const Builder = std.build.Builder;
const CrossTarget = std.zig.CrossTarget;
// TODO integrate this with the std.build executor API
// TODO integrate this with the std.Build executor API
fn isRunnableTarget(t: CrossTarget) bool {
if (t.isNative()) return true;
@ -11,7 +10,7 @@ fn isRunnableTarget(t: CrossTarget) bool {
t.getCpuArch() == builtin.cpu.arch);
}
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const target = b.standardTargetOptions(.{});

3
test/standalone/issue_12588/build.zig
View File

@ -1,7 +1,6 @@
const std = @import("std");
const Builder = std.build.Builder;
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const target = b.standardTargetOptions(.{});

5
test/standalone/issue_12706/build.zig
View File

@ -1,9 +1,8 @@
const std = @import("std");
const builtin = @import("builtin");
const Builder = std.build.Builder;
const CrossTarget = std.zig.CrossTarget;
// TODO integrate this with the std.build executor API
// TODO integrate this with the std.Build executor API
fn isRunnableTarget(t: CrossTarget) bool {
if (t.isNative()) return true;
@ -11,7 +10,7 @@ fn isRunnableTarget(t: CrossTarget) bool {
t.getCpuArch() == builtin.cpu.arch);
}
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const target = b.standardTargetOptions(.{});

3
test/standalone/issue_13030/build.zig
View File

@ -1,9 +1,8 @@
const std = @import("std");
const builtin = @import("builtin");
const Builder = std.build.Builder;
const CrossTarget = std.zig.CrossTarget;
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const target = b.standardTargetOptions(.{});

4
test/standalone/issue_339/build.zig
View File

@ -1,6 +1,6 @@
const Builder = @import("std").build.Builder;
const std = @import("std");
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const obj = b.addObject(.{
.name = "test",
.root_source_file = .{ .path = "test.zig" },

4
test/standalone/issue_5825/build.zig
View File

@ -1,6 +1,6 @@
const Builder = @import("std").build.Builder;
const std = @import("std");
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const target = .{
.cpu_arch = .x86_64,
.os_tag = .windows,

4
test/standalone/issue_7030/build.zig
View File

@ -1,6 +1,6 @@
const Builder = @import("std").build.Builder;
const std = @import("std");
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const exe = b.addExecutable(.{
.name = "issue_7030",
.root_source_file = .{ .path = "main.zig" },

4
test/standalone/issue_794/build.zig
View File

@ -1,6 +1,6 @@
const Builder = @import("std").build.Builder;
const std = @import("std");
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const test_artifact = b.addTest(.{
.root_source_file = .{ .path = "main.zig" },
});

2
test/standalone/issue_8550/build.zig
View File

@ -1,6 +1,6 @@
const std = @import("std");
pub fn build(b: *std.build.Builder) !void {
pub fn build(b: *std.Build) !void {
const target = std.zig.CrossTarget{
.os_tag = .freestanding,
.cpu_arch = .arm,

2
test/standalone/issue_9812/build.zig
View File

@ -1,6 +1,6 @@
const std = @import("std");
pub fn build(b: *std.build.Builder) !void {
pub fn build(b: *std.Build) !void {
const optimize = b.standardOptimizeOption(.{});
const zip_add = b.addTest(.{
.root_source_file = .{ .path = "main.zig" },

4
test/standalone/load_dynamic_library/build.zig
View File

@ -1,6 +1,6 @@
const Builder = @import("std").build.Builder;
const std = @import("std");
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const target = b.standardTargetOptions(.{});
const optimize = b.standardOptimizeOption(.{});

4
test/standalone/main_pkg_path/build.zig
View File

@ -1,6 +1,6 @@
const Builder = @import("std").build.Builder;
const std = @import("std");
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const test_exe = b.addTest(.{
.root_source_file = .{ .path = "a/test.zig" },
});

5
test/standalone/mix_c_files/build.zig
View File

@ -1,9 +1,8 @@
const std = @import("std");
const builtin = @import("builtin");
const Builder = std.build.Builder;
const CrossTarget = std.zig.CrossTarget;
// TODO integrate this with the std.build executor API
// TODO integrate this with the std.Build executor API
fn isRunnableTarget(t: CrossTarget) bool {
if (t.isNative()) return true;
@ -11,7 +10,7 @@ fn isRunnableTarget(t: CrossTarget) bool {
t.getCpuArch() == builtin.cpu.arch);
}
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const target = b.standardTargetOptions(.{});

4
test/standalone/mix_o_files/build.zig
View File

@ -1,6 +1,6 @@
const Builder = @import("std").build.Builder;
const std = @import("std");
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const obj = b.addObject(.{

2
test/standalone/options/build.zig
View File

@ -1,6 +1,6 @@
const std = @import("std");
pub fn build(b: *std.build.Builder) void {
pub fn build(b: *std.Build) void {
const target = b.standardTargetOptions(.{});
const optimize = b.standardOptimizeOption(.{});

4
test/standalone/pie/build.zig
View File

@ -1,6 +1,6 @@
const Builder = @import("std").build.Builder;
const std = @import("std");
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const main = b.addTest(.{
.root_source_file = .{ .path = "main.zig" },
.optimize = b.standardOptimizeOption(.{}),

4
test/standalone/pkg_import/build.zig
View File

@ -1,6 +1,6 @@
const Builder = @import("std").build.Builder;
const std = @import("std");
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const exe = b.addExecutable(.{

4
test/standalone/shared_library/build.zig
View File

@ -1,6 +1,6 @@
const Builder = @import("std").build.Builder;
const std = @import("std");
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const target = b.standardTargetOptions(.{});
const lib = b.addSharedLibrary(.{

4
test/standalone/static_c_lib/build.zig
View File

@ -1,6 +1,6 @@
const Builder = @import("std").build.Builder;
const std = @import("std");
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const foo = b.addStaticLibrary(.{

4
test/standalone/test_runner_path/build.zig
View File

@ -1,6 +1,6 @@
const Builder = @import("std").build.Builder;
const std = @import("std");
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const test_exe = b.addTest(.{
.root_source_file = .{ .path = "test.zig" },
.kind = .test_exe,

4
test/standalone/use_alias/build.zig
View File

@ -1,6 +1,6 @@
const Builder = @import("std").build.Builder;
const std = @import("std");
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const main = b.addTest(.{
.root_source_file = .{ .path = "main.zig" },
.optimize = b.standardOptimizeOption(.{}),

4
test/standalone/windows_spawn/build.zig
View File

@ -1,6 +1,6 @@
const Builder = @import("std").build.Builder;
const std = @import("std");
pub fn build(b: *Builder) void {
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const hello = b.addExecutable(.{

60
test/tests.zig
View File

@ -1,7 +1,6 @@
const std = @import("std");
const builtin = @import("builtin");
const debug = std.debug;
const build = std.build;
const CrossTarget = std.zig.CrossTarget;
const io = std.io;
const fs = std.fs;
@ -9,9 +8,10 @@ const mem = std.mem;
const fmt = std.fmt;
const ArrayList = std.ArrayList;
const OptimizeMode = std.builtin.OptimizeMode;
const LibExeObjStep = build.LibExeObjStep;
const LibExeObjStep = std.Build.LibExeObjStep;
const Allocator = mem.Allocator;
const ExecError = build.Builder.ExecError;
const ExecError = std.Build.ExecError;
const Step = std.Build.Step;
// Cases
const compare_output = @import("compare_output.zig");
@ -462,7 +462,7 @@ const test_targets = blk: {
const max_stdout_size = 1 * 1024 * 1024; // 1 MB
pub fn addCompareOutputTests(b: *build.Builder, test_filter: ?[]const u8, optimize_modes: []const OptimizeMode) *build.Step {
pub fn addCompareOutputTests(b: *std.Build, test_filter: ?[]const u8, optimize_modes: []const OptimizeMode) *Step {
const cases = b.allocator.create(CompareOutputContext) catch unreachable;
cases.* = CompareOutputContext{
.b = b,
@ -477,7 +477,7 @@ pub fn addCompareOutputTests(b: *build.Builder, test_filter: ?[]const u8, optimi
return cases.step;
}
pub fn addStackTraceTests(b: *build.Builder, test_filter: ?[]const u8, optimize_modes: []const OptimizeMode) *build.Step {
pub fn addStackTraceTests(b: *std.Build, test_filter: ?[]const u8, optimize_modes: []const OptimizeMode) *Step {
const cases = b.allocator.create(StackTracesContext) catch unreachable;
cases.* = StackTracesContext{
.b = b,
@ -493,7 +493,7 @@ pub fn addStackTraceTests(b: *build.Builder, test_filter: ?[]const u8, optimize_
}
pub fn addStandaloneTests(
b: *build.Builder,
b: *std.Build,
test_filter: ?[]const u8,
optimize_modes: []const OptimizeMode,
skip_non_native: bool,
@ -506,7 +506,7 @@ pub fn addStandaloneTests(
enable_wasmtime: bool,
enable_wine: bool,
enable_symlinks_windows: bool,
) *build.Step {
) *Step {
const cases = b.allocator.create(StandaloneContext) catch unreachable;
cases.* = StandaloneContext{
.b = b,
@ -532,13 +532,13 @@ pub fn addStandaloneTests(
}
pub fn addLinkTests(
b: *build.Builder,
b: *std.Build,
test_filter: ?[]const u8,
optimize_modes: []const OptimizeMode,
enable_macos_sdk: bool,
omit_stage2: bool,
enable_symlinks_windows: bool,
) *build.Step {
) *Step {
const cases = b.allocator.create(StandaloneContext) catch unreachable;
cases.* = StandaloneContext{
.b = b,
@ -556,7 +556,7 @@ pub fn addLinkTests(
return cases.step;
}
pub fn addCliTests(b: *build.Builder, test_filter: ?[]const u8, optimize_modes: []const OptimizeMode) *build.Step {
pub fn addCliTests(b: *std.Build, test_filter: ?[]const u8, optimize_modes: []const OptimizeMode) *Step {
_ = test_filter;
_ = optimize_modes;
const step = b.step("test-cli", "Test the command line interface");
@ -577,7 +577,7 @@ pub fn addCliTests(b: *build.Builder, test_filter: ?[]const u8, optimize_modes:
return step;
}
pub fn addAssembleAndLinkTests(b: *build.Builder, test_filter: ?[]const u8, optimize_modes: []const OptimizeMode) *build.Step {
pub fn addAssembleAndLinkTests(b: *std.Build, test_filter: ?[]const u8, optimize_modes: []const OptimizeMode) *Step {
const cases = b.allocator.create(CompareOutputContext) catch unreachable;
cases.* = CompareOutputContext{
.b = b,
@ -592,7 +592,7 @@ pub fn addAssembleAndLinkTests(b: *build.Builder, test_filter: ?[]const u8, opti
return cases.step;
}
pub fn addTranslateCTests(b: *build.Builder, test_filter: ?[]const u8) *build.Step {
pub fn addTranslateCTests(b: *std.Build, test_filter: ?[]const u8) *Step {
const cases = b.allocator.create(TranslateCContext) catch unreachable;
cases.* = TranslateCContext{
.b = b,
@ -607,10 +607,10 @@ pub fn addTranslateCTests(b: *build.Builder, test_filter: ?[]const u8) *build.St
}
pub fn addRunTranslatedCTests(
b: *build.Builder,
b: *std.Build,
test_filter: ?[]const u8,
target: std.zig.CrossTarget,
) *build.Step {
) *Step {
const cases = b.allocator.create(RunTranslatedCContext) catch unreachable;
cases.* = .{
.b = b,
@ -625,7 +625,7 @@ pub fn addRunTranslatedCTests(
return cases.step;
}
pub fn addGenHTests(b: *build.Builder, test_filter: ?[]const u8) *build.Step {
pub fn addGenHTests(b: *std.Build, test_filter: ?[]const u8) *Step {
const cases = b.allocator.create(GenHContext) catch unreachable;
cases.* = GenHContext{
.b = b,
@ -640,7 +640,7 @@ pub fn addGenHTests(b: *build.Builder, test_filter: ?[]const u8) *build.Step {
}
pub fn addPkgTests(
b: *build.Builder,
b: *std.Build,
test_filter: ?[]const u8,
root_src: []const u8,
name: []const u8,
@ -651,7 +651,7 @@ pub fn addPkgTests(
skip_libc: bool,
skip_stage1: bool,
skip_stage2: bool,
) *build.Step {
) *Step {
const step = b.step(b.fmt("test-{s}", .{name}), desc);
for (test_targets) |test_target| {
@ -742,8 +742,8 @@ pub fn addPkgTests(
}
pub const StackTracesContext = struct {
b: *build.Builder,
step: *build.Step,
b: *std.Build,
step: *Step,
test_index: usize,
test_filter: ?[]const u8,
optimize_modes: []const OptimizeMode,
@ -840,7 +840,7 @@ pub const StackTracesContext = struct {
const RunAndCompareStep = struct {
pub const base_id = .custom;
step: build.Step,
step: Step,
context: *StackTracesContext,
exe: *LibExeObjStep,
name: []const u8,
@ -858,7 +858,7 @@ pub const StackTracesContext = struct {
const allocator = context.b.allocator;
const ptr = allocator.create(RunAndCompareStep) catch unreachable;
ptr.* = RunAndCompareStep{
.step = build.Step.init(.custom, "StackTraceCompareOutputStep", allocator, make),
.step = Step.init(.custom, "StackTraceCompareOutputStep", allocator, make),
.context = context,
.exe = exe,
.name = name,
@ -871,7 +871,7 @@ pub const StackTracesContext = struct {
return ptr;
}
fn make(step: *build.Step) !void {
fn make(step: *Step) !void {
const self = @fieldParentPtr(RunAndCompareStep, "step", step);
const b = self.context.b;
@ -1014,8 +1014,8 @@ pub const StackTracesContext = struct {
};
pub const StandaloneContext = struct {
b: *build.Builder,
step: *build.Step,
b: *std.Build,
step: *Step,
test_index: usize,
test_filter: ?[]const u8,
optimize_modes: []const OptimizeMode,
@ -1150,8 +1150,8 @@ pub const StandaloneContext = struct {
};
pub const GenHContext = struct {
b: *build.Builder,
step: *build.Step,
b: *std.Build,
step: *Step,
test_index: usize,
test_filter: ?[]const u8,
@ -1178,7 +1178,7 @@ pub const GenHContext = struct {
};
const GenHCmpOutputStep = struct {
step: build.Step,
step: Step,
context: *GenHContext,
obj: *LibExeObjStep,
name: []const u8,
@ -1194,7 +1194,7 @@ pub const GenHContext = struct {
const allocator = context.b.allocator;
const ptr = allocator.create(GenHCmpOutputStep) catch unreachable;
ptr.* = GenHCmpOutputStep{
.step = build.Step.init(.Custom, "ParseCCmpOutput", allocator, make),
.step = Step.init(.Custom, "ParseCCmpOutput", allocator, make),
.context = context,
.obj = obj,
.name = name,
@ -1206,7 +1206,7 @@ pub const GenHContext = struct {
return ptr;
}
fn make(step: *build.Step) !void {
fn make(step: *Step) !void {
const self = @fieldParentPtr(GenHCmpOutputStep, "step", step);
const b = self.context.b;
@ -1348,7 +1348,7 @@ const c_abi_targets = [_]CrossTarget{
},
};
pub fn addCAbiTests(b: *build.Builder, skip_non_native: bool, skip_release: bool) *build.Step {
pub fn addCAbiTests(b: *std.Build, skip_non_native: bool, skip_release: bool) *Step {
const step = b.step("test-c-abi", "Run the C ABI tests");
const optimize_modes: [2]OptimizeMode = .{ .Debug, .ReleaseFast };