tristan/exercises
1
0
Fork 0
mirror of https://codeberg.org/ziglings/exercises.git synced 2024-12-26 01:20:30 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

first test for new build system

Browse source
This commit is contained in:
Chris Boesch 2023-03-19 00:59:42 +01:00
parent 4455afebf9
commit 78e856f602
1 changed files with 59 additions and 61 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

120
build.zig
View file

@ -8,7 +8,7 @@ const print = std.debug.print;
// When changing this version, be sure to also update README.md in two places: // When changing this version, be sure to also update README.md in two places:
// 1) Getting Started // 1) Getting Started
// 2) Version Changes // 2) Version Changes
const needed_version = std.SemanticVersion.parse("0.11.0-dev.1844") catch unreachable; const needed_version = std.SemanticVersion.parse("0.11.0-dev.2157") catch unreachable;
const Exercise = struct { const Exercise = struct {
/// main_file must have the format key_name.zig. /// main_file must have the format key_name.zig.
@ -505,7 +505,7 @@ fn checkVersion() bool {
return order != .lt; return order != .lt;
} }
pub fn build(b: *Builder) void { pub fn build(b: *Builder) !void {
// Use a comptime branch for the version check. // Use a comptime branch for the version check.
// If this fails, code after this block is not compiled. // If this fails, code after this block is not compiled.
// It is parsed though, so versions of zig from before 0.6.0 // It is parsed though, so versions of zig from before 0.6.0
@ -533,30 +533,24 @@ pub fn build(b: *Builder) void {
} }
use_color_escapes = false; use_color_escapes = false;
switch (b.color) { if (std.io.getStdErr().supportsAnsiEscapeCodes()) {
.on => use_color_escapes = true, use_color_escapes = true;
.off => use_color_escapes = false, } else if (builtin.os.tag == .windows) {
.auto => { const w32 = struct {
if (std.io.getStdErr().supportsAnsiEscapeCodes()) { const WINAPI = std.os.windows.WINAPI;
use_color_escapes = true; const DWORD = std.os.windows.DWORD;
} else if (builtin.os.tag == .windows) { const ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004;
const w32 = struct { const STD_ERROR_HANDLE = @bitCast(DWORD, @as(i32, -12));
const WINAPI = std.os.windows.WINAPI; extern "kernel32" fn GetStdHandle(id: DWORD) callconv(WINAPI) ?*anyopaque;
const DWORD = std.os.windows.DWORD; extern "kernel32" fn GetConsoleMode(console: ?*anyopaque, out_mode: *DWORD) callconv(WINAPI) u32;
const ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004; extern "kernel32" fn SetConsoleMode(console: ?*anyopaque, mode: DWORD) callconv(WINAPI) u32;
const STD_ERROR_HANDLE = @bitCast(DWORD, @as(i32, -12)); };
extern "kernel32" fn GetStdHandle(id: DWORD) callconv(WINAPI) ?*anyopaque; const handle = w32.GetStdHandle(w32.STD_ERROR_HANDLE);
extern "kernel32" fn GetConsoleMode(console: ?*anyopaque, out_mode: *DWORD) callconv(WINAPI) u32; var mode: w32.DWORD = 0;
extern "kernel32" fn SetConsoleMode(console: ?*anyopaque, mode: DWORD) callconv(WINAPI) u32; if (w32.GetConsoleMode(handle, &mode) != 0) {
}; mode |= w32.ENABLE_VIRTUAL_TERMINAL_PROCESSING;
const handle = w32.GetStdHandle(w32.STD_ERROR_HANDLE); use_color_escapes = w32.SetConsoleMode(handle, mode) != 0;
var mode: w32.DWORD = 0; }
if (w32.GetConsoleMode(handle, &mode) != 0) {
mode |= w32.ENABLE_VIRTUAL_TERMINAL_PROCESSING;
use_color_escapes = w32.SetConsoleMode(handle, mode) != 0;
}
}
},
} }
if (use_color_escapes) { if (use_color_escapes) {
@ -566,7 +560,7 @@ pub fn build(b: *Builder) void {
reset_text = "\x1b[0m"; reset_text = "\x1b[0m";
} }
const header_step = b.addLog( const logo =
\\ \\
\\ _ _ _ \\ _ _ _
\\ ___(_) __ _| (_)_ __ __ _ ___ \\ ___(_) __ _| (_)_ __ __ _ ___
@ -576,50 +570,57 @@ pub fn build(b: *Builder) void {
\\ |___/ |___/ \\ |___/ |___/
\\ \\
\\ \\
, .{}); ;
const header_step = b.step("header", logo);
print("{s}\n", .{logo});
const verify_all = b.step("ziglings", "Check all ziglings"); const verify_all = b.step("ziglings", "Check all ziglings");
verify_all.dependOn(&header_step.step); verify_all.dependOn(header_step);
b.default_step = verify_all; b.default_step = verify_all;
var prev_chain_verify = verify_all; var prev_chain_verify = verify_all;
const use_healed = b.option(bool, "healed", "Run exercises from patches/healed") orelse false; const use_healed = b.option(bool, "healed", "Run exercises from patches/healed") orelse false;
for (exercises) |ex| { // for (exercises) |ex| {
const base_name = ex.baseName(); const ex = exercises[0];
const file_path = std.fs.path.join(b.allocator, &[_][]const u8{ const base_name = ex.baseName();
if (use_healed) "patches/healed" else "exercises", ex.main_file, const file_path = std.fs.path.join(b.allocator, &[_][]const u8{
}) catch unreachable; if (use_healed) "patches/healed" else "exercises", ex.main_file,
const build_step = b.addExecutable(.{ .name = base_name, .root_source_file = .{ .path = file_path } }); }) catch unreachable;
const build_step = b.addExecutable(.{ .name = base_name, .root_source_file = .{ .path = file_path } });
build_step.install(); build_step.install();
// std.time.sleep(1000000);
const verify_step = ZiglingStep.create(b, ex, use_healed); const verify_step = ZiglingStep.create(b, ex, use_healed);
const key = ex.key(); const key = ex.key();
const named_test = b.step(b.fmt("{s}_test", .{key}), b.fmt("Run {s} without checking output", .{ex.main_file})); const named_test = b.step(b.fmt("{s}_test", .{key}), b.fmt("Run {s} without checking output", .{ex.main_file}));
const run_step = build_step.run(); const run_step = build_step.run();
named_test.dependOn(&run_step.step); named_test.dependOn(&run_step.step);
const named_install = b.step(b.fmt("{s}_install", .{key}), b.fmt("Install {s} to zig-cache/bin", .{ex.main_file})); const named_install = b.step(b.fmt("{s}_install", .{key}), b.fmt("Install {s} to zig-cache/bin", .{ex.main_file}));
named_install.dependOn(&build_step.install_step.?.step); named_install.dependOn(&build_step.install_step.?.step);
const named_verify = b.step(key, b.fmt("Check {s} only", .{ex.main_file})); const named_verify = b.step(key, b.fmt("Check {s} only", .{ex.main_file}));
named_verify.dependOn(&verify_step.step); named_verify.dependOn(&verify_step.step);
const chain_verify = b.allocator.create(Step) catch unreachable; const chain_verify = b.allocator.create(Step) catch unreachable;
chain_verify.* = Step.initNoOp(.custom, b.fmt("chain {s}", .{key}), b.allocator); chain_verify.* = Step.init(Step.Options{ .id = .custom, .name = b.fmt("chain {s}", .{key}), .owner = b });
chain_verify.dependOn(&verify_step.step); chain_verify.dependOn(&verify_step.step);
const named_chain = b.step(b.fmt("{s}_start", .{key}), b.fmt("Check all solutions starting at {s}", .{ex.main_file})); const named_chain = b.step(b.fmt("{s}_start", .{key}), b.fmt("Check all solutions starting at {s}", .{ex.main_file}));
named_chain.dependOn(&header_step.step); named_chain.dependOn(header_step);
named_chain.dependOn(chain_verify); named_chain.dependOn(chain_verify);
prev_chain_verify.dependOn(chain_verify); prev_chain_verify.dependOn(chain_verify);
prev_chain_verify = chain_verify; prev_chain_verify = chain_verify;
} // std.os.exit(0);
// while (true) {}
// }
} }
var use_color_escapes = false; var use_color_escapes = false;
@ -637,7 +638,8 @@ const ZiglingStep = struct {
pub fn create(builder: *Builder, exercise: Exercise, use_healed: bool) *@This() { pub fn create(builder: *Builder, exercise: Exercise, use_healed: bool) *@This() {
const self = builder.allocator.create(@This()) catch unreachable; const self = builder.allocator.create(@This()) catch unreachable;
self.* = .{ self.* = .{
.step = Step.init(.custom, exercise.main_file, builder.allocator, make), // .step = Step.init(.custom, exercise.main_file, builder.allocator, make),
.step = Step.init(Step.Options{ .id = .custom, .name = exercise.main_file, .owner = builder, .makeFn = make }),
.exercise = exercise, .exercise = exercise,
.builder = builder, .builder = builder,
.use_healed = use_healed, .use_healed = use_healed,
@ -645,7 +647,8 @@ const ZiglingStep = struct {
return self; return self;
} }
fn make(step: *Step) anyerror!void { fn make(step: *Step, prog_node: *std.Progress.Node) anyerror!void {
_ = prog_node;
const self = @fieldParentPtr(@This(), "step", step); const self = @fieldParentPtr(@This(), "step", step);
self.makeInternal() catch { self.makeInternal() catch {
if (self.exercise.hint.len > 0) { if (self.exercise.hint.len > 0) {
@ -756,11 +759,6 @@ const ZiglingStep = struct {
zig_args.append("-lc") catch unreachable; zig_args.append("-lc") catch unreachable;
} }
if (builder.color != .auto) {
zig_args.append("--color") catch unreachable;
zig_args.append(@tagName(builder.color)) catch unreachable;
}
const zig_file = std.fs.path.join(builder.allocator, &[_][]const u8{ if (self.use_healed) "patches/healed" else "exercises", self.exercise.main_file }) catch unreachable; const zig_file = std.fs.path.join(builder.allocator, &[_][]const u8{ if (self.use_healed) "patches/healed" else "exercises", self.exercise.main_file }) catch unreachable;
zig_args.append(builder.pathFromRoot(zig_file)) catch unreachable; zig_args.append(builder.pathFromRoot(zig_file)) catch unreachable;