-
Notifications
You must be signed in to change notification settings - Fork 0
/
build.zig
127 lines (112 loc) · 3.86 KB
/
build.zig
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
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
const std = @import("std");
const Compile = std.Build.Step.Compile;
const ResolvedTarget = std.Build.ResolvedTarget;
const OptimizedMode = std.builtin.OptimizeMode;
const Dependency = std.Build.Dependency;
const Module = std.Build.Module;
const slurm = @import("slurm");
const DependencyList = std.ArrayList(DependencyNamed);
const Allocator = std.mem.Allocator;
pub const DependencyNamed = struct {
name: []const u8,
data: *Dependency,
};
pub const Exe = struct {
name: []const u8,
target: ResolvedTarget,
optimize: OptimizedMode,
build: *std.Build,
step: *Compile = undefined,
deps: DependencyList,
slurm_dep: *Dependency = undefined,
backing_allocator: Allocator,
path: []const u8 = undefined,
pub fn default(b: *std.Build, name: []const u8, allocator: Allocator, target: ResolvedTarget, optimize: OptimizedMode) !Exe {
var exe = Exe{
.name = name,
.target = target,
.optimize = optimize,
.build = b,
.deps = DependencyList.init(allocator),
.backing_allocator = allocator,
};
exe.slurm_dep = exe.stdDep("slurm");
exe.path = try std.fmt.allocPrint(
exe.backing_allocator,
"src/{s}/main.zig",
.{exe.name},
);
return exe;
}
pub fn install(self: *Exe) !void {
self.step = self.build.addExecutable(.{
.name = self.name,
.root_source_file = .{ .path = self.path },
.target = self.target,
.optimize = self.optimize,
});
try slurm.setupSlurmPath(self.step, null, self.backing_allocator);
try self.addDep("slurm");
self.linkSlurm();
self.addImports();
try self.addTests();
self.build.installArtifact(self.step);
}
fn addTests(self: Exe) !void {
const exe_unit_tests = self.build.addTest(.{
.root_source_file = .{ .path = self.path },
.target = self.target,
.optimize = self.optimize,
});
const run_exe_unit_tests = self.build.addRunArtifact(exe_unit_tests);
const test_name = try std.fmt.allocPrint(
self.backing_allocator,
"test-{s}",
.{self.name},
);
const test_step = self.build.step(test_name, "Run unit tests");
test_step.dependOn(&run_exe_unit_tests.step);
}
pub fn addImports(self: Exe) void {
for (self.deps.items) |dep| {
const mod: *Module = dep.data.module(dep.name);
self.step.root_module.addImport(dep.name, mod);
}
}
pub fn stdDep(self: Exe, name: []const u8) *Dependency {
return self.build.dependency(name, .{
.target = self.target,
.optimize = self.optimize,
});
}
pub fn namedDep(self: Exe, name: []const u8) DependencyNamed {
return .{
.name = name,
.data = self.stdDep(name),
};
}
pub fn addDep(self: *Exe, name: []const u8) !void {
try self.deps.append(
.{ .name = name, .data = self.stdDep(name) },
);
}
pub fn linkSlurm(self: Exe) void {
self.step.linkLibrary(self.slurm_dep.artifact("slurm"));
}
};
fn snodestats(b: *std.Build, allocator: Allocator, target: ResolvedTarget, optimize: OptimizedMode) !void {
var exe = try Exe.default(b, "snodestats", allocator, target, optimize);
try exe.deps.appendSlice(&[_]DependencyNamed{
exe.namedDep("prettytable"),
exe.namedDep("clap"),
});
try exe.install();
}
pub fn build(b: *std.Build) !void {
const target = b.standardTargetOptions(.{});
const optimize = b.standardOptimizeOption(.{});
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena.deinit();
const allocator = arena.allocator();
try snodestats(b, allocator, target, optimize);
}