|
| 1 | +const std = @import("../std.zig"); |
| 2 | +const ConfigHeaderStep = @This(); |
| 3 | +const Step = std.build.Step; |
| 4 | +const Builder = std.build.Builder; |
| 5 | + |
| 6 | +pub const base_id: Step.Id = .config_header; |
| 7 | + |
| 8 | +pub const Style = enum { |
| 9 | + /// The configure format supported by autotools. It uses `#undef foo` to |
| 10 | + /// mark lines that can be substituted with different values. |
| 11 | + autoconf, |
| 12 | + /// The configure format supported by CMake. It uses `@@FOO@@` and |
| 13 | + /// `#cmakedefine` for template substitution. |
| 14 | + cmake, |
| 15 | +}; |
| 16 | + |
| 17 | +pub const Value = union(enum) { |
| 18 | + undef, |
| 19 | + defined, |
| 20 | + boolean: bool, |
| 21 | + int: i64, |
| 22 | + ident: []const u8, |
| 23 | + string: []const u8, |
| 24 | +}; |
| 25 | + |
| 26 | +step: Step, |
| 27 | +builder: *Builder, |
| 28 | +source: std.build.FileSource, |
| 29 | +style: Style, |
| 30 | +values: std.StringHashMap(Value), |
| 31 | +max_bytes: usize = 2 * 1024 * 1024, |
| 32 | +output_dir: []const u8, |
| 33 | +output_basename: []const u8, |
| 34 | + |
| 35 | +pub fn create(builder: *Builder, source: std.build.FileSource, style: Style) *ConfigHeaderStep { |
| 36 | + const self = builder.allocator.create(ConfigHeaderStep) catch @panic("OOM"); |
| 37 | + const name = builder.fmt("configure header {s}", .{source.getDisplayName()}); |
| 38 | + self.* = .{ |
| 39 | + .builder = builder, |
| 40 | + .step = Step.init(base_id, name, builder.allocator, make), |
| 41 | + .source = source, |
| 42 | + .style = style, |
| 43 | + .values = std.StringHashMap(Value).init(builder.allocator), |
| 44 | + .output_dir = undefined, |
| 45 | + .output_basename = "config.h", |
| 46 | + }; |
| 47 | + switch (source) { |
| 48 | + .path => |p| { |
| 49 | + const basename = std.fs.path.basename(p); |
| 50 | + if (std.mem.endsWith(u8, basename, ".h.in")) { |
| 51 | + self.output_basename = basename[0 .. basename.len - 3]; |
| 52 | + } |
| 53 | + }, |
| 54 | + else => {}, |
| 55 | + } |
| 56 | + return self; |
| 57 | +} |
| 58 | + |
| 59 | +pub fn addValues(self: *ConfigHeaderStep, values: anytype) void { |
| 60 | + return addValuesInner(self, values) catch @panic("OOM"); |
| 61 | +} |
| 62 | + |
| 63 | +fn addValuesInner(self: *ConfigHeaderStep, values: anytype) !void { |
| 64 | + inline for (@typeInfo(@TypeOf(values)).Struct.fields) |field| { |
| 65 | + switch (@typeInfo(field.type)) { |
| 66 | + .Null => { |
| 67 | + try self.values.put(field.name, .undef); |
| 68 | + }, |
| 69 | + .Void => { |
| 70 | + try self.values.put(field.name, .defined); |
| 71 | + }, |
| 72 | + .Bool => { |
| 73 | + try self.values.put(field.name, .{ .boolean = @field(values, field.name) }); |
| 74 | + }, |
| 75 | + .ComptimeInt => { |
| 76 | + try self.values.put(field.name, .{ .int = @field(values, field.name) }); |
| 77 | + }, |
| 78 | + .EnumLiteral => { |
| 79 | + try self.values.put(field.name, .{ .ident = @tagName(@field(values, field.name)) }); |
| 80 | + }, |
| 81 | + .Pointer => |ptr| { |
| 82 | + switch (@typeInfo(ptr.child)) { |
| 83 | + .Array => |array| { |
| 84 | + if (ptr.size == .One and array.child == u8) { |
| 85 | + try self.values.put(field.name, .{ .string = @field(values, field.name) }); |
| 86 | + continue; |
| 87 | + } |
| 88 | + }, |
| 89 | + else => {}, |
| 90 | + } |
| 91 | + |
| 92 | + @compileError("unsupported ConfigHeaderStep value type: " ++ |
| 93 | + @typeName(field.type)); |
| 94 | + }, |
| 95 | + else => @compileError("unsupported ConfigHeaderStep value type: " ++ |
| 96 | + @typeName(field.type)), |
| 97 | + } |
| 98 | + } |
| 99 | +} |
| 100 | + |
| 101 | +fn make(step: *Step) !void { |
| 102 | + const self = @fieldParentPtr(ConfigHeaderStep, "step", step); |
| 103 | + const gpa = self.builder.allocator; |
| 104 | + const src_path = self.source.getPath(self.builder); |
| 105 | + const contents = try std.fs.cwd().readFileAlloc(gpa, src_path, self.max_bytes); |
| 106 | + |
| 107 | + // The cache is used here not really as a way to speed things up - because writing |
| 108 | + // the data to a file would probably be very fast - but as a way to find a canonical |
| 109 | + // location to put build artifacts. |
| 110 | + |
| 111 | + // If, for example, a hard-coded path was used as the location to put ConfigHeaderStep |
| 112 | + // files, then two ConfigHeaderStep executing in parallel might clobber each other. |
| 113 | + |
| 114 | + // TODO port the cache system from the compiler to zig std lib. Until then |
| 115 | + // we construct the path directly, and no "cache hit" detection happens; |
| 116 | + // the files are always written. |
| 117 | + // Note there is very similar code over in WriteFileStep |
| 118 | + const Hasher = std.crypto.auth.siphash.SipHash128(1, 3); |
| 119 | + // Random bytes to make ConfigHeaderStep unique. Refresh this with new |
| 120 | + // random bytes when ConfigHeaderStep implementation is modified in a |
| 121 | + // non-backwards-compatible way. |
| 122 | + var hash = Hasher.init("X1pQzdDt91Zlh7Eh"); |
| 123 | + hash.update(self.source.getDisplayName()); |
| 124 | + hash.update(contents); |
| 125 | + |
| 126 | + var digest: [16]u8 = undefined; |
| 127 | + hash.final(&digest); |
| 128 | + var hash_basename: [digest.len * 2]u8 = undefined; |
| 129 | + _ = std.fmt.bufPrint( |
| 130 | + &hash_basename, |
| 131 | + "{s}", |
| 132 | + .{std.fmt.fmtSliceHexLower(&digest)}, |
| 133 | + ) catch unreachable; |
| 134 | + |
| 135 | + self.output_dir = try std.fs.path.join(gpa, &[_][]const u8{ |
| 136 | + self.builder.cache_root, "o", &hash_basename, |
| 137 | + }); |
| 138 | + var dir = std.fs.cwd().makeOpenPath(self.output_dir, .{}) catch |err| { |
| 139 | + std.debug.print("unable to make path {s}: {s}\n", .{ self.output_dir, @errorName(err) }); |
| 140 | + return err; |
| 141 | + }; |
| 142 | + defer dir.close(); |
| 143 | + |
| 144 | + var values_copy = try self.values.clone(); |
| 145 | + defer values_copy.deinit(); |
| 146 | + |
| 147 | + var output = std.ArrayList(u8).init(gpa); |
| 148 | + defer output.deinit(); |
| 149 | + try output.ensureTotalCapacity(contents.len); |
| 150 | + |
| 151 | + try output.appendSlice("/* This file was generated by ConfigHeaderStep using the Zig Build System. */\n"); |
| 152 | + |
| 153 | + switch (self.style) { |
| 154 | + .autoconf => try render_autoconf(contents, &output, &values_copy, src_path), |
| 155 | + .cmake => try render_cmake(contents, &output, &values_copy, src_path), |
| 156 | + } |
| 157 | + |
| 158 | + try dir.writeFile(self.output_basename, output.items); |
| 159 | +} |
| 160 | + |
| 161 | +fn render_autoconf( |
| 162 | + contents: []const u8, |
| 163 | + output: *std.ArrayList(u8), |
| 164 | + values_copy: *std.StringHashMap(Value), |
| 165 | + src_path: []const u8, |
| 166 | +) !void { |
| 167 | + var any_errors = false; |
| 168 | + var line_index: u32 = 0; |
| 169 | + var line_it = std.mem.split(u8, contents, "\n"); |
| 170 | + while (line_it.next()) |line| : (line_index += 1) { |
| 171 | + if (!std.mem.startsWith(u8, line, "#")) { |
| 172 | + try output.appendSlice(line); |
| 173 | + try output.appendSlice("\n"); |
| 174 | + continue; |
| 175 | + } |
| 176 | + var it = std.mem.tokenize(u8, line[1..], " \t\r"); |
| 177 | + const undef = it.next().?; |
| 178 | + if (!std.mem.eql(u8, undef, "undef")) { |
| 179 | + try output.appendSlice(line); |
| 180 | + try output.appendSlice("\n"); |
| 181 | + continue; |
| 182 | + } |
| 183 | + const name = it.rest(); |
| 184 | + const kv = values_copy.fetchRemove(name) orelse { |
| 185 | + std.debug.print("{s}:{d}: error: unspecified config header value: '{s}'\n", .{ |
| 186 | + src_path, line_index + 1, name, |
| 187 | + }); |
| 188 | + any_errors = true; |
| 189 | + continue; |
| 190 | + }; |
| 191 | + switch (kv.value) { |
| 192 | + .undef => { |
| 193 | + try output.appendSlice("/* #undef "); |
| 194 | + try output.appendSlice(name); |
| 195 | + try output.appendSlice(" */\n"); |
| 196 | + }, |
| 197 | + .defined => { |
| 198 | + try output.appendSlice("#define "); |
| 199 | + try output.appendSlice(name); |
| 200 | + try output.appendSlice("\n"); |
| 201 | + }, |
| 202 | + .boolean => |b| { |
| 203 | + try output.appendSlice("#define "); |
| 204 | + try output.appendSlice(name); |
| 205 | + try output.appendSlice(" "); |
| 206 | + try output.appendSlice(if (b) "true\n" else "false\n"); |
| 207 | + }, |
| 208 | + .int => |i| { |
| 209 | + try output.writer().print("#define {s} {d}\n", .{ name, i }); |
| 210 | + }, |
| 211 | + .ident => |ident| { |
| 212 | + try output.writer().print("#define {s} {s}\n", .{ name, ident }); |
| 213 | + }, |
| 214 | + .string => |string| { |
| 215 | + // TODO: use C-specific escaping instead of zig string literals |
| 216 | + try output.writer().print("#define {s} \"{}\"\n", .{ name, std.zig.fmtEscapes(string) }); |
| 217 | + }, |
| 218 | + } |
| 219 | + } |
| 220 | + |
| 221 | + { |
| 222 | + var it = values_copy.iterator(); |
| 223 | + while (it.next()) |entry| { |
| 224 | + const name = entry.key_ptr.*; |
| 225 | + std.debug.print("{s}: error: config header value unused: '{s}'\n", .{ src_path, name }); |
| 226 | + } |
| 227 | + } |
| 228 | + |
| 229 | + if (any_errors) { |
| 230 | + return error.HeaderConfigFailed; |
| 231 | + } |
| 232 | +} |
| 233 | + |
| 234 | +fn render_cmake( |
| 235 | + contents: []const u8, |
| 236 | + output: *std.ArrayList(u8), |
| 237 | + values_copy: *std.StringHashMap(Value), |
| 238 | + src_path: []const u8, |
| 239 | +) !void { |
| 240 | + _ = contents; |
| 241 | + _ = output; |
| 242 | + _ = values_copy; |
| 243 | + _ = src_path; |
| 244 | + @panic("TODO: render_cmake is not implemented yet"); |
| 245 | +} |
0 commit comments