authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2023-02-05 08:27:53-05:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2023-02-05 08:27:53-05:00
loga5b34a61ab61882bf55d87e4cbc8186215ecf320
tree7b436f99dc6063e380813a0a357351f301fdbaad
parent11cc1c16fa36a7eb13cba1c43fb153ee6aca7b58
parentb29e3fa2cd667cc967b4c7dfb5023e5ac0224d96
signature Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #14562: std.Build: enhancements to ConfigHeaderStep

5 files changed, 165 insertions(+), 76 deletions(-)

lib/std/Build.zig+7-3
......@@ -598,13 +598,17 @@ pub fn addSystemCommand(self: *Build, argv: []const []const u8) *RunStep {
598598 return run_step;
599599}
600600
601/// Using the `values` provided, produces a C header file, possibly based on a
602/// template input file (e.g. config.h.in).
603/// When an input template file is provided, this function will fail the build
604/// when an option not found in the input file is provided in `values`, and
605/// when an option found in the input file is missing from `values`.
601606pub fn addConfigHeader(
602607 b: *Build,
603 source: FileSource,
604 style: ConfigHeaderStep.Style,
608 options: ConfigHeaderStep.Options,
605609 values: anytype,
606610) *ConfigHeaderStep {
607 const config_header_step = ConfigHeaderStep.create(b, source, style);
611 const config_header_step = ConfigHeaderStep.create(b, options);
608612 config_header_step.addValues(values);
609613 return config_header_step;
610614}
lib/std/Build/CompileStep.zig+23-2
......@@ -442,6 +442,26 @@ pub fn installHeader(a: *CompileStep, src_path: []const u8, dest_rel_path: []con
442442 a.installed_headers.append(&install_file.step) catch @panic("OOM");
443443}
444444
445pub const InstallConfigHeaderOptions = struct {
446 install_dir: InstallDir = .header,
447 dest_rel_path: ?[]const u8 = null,
448};
449
450pub fn installConfigHeader(
451 cs: *CompileStep,
452 config_header: *ConfigHeaderStep,
453 options: InstallConfigHeaderOptions,
454) void {
455 const dest_rel_path = options.dest_rel_path orelse config_header.include_path;
456 const install_file = cs.builder.addInstallFileWithDir(
457 .{ .generated = &config_header.output_file },
458 options.install_dir,
459 dest_rel_path,
460 );
461 cs.builder.getInstallStep().dependOn(&install_file.step);
462 cs.installed_headers.append(&install_file.step) catch @panic("OOM");
463}
464
445465pub fn installHeadersDirectory(
446466 a: *CompileStep,
447467 src_dir_path: []const u8,
......@@ -1622,8 +1642,9 @@ fn make(step: *Step) !void {
16221642 }
16231643 },
16241644 .config_header_step => |config_header| {
1625 try zig_args.append("-I");
1626 try zig_args.append(config_header.output_dir);
1645 const full_file_path = config_header.output_file.path.?;
1646 const header_dir_path = full_file_path[0 .. full_file_path.len - config_header.include_path.len];
1647 try zig_args.appendSlice(&.{ "-I", header_dir_path });
16271648 },
16281649 }
16291650 }
lib/std/Build/ConfigHeaderStep.zig+128-55
......@@ -4,13 +4,22 @@ const Step = std.Build.Step;
44
55pub const base_id: Step.Id = .config_header;
66
7pub const Style = enum {
7pub const Style = union(enum) {
88 /// The configure format supported by autotools. It uses `#undef foo` to
99 /// mark lines that can be substituted with different values.
10 autoconf,
10 autoconf: std.Build.FileSource,
1111 /// The configure format supported by CMake. It uses `@@FOO@@` and
1212 /// `#cmakedefine` for template substitution.
13 cmake,
13 cmake: std.Build.FileSource,
14 /// Instead of starting with an input file, start with nothing.
15 blank,
16
17 pub fn getFileSource(style: Style) ?std.Build.FileSource {
18 switch (style) {
19 .autoconf, .cmake => |s| return s,
20 .blank => return null,
21 }
22 }
1423};
1524
1625pub const Value = union(enum) {
......@@ -24,34 +33,50 @@ pub const Value = union(enum) {
2433
2534step: Step,
2635builder: *std.Build,
27source: std.Build.FileSource,
36values: std.StringArrayHashMap(Value),
37output_file: std.Build.GeneratedFile,
38
2839style: Style,
29values: std.StringHashMap(Value),
30max_bytes: usize = 2 * 1024 * 1024,
31output_dir: []const u8,
32output_basename: []const u8,
40max_bytes: usize,
41include_path: []const u8,
3342
34pub fn create(builder: *std.Build, source: std.Build.FileSource, style: Style) *ConfigHeaderStep {
43pub const Options = struct {
44 style: Style = .blank,
45 max_bytes: usize = 2 * 1024 * 1024,
46 include_path: ?[]const u8 = null,
47};
48
49pub fn create(builder: *std.Build, options: Options) *ConfigHeaderStep {
3550 const self = builder.allocator.create(ConfigHeaderStep) catch @panic("OOM");
36 const name = builder.fmt("configure header {s}", .{source.getDisplayName()});
51 const name = if (options.style.getFileSource()) |s|
52 builder.fmt("configure {s} header {s}", .{ @tagName(options.style), s.getDisplayName() })
53 else
54 builder.fmt("configure {s} header", .{@tagName(options.style)});
3755 self.* = .{
3856 .builder = builder,
3957 .step = Step.init(base_id, name, builder.allocator, make),
40 .source = source,
41 .style = style,
42 .values = std.StringHashMap(Value).init(builder.allocator),
43 .output_dir = undefined,
44 .output_basename = "config.h",
58 .style = options.style,
59 .values = std.StringArrayHashMap(Value).init(builder.allocator),
60
61 .max_bytes = options.max_bytes,
62 .include_path = "config.h",
63 .output_file = .{ .step = &self.step },
4564 };
46 switch (source) {
65
66 if (options.style.getFileSource()) |s| switch (s) {
4767 .path => |p| {
4868 const basename = std.fs.path.basename(p);
4969 if (std.mem.endsWith(u8, basename, ".h.in")) {
50 self.output_basename = basename[0 .. basename.len - 3];
70 self.include_path = basename[0 .. basename.len - 3];
5171 }
5272 },
5373 else => {},
74 };
75
76 if (options.include_path) |include_path| {
77 self.include_path = include_path;
5478 }
79
5580 return self;
5681}
5782
......@@ -112,8 +137,6 @@ fn putValue(self: *ConfigHeaderStep, field_name: []const u8, comptime T: type, v
112137fn make(step: *Step) !void {
113138 const self = @fieldParentPtr(ConfigHeaderStep, "step", step);
114139 const gpa = self.builder.allocator;
115 const src_path = self.source.getPath(self.builder);
116 const contents = try std.fs.cwd().readFileAlloc(gpa, src_path, self.max_bytes);
117140
118141 // The cache is used here not really as a way to speed things up - because writing
119142 // the data to a file would probably be very fast - but as a way to find a canonical
......@@ -130,9 +153,30 @@ fn make(step: *Step) !void {
130153 // Random bytes to make ConfigHeaderStep unique. Refresh this with new
131154 // random bytes when ConfigHeaderStep implementation is modified in a
132155 // non-backwards-compatible way.
133 var hash = Hasher.init("X1pQzdDt91Zlh7Eh");
134 hash.update(self.source.getDisplayName());
135 hash.update(contents);
156 var hash = Hasher.init("PGuDTpidxyMqnkGM");
157
158 var output = std.ArrayList(u8).init(gpa);
159 defer output.deinit();
160
161 try output.appendSlice("/* This file was generated by ConfigHeaderStep using the Zig Build System. */\n");
162
163 switch (self.style) {
164 .autoconf => |file_source| {
165 const src_path = file_source.getPath(self.builder);
166 const contents = try std.fs.cwd().readFileAlloc(gpa, src_path, self.max_bytes);
167 try render_autoconf(contents, &output, self.values, src_path);
168 },
169 .cmake => |file_source| {
170 const src_path = file_source.getPath(self.builder);
171 const contents = try std.fs.cwd().readFileAlloc(gpa, src_path, self.max_bytes);
172 try render_cmake(contents, &output, self.values, src_path);
173 },
174 .blank => {
175 try render_blank(&output, self.values, self.include_path);
176 },
177 }
178
179 hash.update(output.items);
136180
137181 var digest: [16]u8 = undefined;
138182 hash.final(&digest);
......@@ -143,38 +187,42 @@ fn make(step: *Step) !void {
143187 .{std.fmt.fmtSliceHexLower(&digest)},
144188 ) catch unreachable;
145189
146 self.output_dir = try std.fs.path.join(gpa, &[_][]const u8{
190 const output_dir = try std.fs.path.join(gpa, &[_][]const u8{
147191 self.builder.cache_root, "o", &hash_basename,
148192 });
149 var dir = std.fs.cwd().makeOpenPath(self.output_dir, .{}) catch |err| {
150 std.debug.print("unable to make path {s}: {s}\n", .{ self.output_dir, @errorName(err) });
193
194 // If output_path has directory parts, deal with them. Example:
195 // output_dir is zig-cache/o/HASH
196 // output_path is libavutil/avconfig.h
197 // We want to open directory zig-cache/o/HASH/libavutil/
198 // but keep output_dir as zig-cache/o/HASH for -I include
199 const sub_dir_path = if (std.fs.path.dirname(self.include_path)) |d|
200 try std.fs.path.join(gpa, &.{ output_dir, d })
201 else
202 output_dir;
203
204 var dir = std.fs.cwd().makeOpenPath(sub_dir_path, .{}) catch |err| {
205 std.debug.print("unable to make path {s}: {s}\n", .{ output_dir, @errorName(err) });
151206 return err;
152207 };
153208 defer dir.close();
154209
155 var values_copy = try self.values.clone();
156 defer values_copy.deinit();
210 try dir.writeFile(std.fs.path.basename(self.include_path), output.items);
157211
158 var output = std.ArrayList(u8).init(gpa);
159 defer output.deinit();
160 try output.ensureTotalCapacity(contents.len);
161
162 try output.appendSlice("/* This file was generated by ConfigHeaderStep using the Zig Build System. */\n");
163
164 switch (self.style) {
165 .autoconf => try render_autoconf(contents, &output, &values_copy, src_path),
166 .cmake => try render_cmake(contents, &output, &values_copy, src_path),
167 }
168
169 try dir.writeFile(self.output_basename, output.items);
212 self.output_file.path = try std.fs.path.join(self.builder.allocator, &.{
213 output_dir, self.include_path,
214 });
170215}
171216
172217fn render_autoconf(
173218 contents: []const u8,
174219 output: *std.ArrayList(u8),
175 values_copy: *std.StringHashMap(Value),
220 values: std.StringArrayHashMap(Value),
176221 src_path: []const u8,
177222) !void {
223 var values_copy = try values.clone();
224 defer values_copy.deinit();
225
178226 var any_errors = false;
179227 var line_index: u32 = 0;
180228 var line_it = std.mem.split(u8, contents, "\n");
......@@ -192,7 +240,7 @@ fn render_autoconf(
192240 continue;
193241 }
194242 const name = it.rest();
195 const kv = values_copy.fetchRemove(name) orelse {
243 const kv = values_copy.fetchSwapRemove(name) orelse {
196244 std.debug.print("{s}:{d}: error: unspecified config header value: '{s}'\n", .{
197245 src_path, line_index + 1, name,
198246 });
......@@ -202,12 +250,8 @@ fn render_autoconf(
202250 try renderValue(output, name, kv.value);
203251 }
204252
205 {
206 var it = values_copy.iterator();
207 while (it.next()) |entry| {
208 const name = entry.key_ptr.*;
209 std.debug.print("{s}: error: config header value unused: '{s}'\n", .{ src_path, name });
210 }
253 for (values_copy.keys()) |name| {
254 std.debug.print("{s}: error: config header value unused: '{s}'\n", .{ src_path, name });
211255 }
212256
213257 if (any_errors) {
......@@ -218,9 +262,12 @@ fn render_autoconf(
218262fn render_cmake(
219263 contents: []const u8,
220264 output: *std.ArrayList(u8),
221 values_copy: *std.StringHashMap(Value),
265 values: std.StringArrayHashMap(Value),
222266 src_path: []const u8,
223267) !void {
268 var values_copy = try values.clone();
269 defer values_copy.deinit();
270
224271 var any_errors = false;
225272 var line_index: u32 = 0;
226273 var line_it = std.mem.split(u8, contents, "\n");
......@@ -244,7 +291,7 @@ fn render_cmake(
244291 any_errors = true;
245292 continue;
246293 };
247 const kv = values_copy.fetchRemove(name) orelse {
294 const kv = values_copy.fetchSwapRemove(name) orelse {
248295 std.debug.print("{s}:{d}: error: unspecified config header value: '{s}'\n", .{
249296 src_path, line_index + 1, name,
250297 });
......@@ -254,12 +301,8 @@ fn render_cmake(
254301 try renderValue(output, name, kv.value);
255302 }
256303
257 {
258 var it = values_copy.iterator();
259 while (it.next()) |entry| {
260 const name = entry.key_ptr.*;
261 std.debug.print("{s}: error: config header value unused: '{s}'\n", .{ src_path, name });
262 }
304 for (values_copy.keys()) |name| {
305 std.debug.print("{s}: error: config header value unused: '{s}'\n", .{ src_path, name });
263306 }
264307
265308 if (any_errors) {
......@@ -267,6 +310,36 @@ fn render_cmake(
267310 }
268311}
269312
313fn render_blank(
314 output: *std.ArrayList(u8),
315 defines: std.StringArrayHashMap(Value),
316 include_path: []const u8,
317) !void {
318 const include_guard_name = try output.allocator.dupe(u8, include_path);
319 for (include_guard_name) |*byte| {
320 switch (byte.*) {
321 'a'...'z' => byte.* = byte.* - 'a' + 'A',
322 'A'...'Z', '0'...'9' => continue,
323 else => byte.* = '_',
324 }
325 }
326
327 try output.appendSlice("#ifndef ");
328 try output.appendSlice(include_guard_name);
329 try output.appendSlice("\n#define ");
330 try output.appendSlice(include_guard_name);
331 try output.appendSlice("\n");
332
333 const values = defines.values();
334 for (defines.keys()) |name, i| {
335 try renderValue(output, name, values[i]);
336 }
337
338 try output.appendSlice("#endif /* ");
339 try output.appendSlice(include_guard_name);
340 try output.appendSlice(" */\n");
341}
342
270343fn renderValue(output: *std.ArrayList(u8), name: []const u8, value: Value) !void {
271344 switch (value) {
272345 .undef => {
lib/std/Build/TranslateCStep.zig+2-9
......@@ -15,7 +15,6 @@ builder: *std.Build,
1515source: std.Build.FileSource,
1616include_dirs: std.ArrayList([]const u8),
1717c_macros: std.ArrayList([]const u8),
18output_dir: ?[]const u8,
1918out_basename: []const u8,
2019target: CrossTarget,
2120optimize: std.builtin.OptimizeMode,
......@@ -36,7 +35,6 @@ pub fn create(builder: *std.Build, options: Options) *TranslateCStep {
3635 .source = source,
3736 .include_dirs = std.ArrayList([]const u8).init(builder.allocator),
3837 .c_macros = std.ArrayList([]const u8).init(builder.allocator),
39 .output_dir = null,
4038 .out_basename = undefined,
4139 .target = options.target,
4240 .optimize = options.optimize,
......@@ -122,15 +120,10 @@ fn make(step: *Step) !void {
122120 const output_path = mem.trimRight(u8, output_path_nl, "\r\n");
123121
124122 self.out_basename = fs.path.basename(output_path);
125 if (self.output_dir) |output_dir| {
126 const full_dest = try fs.path.join(self.builder.allocator, &[_][]const u8{ output_dir, self.out_basename });
127 try self.builder.updateFile(output_path, full_dest);
128 } else {
129 self.output_dir = fs.path.dirname(output_path).?;
130 }
123 const output_dir = fs.path.dirname(output_path).?;
131124
132125 self.output_file.path = try fs.path.join(
133126 self.builder.allocator,
134 &[_][]const u8{ self.output_dir.?, self.out_basename },
127 &[_][]const u8{ output_dir, self.out_basename },
135128 );
136129}
lib/std/Build/WriteFileStep.zig+5-7
......@@ -9,7 +9,6 @@ pub const base_id = .write_file;
99
1010step: Step,
1111builder: *std.Build,
12output_dir: []const u8,
1312files: std.TailQueue(File),
1413
1514pub const File = struct {
......@@ -23,7 +22,6 @@ pub fn init(builder: *std.Build) WriteFileStep {
2322 .builder = builder,
2423 .step = Step.init(.write_file, "writefile", builder.allocator, make),
2524 .files = .{},
26 .output_dir = undefined,
2725 };
2826}
2927
......@@ -87,11 +85,11 @@ fn make(step: *Step) !void {
8785 .{std.fmt.fmtSliceHexLower(&digest)},
8886 ) catch unreachable;
8987
90 self.output_dir = try fs.path.join(self.builder.allocator, &[_][]const u8{
88 const output_dir = try fs.path.join(self.builder.allocator, &[_][]const u8{
9189 self.builder.cache_root, "o", &hash_basename,
9290 });
93 var dir = fs.cwd().makeOpenPath(self.output_dir, .{}) catch |err| {
94 std.debug.print("unable to make path {s}: {s}\n", .{ self.output_dir, @errorName(err) });
91 var dir = fs.cwd().makeOpenPath(output_dir, .{}) catch |err| {
92 std.debug.print("unable to make path {s}: {s}\n", .{ output_dir, @errorName(err) });
9593 return err;
9694 };
9795 defer dir.close();
......@@ -101,14 +99,14 @@ fn make(step: *Step) !void {
10199 dir.writeFile(node.data.basename, node.data.bytes) catch |err| {
102100 std.debug.print("unable to write {s} into {s}: {s}\n", .{
103101 node.data.basename,
104 self.output_dir,
102 output_dir,
105103 @errorName(err),
106104 });
107105 return err;
108106 };
109107 node.data.source.path = try fs.path.join(
110108 self.builder.allocator,
111 &[_][]const u8{ self.output_dir, node.data.basename },
109 &[_][]const u8{ output_dir, node.data.basename },
112110 );
113111 }
114112 }