zig/lib/std/build.zig at link-tests · dominictarr/zig

Repository navigation

History

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504<
10BC8
/div>

const std = @import("std.zig");

const builtin = @import("builtin");

const io = std.io;

const fs = std.fs;

const mem = std.mem;

const debug = std.debug;

const panic = std.debug.panic;

const assert = debug.assert;

const warn = std.debug.print; // TODO use the log system instead of this

const ArrayList = std.ArrayList;

const StringHashMap = std.StringHashMap;

const Allocator = mem.Allocator;

const process = std.process;

const BufSet = std.BufSet;

const BufMap = std.BufMap;

const fmt_lib = std.fmt;

const File = std.fs.File;

const CrossTarget = std.zig.CrossTarget;

const NativeTargetInfo = std.zig.system.NativeTargetInfo;

const Sha256 = std.crypto.hash.sha2.Sha256;

pub const FmtStep = @import("build/FmtStep.zig");

pub const TranslateCStep = @import("build/TranslateCStep.zig");

pub const WriteFileStep = @import("build/WriteFileStep.zig");

pub const RunStep = @import("build/RunStep.zig");

pub const CheckFileStep = @import("build/CheckFileStep.zig");

pub const InstallRawStep = @import("build/InstallRawStep.zig");

pub const OptionsStep = @import("build/OptionsStep.zig");

pub const Builder = struct {

install_tls: TopLevelStep,

uninstall_tls: TopLevelStep,

allocator: Allocator,

user_input_options: UserInputOptionsMap,

available_options_map: AvailableOptionsMap,

available_options_list: ArrayList(AvailableOption),

verbose: bool,

verbose_link: bool,

verbose_cc: bool,

verbose_air: bool,

verbose_llvm_ir: bool,

verbose_cimport: bool,

verbose_llvm_cpu_features: bool,

/// The purpose of executing the command is for a human to read compile errors from the terminal

prominent_compile_errors: bool,

color: enum { auto, on, off } = .auto,

use_stage1: ?bool = null,

invalid_user_input: bool,

zig_exe: []const u8,

default_step: *Step,

env_map: *BufMap,

top_level_steps: ArrayList(*TopLevelStep),

install_prefix: []const u8,

dest_dir: ?[]const u8,

lib_dir: []const u8,

exe_dir: []const u8,

h_dir: []const u8,

install_path: []const u8,

sysroot: ?[]const u8 = null,

search_prefixes: ArrayList([]const u8),

libc_file: ?[]const u8 = null,

installed_files: ArrayList(InstalledFile),

build_root: []const u8,

cache_root: []const u8,

global_cache_root: []const u8,

release_mode: ?std.builtin.Mode,

is_release: bool,

override_lib_dir: ?[]const u8,

vcpkg_root: VcpkgRoot,

pkg_config_pkg_list: ?(PkgConfigError![]const PkgConfigPkg) = null,

args: ?[][]const u8 = null,

debug_log_scopes: []const []const u8 = &.{},

/// Experimental. Use system Darling installation to run cross compiled macOS build artifacts.

enable_darling: bool = false,

/// Use system QEMU installation to run cross compiled foreign architecture build artifacts.

enable_qemu: bool = false,

/// Darwin. Use Rosetta to run x86_64 macOS build artifacts on arm64 macOS.

enable_rosetta: bool = false,

/// Use system Wasmtime installation to run cross compiled wasm/wasi build artifacts.

enable_wasmtime: bool = false,

/// Use system Wine installation to run cross compiled Windows build artifacts.

enable_wine: bool = false,

/// After following the steps in https://github.com/ziglang/zig/wiki/Updating-libc#glibc,

/// this will be the directory $glibc-build-dir/install/glibcs

/// Given the example of the aarch64 target, this is the directory

/// that contains the path `aarch64-linux-gnu/lib/ld-linux-aarch64.so.1`.

glibc_runtimes_dir: ?[]const u8 = null,

/// Information about the native target. Computed before build() is invoked.

host: NativeTargetInfo,

pub const ExecError = error{

ReadFailure,

ExitCodeFailure,

ProcessTerminated,

ExecNotSupported,

} || std.ChildProcess.SpawnError;

pub const PkgConfigError = error{

PkgConfigCrashed,

PkgConfigFailed,

PkgConfigNotInstalled,

PkgConfigInvalidOutput,

};

pub const PkgConfigPkg = struct {

desc: []const u8,

};

pub const CStd = enum {

C89,

C99,

C11,

};

const UserInputOptionsMap = StringHashMap(UserInputOption);

const AvailableOptionsMap = StringHashMap(AvailableOption);

const AvailableOption = struct {

type_id: TypeId,

description: []const u8,

/// If the `type_id` is `enum` this provides the list of enum options

enum_options: ?[]const []const u8,

};

const UserInputOption = struct {

value: UserValue,

used: bool,

};

const UserValue = union(enum) {

flag: void,

scalar: []const u8,

list: ArrayList([]const u8),

};

const TypeId = enum {

bool,

int,

float,

@"enum",

string,

list,

};

const TopLevelStep = struct {

pub const base_id = .top_level;

step: Step,

description: []const u8,

};

pub const DirList = struct {

lib_dir: ?[]const u8 = null,

exe_dir: ?[]const u8 = null,

include_dir: ?[]const u8 = null,

};

pub fn create(

allocator: Allocator,

zig_exe: []const u8,

build_root: []const u8,

cache_root: []const u8,

global_cache_root: []const u8,

) !*Builder {

const env_map = try allocator.create(BufMap);

env_map.* = try process.getEnvMap(allocator);

const host = try NativeTargetInfo.detect(allocator, .{});

const self = try allocator.create(Builder);

self.* = Builder{

.zig_exe = zig_exe,

.build_root = build_root,

.cache_root = try fs.path.relative(allocator, build_root, cache_root),

.global_cache_root = global_cache_root,

.verbose = false,

.verbose_link = false,

.verbose_cc = false,

.verbose_air = false,

.verbose_llvm_ir = false,

.verbose_cimport = false,

.verbose_llvm_cpu_features = false,

.prominent_compile_errors = false,

.invalid_user_input = false,

.allocator = allocator,

.user_input_options = UserInputOptionsMap.init(allocator),

.available_options_map = AvailableOptionsMap.init(allocator),

.available_options_list = ArrayList(AvailableOption).init(allocator),

.top_level_steps = ArrayList(*TopLevelStep).init(allocator),

.default_step = undefined,

.env_map = env_map,

.search_prefixes = ArrayList([]const u8).init(allocator),

.install_prefix = undefined,

.lib_dir = undefined,

.exe_dir = undefined,

.h_dir = undefined,

.dest_dir = env_map.get("DESTDIR"),

.installed_files = ArrayList(InstalledFile).init(allocator),

.install_tls = TopLevelStep{

.step = Step.initNoOp(.top_level, "install", allocator),

.description = "Copy build artifacts to prefix path",

.uninstall_tls = TopLevelStep{

.step = Step.init(.top_level, "uninstall", allocator, makeUninstall),

.description = "Remove build artifacts from prefix path",

.release_mode = null,

.is_release = false,

.override_lib_dir = null,

.install_path = undefined,

.vcpkg_root = VcpkgRoot{ .unattempted = {} },

.args = null,

.host = host,

};

try self.top_level_steps.append(&self.install_tls);

try self.top_level_steps.append(&self.uninstall_tls);

self.default_step = &self.install_tls.step;

return self;

}

pub fn destroy(self: *Builder) void {

self.env_map.deinit();

self.top_level_steps.deinit();

self.allocator.destroy(self);

}

/// This function is intended to be called by std/special/build_runner.zig, not a build.zig file.

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

if (self.dest_dir) |dest_dir| {

self.install_prefix = install_prefix orelse "/usr";

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

} else {

self.install_prefix = install_prefix orelse

(self.pathJoin(&.{ self.build_root, "zig-out" }));

self.install_path = self.install_prefix;

}

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

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

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

if (dir_list.lib_dir) |dir| {

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

lib_list[1] = dir;

}

if (dir_list.exe_dir) |dir| {

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

exe_list[1] = dir;

}

if (dir_list.include_dir) |dir| {

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

h_list[1] = dir;

}

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

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

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

}

fn convertOptionalPathToFileSource(path: ?[]const u8) ?FileSource {

return if (path) |p|

FileSource{ .path = p }

else

null;

}

pub fn addExecutable(self: *Builder, name: []const u8, root_src: ?[]const u8) *LibExeObjStep {

return addExecutableSource(self, name, convertOptionalPathToFileSource(root_src));

}

pub fn addExecutableSource(builder: *Builder, name: []const u8, root_src: ?FileSource) *LibExeObjStep {

return LibExeObjStep.createExecutable(builder, name, root_src);

}

pub fn addOptions(self: *Builder) *OptionsStep {

return OptionsStep.create(self);

}

pub fn addObject(self: *Builder, name: []const u8, root_src: ?[]const u8) *LibExeObjStep {

return addObjectSource(self, name, convertOptionalPathToFileSource(root_src));

}

pub fn addObjectSource(builder: *Builder, name: []const u8, root_src: ?FileSource) *LibExeObjStep {

return LibExeObjStep.createObject(builder, name, root_src);

}

pub fn addSharedLibrary(

self: *Builder,

root_src: ?[]const u8,

kind: LibExeObjStep.SharedLibKind,

) *LibExeObjStep {

return addSharedLibrarySource(self, name, convertOptionalPathToFileSource(root_src), kind);

}

pub fn addSharedLibrarySource(

self: *Builder,

root_src: ?FileSource,

kind: LibExeObjStep.SharedLibKind,

) *LibExeObjStep {

return LibExeObjStep.createSharedLibrary(self, name, root_src, kind);

}

pub fn addStaticLibrary(self: *Builder, name: []const u8, root_src: ?[]const u8) *LibExeObjStep {

return addStaticLibrarySource(self, name, convertOptionalPathToFileSource(root_src));

}

pub fn addStaticLibrarySource(self: *Builder, name: []const u8, root_src: ?FileSource) *LibExeObjStep {

return LibExeObjStep.createStaticLibrary(self, name, root_src);

}

pub fn addTest(self: *Builder, root_src: []const u8) *LibExeObjStep {

return LibExeObjStep.createTest(self, "test", .{ .path = root_src });

}

pub fn addTestSource(self: *Builder, root_src: FileSource) *LibExeObjStep {

return LibExeObjStep.createTest(self, "test", root_src.dupe(self));

}

pub fn addTestExe(self: *Builder, name: []const u8, root_src: []const u8) *LibExeObjStep {

return LibExeObjStep.createTestExe(self, name, .{ .path = root_src });

}

pub fn addTestExeSource(self: *Builder, name: []const u8, root_src: FileSource) *LibExeObjStep {

return LibExeObjStep.createTestExe(self, name, root_src.dupe(self));

}

pub fn addAssemble(self: *Builder, name: []const u8, src: []const u8) *LibExeObjStep {

return addAssembleSource(self, name, .{ .path = src });

}

pub fn addAssembleSource(self: *Builder, name: []const u8, src: FileSource) *LibExeObjStep {

const obj_step = LibExeObjStep.createObject(self, name, null);

obj_step.addAssemblyFileSource(src.dupe(self));

return obj_step;

}

/// Initializes a RunStep with argv, which must at least have the path to the

/// executable. More command line arguments can be added with `addArg`,

/// `addArgs`, and `addArtifactArg`.

/// Be careful using this function, as it introduces a system dependency.

/// To run an executable built with zig build, see `LibExeObjStep.run`.

pub fn addSystemCommand(self: *Builder, argv: []const []const u8) *RunStep {

assert(argv.len >= 1);

const run_step = RunStep.create(self, self.fmt("run {s}", .{argv[0]}));

run_step.addArgs(argv);

return run_step;

}

/// Allocator.dupe without the need to handle out of memory.

pub fn dupe(self: *Builder, bytes: []const u8) []u8 {

return self.allocator.dupe(u8, bytes) catch unreachable;

}

/// Duplicates an array of strings without the need to handle out of memory.

pub fn dupeStrings(self: *Builder, strings: []const []const u8) [][]u8 {

const array = self.allocator.alloc([]u8, strings.len) catch unreachable;

for (strings) |s, i| {

array[i] = self.dupe(s);

}

return array;

}

/// Duplicates a path and converts all slashes to the OS's canonical path separator.

pub fn dupePath(self: *Builder, bytes: []const u8) []u8 {

const the_copy = self.dupe(bytes);

for (the_copy) |*byte| {

switch (byte.*) {

'/', '\\' => byte.* = fs.path.sep,

else => {},

}

return the_copy;

}

/// Duplicates a package recursively.

pub fn dupePkg(self: *Builder, package: Pkg) Pkg {

var the_copy = Pkg{

.name = self.dupe(package.name),

.path = package.path.dupe(self),

};

if (package.dependencies) |dependencies| {

const new_dependencies = self.allocator.alloc(Pkg, dependencies.len) catch unreachable;

the_copy.dependencies = new_dependencies;

for (dependencies) |dep_package, i| {

new_dependencies[i] = self.dupePkg(dep_package);

}

return the_copy;

}

pub fn addWriteFile(self: *Builder, file_path: []const u8, data: []const u8) *WriteFileStep {

const write_file_step = self.addWriteFiles();

write_file_step.add(file_path, data);

return write_file_step;

}

pub fn addWriteFiles(self: *Builder) *WriteFileStep {

const write_file_step = self.allocator.create(WriteFileStep) catch unreachable;

write_file_step.* = WriteFileStep.init(self);

return write_file_step;

}

pub fn addLog(self: *Builder, comptime format: []const u8, args: anytype) *LogStep {

const data = self.fmt(format, args);

const log_step = self.allocator.create(LogStep) catch unreachable;

log_step.* = LogStep.init(self, data);

return log_step;

}

pub fn addRemoveDirTree(self: *Builder, dir_path: []const u8) *RemoveDirStep {

const remove_dir_step = self.allocator.create(RemoveDirStep) catch unreachable;

remove_dir_step.* = RemoveDirStep.init(self, dir_path);

return remove_dir_step;

}

pub fn addFmt(self: *Builder, paths: []const []const u8) *FmtStep {

return FmtStep.create(self, paths);

}

pub fn addTranslateC(self: *Builder, source: FileSource) *TranslateCStep {

return TranslateCStep.create(self, source.dupe(self));

}

pub fn version(self: *const Builder, major: u32, minor: u32, patch: u32) LibExeObjStep.SharedLibKind {

_ = self;

return .{

.versioned = .{

.major = major,

.minor = minor,

.patch = patch,

};

}

pub fn make(self: *Builder, step_names: []const []const u8) !void {

try self.makePath(self.cache_root);

var wanted_steps = ArrayList(*Step).init(self.allocator);

defer wanted_steps.deinit();

if (step_names.len == 0) {

try wanted_steps.append(self.default_step);

} else {

for (step_names) |step_name| {

const s = try self.getTopLevelStepByName(step_name);

try wanted_steps.append(s);

}

for (wanted_steps.items) |s| {

try self.makeOneStep(s);

}

pub fn getInstallStep(self: *Builder) *Step {

return &self.install_tls.step;

}

pub fn getUninstallStep(self: *Builder) *Step {

return &self.uninstall_tls.step;

}

fn makeUninstall(uninstall_step: *Step) anyerror!void {

const uninstall_tls = @fieldParentPtr(TopLevelStep, "step", uninstall_step);

const self = @fieldParentPtr(Builder, "uninstall_tls", uninstall_tls);

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

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

if (self.verbose) {

warn("rm {s}\n", .{full_path});

}

fs.cwd().deleteTree(full_path) catch {};

}

// TODO remove empty directories

}

fn makeOneStep(self: *Builder, s: *Step) anyerror!void {

if (s.loop_flag) {

warn("Dependency loop detected:\n {s}\n", .{s.name});

return error.DependencyLoopDetected;

}

s.loop_flag = true;

for (s.dependencies.items) |dep| {

self.makeOneStep(dep) catch |err| {

if (err == error.DependencyLoopDetected) {

warn(" {s}\n", .{s.name});

}

return err;

};

}

s.loop_flag = false;

try s.make();

}

fn getTopLevelStepByName(self: *Builder, name: []const u8) !*Step {

for (self.top_level_steps.items) |top_level_step| {

if (mem.eql(u8, top_level_step.step.name, name)) {

return &top_level_step.step;

}

warn("Cannot run step '{s}' because it does not exist\n", .{name});

return error.InvalidStepName;

}

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

const name = self.dupe(name_raw);

const description = self.dupe(description_raw);

const type_id = comptime typeToEnum(T);

const enum_options = if (type_id == .@"enum") blk: {

const fields = comptime std.meta.fields(T);

var options = ArrayList([]const u8).initCapacity(self.allocator, fields.len) catch unreachable;

inline for (fields) |field| {

options.appendAssumeCapacity(field.name);

}

break :blk options.toOwnedSlice();

} else null;

const available_option = AvailableOption{

.name = name,

.type_id = type_id,

.description = description,

.enum_options = enum_options,

};

if ((self.available_options_map.fetchPut(name, available_option) catch unreachable) != null) {

panic("Option '{s}' declared twice", .{name});

}

self.available_options_list.append(available_option) catch unreachable;

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

option_ptr.used = true;

switch (type_id) {

.bool => switch (option_ptr.value) {

.flag => return true,

.scalar => |s| {

if (mem.eql(u8, s, "true")) {

return true;

} else if (mem.eql(u8, s, "false")) {

return false;

} else {

warn("Expected -D{s} to be a boolean, but received '{s}'\n\n", .{ name, s });

self.markInvalidUserInput();

return null;

}

.list => {

warn("Expected -D{s} to be a boolean, but received a list.\n\n", .{name});

self.markInvalidUserInput();

return null;

.int => switch (option_ptr.value) {

.flag => {

warn("Expected -D{s} to be an integer, but received a boolean.\n\n", .{name});

self.markInvalidUserInput();

return null;

.scalar => |s| {

const n = std.fmt.parseInt(T, s, 10) catch |err| switch (err) {

error.Overflow => {

warn("-D{s} value {s} cannot fit into type {s}.\n\n", .{ name, s, @typeName(T) });

self.markInvalidUserInput();

return null;

else => {

warn("Expected -D{s} to be an integer of type {s}.\n\n", .{ name, @typeName(T) });

self.markInvalidUserInput();

return null;

};

return n;

.list => {

warn("Expected -D{s} to be an integer, but received a list.\n\n", .{name});

10BC8

self.markInvalidUserInput();

return null;

.float => switch (option_ptr.value) {

.flag => {

warn("Expected -D{s} to be a float, but received a boolean.\n\n", .{name});

self.markInvalidUserInput();

return null;

.scalar => |s| {

const n = std.fmt.parseFloat(T, s) catch {

warn("Expected -D{s} to be a float of type {s}.\n\n", .{ name, @typeName(T) });

self.markInvalidUserInput();

return null;

};

return n;

.list => {

warn("Expected -D{s} to be a float, but received a list.\n\n", .{name});

self.markInvalidUserInput();

return null;

.@"enum" => switch (option_ptr.value) {

.flag => {

warn("Expected -D{s} to be a string, but received a boolean.\n\n", .{name});

self.markInvalidUserInput();

return null;

.scalar => |s| {

if (std.meta.stringToEnum(T, s)) |enum_lit| {

return enum_lit;

} else {

warn("Expected -D{s} to be of type {s}.\n\n", .{ name, @typeName(T) });

self.markInvalidUserInput();

return null;

}

.list => {

warn("Expected -D{s} to be a string, but received a list.\n\n", .{name});

self.markInvalidUserInput();

return null;

.string => switch (option_ptr.value) {

.flag => {

warn("Expected -D{s} to be a string, but received a boolean.\n\n", .{name});

self.markInvalidUserInput();

return null;

.list => {

warn("Expected -D{s} to be a string, but received a list.\n\n", .{name});

self.markInvalidUserInput();

return null;

.scalar => |s| return s,

.list => switch (option_ptr.value) {

.flag => {

warn("Expected -D{s} to be a list, but received a boolean.\n\n", .{name});

self.markInvalidUserInput();

return null;

.scalar => |s| {

return self.allocator.dupe([]const u8, &[_][]const u8{s}) catch unreachable;

.list => |lst| return lst.items,

}

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

const step_info = self.allocator.create(TopLevelStep) catch unreachable;

step_info.* = TopLevelStep{

.step = Step.initNoOp(.top_level, name, self.allocator),

.description = self.dupe(description),

};

self.top_level_steps.append(step_info) catch unreachable;

return &step_info.step;

}

/// This provides the -Drelease option to the build user and does not give them the choice.

pub fn setPreferredReleaseMode(self: *Builder, mode: std.builtin.Mode) void {

if (self.release_mode != null) {

@panic("setPreferredReleaseMode must be called before standardReleaseOptions and may not be called twice");

}

const description = self.fmt("Create a release build ({s})", .{@tagName(mode)});

self.is_release = self.option(bool, "release", description) orelse false;

self.release_mode = if (self.is_release) mode else std.builtin.Mode.Debug;

}

/// If you call this without first calling `setPreferredReleaseMode` then it gives the build user

/// the choice of what kind of release.

pub fn standardReleaseOptions(self: *Builder) std.builtin.Mode {

if (self.release_mode) |mode| return mode;

const release_safe = self.option(bool, "release-safe", "Optimizations on and safety on") orelse false;

const release_fast = self.option(bool, "release-fast", "Optimizations on and safety off") orelse false;

const release_small = self.option(bool, "release-small", "Size optimizations on and safety off") orelse false;

const mode = if (release_safe and !release_fast and !release_small)

std.builtin.Mode.ReleaseSafe

else if (release_fast and !release_safe and !release_small)

std.builtin.Mode.ReleaseFast

else if (release_small and !release_fast and !release_safe)

std.builtin.Mode.ReleaseSmall

else if (!release_fast and !release_safe and !release_small)

std.builtin.Mode.Debug

else x: {

warn("Multiple release modes (of -Drelease-safe, -Drelease-fast and -Drelease-small)\n\n", .{});

self.markInvalidUserInput();

break :x std.builtin.Mode.Debug;

};

self.is_release = mode != .Debug;

self.release_mode = mode;

return mode;

}

pub const StandardTargetOptionsArgs = struct {

whitelist: ?[]const CrossTarget = null,

default_target: CrossTarget = CrossTarget{},

};

/// Exposes standard `zig build` options for choosing a target.

pub fn standardTargetOptions(self: *Builder, args: StandardTargetOptionsArgs) CrossTarget {

const maybe_triple = self.option(

[]const u8,

"target",

"The CPU architecture, OS, and ABI to build for",

);

const mcpu = self.option([]const u8, "cpu", "Target CPU features to add or subtract");

if (maybe_triple == null and mcpu == null) {

return args.default_target;

}

const triple = maybe_triple orelse "native";

var diags: CrossTarget.ParseOptions.Diagnostics = .{};

const selected_target = CrossTarget.parse(.{

.arch_os_abi = triple,

.cpu_features = mcpu,

.diagnostics = &diags,

}) catch |err| switch (err) {

error.UnknownCpuModel => {

warn("Unknown CPU: '{s}'\nAvailable CPUs for architecture '{s}':\n", .{

diags.cpu_name.?,

@tagName(diags.arch.?),

});

for (diags.arch.?.allCpuModels()) |cpu| {

warn(" {s}\n", .{cpu.name});

}

warn("\n", .{});

self.markInvalidUserInput();

return args.default_target;

error.UnknownCpuFeature => {

warn(

\\Unknown CPU feature: '{s}'

\\Available CPU features for architecture '{s}':

, .{

diags.unknown_feature_name,

@tagName(diags.arch.?),

});

for (diags.arch.?.allFeaturesList()) |feature| {

warn(" {s}: {s}\n", .{ feature.name, feature.description });

}

warn("\n", .{});

self.markInvalidUserInput();

return args.default_target;

error.UnknownOperatingSystem => {

warn(

\\Unknown OS: '{s}'

\\Available operating systems:

, .{diags.os_name});

inline for (std.meta.fields(std.Target.Os.Tag)) |field| {

warn(" {s}\n", .{field.name});

}

warn("\n", .{});

self.markInvalidUserInput();

return args.default_target;

else => |e| {

warn("Unable to parse target '{s}': {s}\n\n", .{ triple, @errorName(e) });

self.markInvalidUserInput();

return args.default_target;

};

const selected_canonicalized_triple = selected_target.zigTriple(self.allocator) catch unreachable;

if (args.whitelist) |list| whitelist_check: {

// Make sure it's a match of one of the list.

var mismatch_triple = true;

var mismatch_cpu_features = true;

var whitelist_item = CrossTarget{};

for (list) |t| {

mismatch_cpu_features = true;

mismatch_triple = true;

const t_triple = t.zigTriple(self.allocator) catch unreachable;

if (mem.eql(u8, t_triple, selected_canonicalized_triple)) {

mismatch_triple = false;

whitelist_item = t;

if (t.getCpuFeatures().isSuperSetOf(selected_target.getCpuFeatures())) {

mismatch_cpu_features = false;

break :whitelist_check;

} else {

break;

}

if (mismatch_triple) {

warn("Chosen target '{s}' does not match one of the supported targets:\n", .{

selected_canonicalized_triple,

});

for (list) |t| {

const t_triple = t.zigTriple(self.allocator) catch unreachable;

warn(" {s}\n", .{t_triple});

}

warn("\n", .{});

} else {

assert(mismatch_cpu_features);

const whitelist_cpu = whitelist_item.getCpu();

const selected_cpu = selected_target.getCpu();

warn("Chosen CPU model '{s}' does not match one of the supported targets:\n", .{

selected_cpu.model.name,

});

warn(" Supported feature Set: ", .{});

const all_features = whitelist_cpu.arch.allFeaturesList();

var populated_cpu_features = whitelist_cpu.model.features;

populated_cpu_features.populateDependencies(all_features);

for (all_features) |feature, i_usize| {

const i = @intCast(std.Target.Cpu.Feature.Set.Index, i_usize);

const in_cpu_set = populated_cpu_features.isEnabled(i);

if (in_cpu_set) {

warn("{s} ", .{feature.name});

}

warn("\n", .{});

warn(" Remove: ", .{});

for (all_features) |feature, i_usize| {

const i = @intCast(std.Target.Cpu.Feature.Set.Index, i_usize);

const in_cpu_set = populated_cpu_features.isEnabled(i);

const in_actual_set = selected_cpu.features.isEnabled(i);

if (in_actual_set and !in_cpu_set) {

warn("{s} ", .{feature.name});

}

warn("\n", .{});

8 C9BF }

self.markInvalidUserInput();

return args.default_target;

}

return selected_target;

}

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

const name = self.dupe(name_raw);

const value = self.dupe(value_raw);

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

if (!gop.found_existing) {

gop.value_ptr.* = UserInputOption{

.name = name,

.value = .{ .scalar = value },

.used = false,

};

return false;

}

// option already exists

switch (gop.value_ptr.value) {

.scalar => |s| {

// turn it into a list

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

list.append(s) catch unreachable;

list.append(value) catch unreachable;

self.user_input_options.put(name, .{

.name = name,

.value = .{ .list = list },

.used = false,

}) catch unreachable;

.list => |*list| {

// append to the list

list.append(value) catch unreachable;

self.user_input_options.put(name, .{

.name = name,

.value = .{ .list = list.* },

.used = false,

}) catch unreachable;

.flag => {

warn("Option '-D{s}={s}' conflicts with flag '-D{s}'.\n", .{ name, value, name });

return true;

}

return false;

}

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

const name = self.dupe(name_raw);

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

if (!gop.found_existing) {

gop.value_ptr.* = .{

.name = name,

.value = .{ .flag = {} },

.used = false,

};

return false;

}

// option already exists

switch (gop.value_ptr.value) {

.scalar => |s| {

warn("Flag '-D{s}' conflicts with option '-D{s}={s}'.\n", .{ name, name, s });

return true;

.list => {

warn("Flag '-D{s}' conflicts with multiple options of the same name.\n", .{name});

return true;

.flag => {},

}

return false;

}

fn typeToEnum(comptime T: type) TypeId {

return switch (@typeInfo(T)) {

.Int => .int,

.Float => .float,

.Bool => .bool,

.Enum => .@"enum",

else => switch (T) {

[]const u8 => .string,

[]const []const u8 => .list,

else => @compileError("Unsupported type: " ++ @typeName(T)),

};

}

fn markInvalidUserInput(self: *Builder) void {

self.invalid_user_input = true;

}

pub fn validateUserInputDidItFail(self: *Builder) bool {

// make sure all args are used

var it = self.user_input_options.iterator();

while (it.next()) |entry| {

if (!entry.value_ptr.used) {

warn("Invalid option: -D{s}\n\n", .{entry.key_ptr.*});

self.markInvalidUserInput();

}

return self.invalid_user_input;

}

pub fn spawnChild(self: *Builder, argv: []const []const u8) !void {

return self.spawnChildEnvMap(null, self.env_map, argv);

}

fn printCmd(cwd: ?[]const u8, argv: []const []const u8) void {

if (cwd) |yes_cwd| warn("cd {s} && ", .{yes_cwd});

for (argv) |arg| {

warn("{s} ", .{arg});

}

warn("\n", .{});

}

pub fn spawnChildEnvMap(self: *Builder, cwd: ?[]const u8, env_map: *const BufMap, argv: []const []const u8) !void {

if (self.verbose) {

printCmd(cwd, argv);

}

if (!std.process.can_spawn)

return error.ExecNotSupported;

const child = std.ChildProcess.init(argv, self.allocator) catch unreachable;

defer child.deinit();

child.cwd = cwd;

child.env_map = env_map;

const term = child.spawnAndWait() catch |err| {

warn("Unable to spawn {s}: {s}\n", .{ argv[0], @errorName(err) });

return err;

};

switch (term) {

.Exited => |code| {

if (code != 0) {

warn("The following command exited with error code {}:\n", .{code});

printCmd(cwd, argv);

return error.UncleanExit;

}

else => {

warn("The following command terminated unexpectedly:\n", .{});

printCmd(cwd, argv);

return error.UncleanExit;

}

View remainder of file in raw view

FilesExpand file tree

build.zig

Latest commit

History

build.zig

File metadata and controls