using root_module.addOptions to add options

Author: ItsMeSamey

build.zig

@@ -1,27 +1,26 @@
 const std = @import("std");
-const IntLen = @import("src/build_config.zig").IntLen;
+
+const IntLen = enum {
+    u16,
+    u32,
+    u64,
+    usize,
+};
 
 /// Configures build artifacts, helper steps, and test/check pipelines.
 pub fn build(b: *std.Build) void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
     const intlen = b.option(IntLen, "intlen", "Integer width used for document spans and node indexes") orelse .u32;
 
-    const build_config = b.addOptions();
-    build_config.addOption(IntLen, "intlen", intlen);
-
-    const config_mod = b.createModule(.{
-        .root_source_file = b.path("src/config.zig"),
-        .target = target,
-        .optimize = optimize,
-    });
-    config_mod.addOptions("build_config", build_config);
+    const config_options = b.addOptions();
+    config_options.addOption(IntLen, "intlen", intlen);
 
     const mod = b.addModule("htmlparser", .{
         .root_source_file = b.path("src/root.zig"),
         .target = target,
     });
-    mod.addImport("config", config_mod);
+    mod.addOptions("config", config_options);
 
     const exe = b.addExecutable(.{
         .name = "htmlparser",
@@ -31,10 +30,10 @@ pub fn build(b: *std.Build) void {
             .optimize = optimize,
             .imports = &.{
                 .{ .name = "htmlparser", .module = mod },
-                .{ .name = "config", .module = config_mod },
             },
         }),
     });
+    exe.root_module.addOptions("config", config_options);
 
     const parse_mode_mod = b.createModule(.{
         .root_source_file = b.path("tools/parse_mode.zig"),

src/common.zig

@@ -1,7 +1,22 @@
 const std = @import("std");
 const config = @import("config");
 
-pub const IndexInt = config.Int;
+pub const IndexInt = switch (config.intlen) {
+    .u16 => u16,
+    .u32 => u32,
+    .u64 => u64,
+    .usize => usize,
+};
+
+/// Maximum input length representable by the configured index width.
+pub const MaxLen: usize = if (@sizeOf(IndexInt) >= @sizeOf(usize))
+    std.math.maxInt(usize)
+else
+    @as(usize, std.math.maxInt(IndexInt));
+
+pub inline fn lenFits(len: usize) bool {
+    return len <= MaxLen;
+}
 
 /// Sentinel for invalid node indexes in DOM/query paths.
 pub const InvalidIndex: IndexInt = std.math.maxInt(IndexInt);

src/html/parser.zig

@@ -3,7 +3,6 @@ const tables = @import("tables.zig");
 const tags = @import("tags.zig");
 const scanner = @import("scanner.zig");
 const common = @import("../common.zig");
-const config = @import("config");
 
 const InvalidIndex: IndexInt = common.InvalidIndex;
 const IndexInt = common.IndexInt;
@@ -16,7 +15,7 @@ const MaxInitialNodeReserve: usize = 1 << 20;
 
 /// Parses mutable HTML bytes into `doc` using permissive, in-place tree construction.
 pub fn parseInto(comptime Doc: type, noalias doc: *Doc, input: []u8, comptime opts: anytype) !void {
-    if (!config.lenFits(input.len)) return error.InputTooLarge;
+    if (!common.lenFits(input.len)) return error.InputTooLarge;
     var p = Parser(Doc, opts){
         .doc = doc,
         .input = input,

src/root.zig

@@ -1,6 +1,5 @@
 const std = @import("std");
-const config = @import("config");
-pub const ParseInt = @import("config").Int;
+pub const ParseInt = @import("common.zig").IndexInt;
 
 /// Parse-time configuration and type factory for `Document`, `Node`, and iterators.
 pub const ParseOptions = @import("html/document.zig").ParseOptions;
@@ -247,7 +246,11 @@ test "u16 parse rejects oversized input" {
     var doc = Document.init(alloc);
     defer doc.deinit();
 
-    const src = try alloc.alloc(u8, config.max_len + 1);
+    const max_len: usize = if (@sizeOf(ParseInt) >= @sizeOf(usize))
+        std.math.maxInt(usize)
+    else
+        @as(usize, std.math.maxInt(ParseInt));
+    const src = try alloc.alloc(u8, max_len + 1);
     defer alloc.free(src);
     @memset(src, 'a');
     src[0] = '<';

tools/scripts.zig

@@ -1642,8 +1642,13 @@ fn buildSuiteRunner(io: std.Io, alloc: std.mem.Allocator) !void {
     try common.ensureDir(io, BIN_DIR);
     const root_mod = "-Mroot=tools/suite_runner.zig";
     const html_mod = "-Mhtmlparser=src/root.zig";
-    const config_mod = "-Mconfig=src/config.zig";
-    const build_config_mod = "-Mbuild_config=src/build_config.zig";
+    const config_path = try tempConfigModule(io, alloc);
+    defer {
+        std.Io.Dir.deleteFileAbsolute(io, config_path) catch {};
+        alloc.free(config_path);
+    }
+    const config_mod = try std.fmt.allocPrint(alloc, "-Mconfig={s}", .{config_path});
+    defer alloc.free(config_mod);
     const argv = [_][]const u8{
         "zig",
         "build-exe",
@@ -1653,17 +1658,38 @@ fn buildSuiteRunner(io: std.Io, alloc: std.mem.Allocator) !void {
         "--dep",
         "config",
         html_mod,
-        "--dep",
-        "build_config",
         config_mod,
-        build_config_mod,
         "-O",
         "ReleaseFast",
         "-femit-bin=" ++ SUITE_RUNNER_BIN,
     };
     try common.runInherit(io, alloc, &argv, REPO_ROOT);
 }
 
+fn tempConfigModule(io: std.Io, alloc: std.mem.Allocator) ![]u8 {
+    var src: std.Random.IoSource = .{ .io = io };
+    const path = try std.fmt.allocPrint(alloc, "/tmp/htmlparser-config-{x}.zig", .{src.interface().int(u64)});
+    errdefer alloc.free(path);
+
+    const file = try std.Io.Dir.createFileAbsolute(io, path, .{
+        .truncate = true,
+        .exclusive = true,
+    });
+    defer file.close(io);
+    try file.writeStreamingAll(io,
+        \\pub const IntLen = enum {
+        \\    u16,
+        \\    u32,
+        \\    u64,
+        \\    usize,
+        \\};
+        \\
+        \\pub const intlen: IntLen = .u32;
+        \\
+    );
+    return path;
+}
+
 fn runSelectorCount(io: std.Io, alloc: std.mem.Allocator, mode: []const u8, fixture: []const u8, selector: []const u8) !usize {
     const argv = [_][]const u8{ SUITE_RUNNER_BIN, "selector-count", mode, fixture, selector };
     const out = try common.runCaptureStdout(io, alloc, &argv, REPO_ROOT);
@@ -2728,13 +2754,19 @@ fn runExamplesCheck(io: std.Io, alloc: std.mem.Allocator) !void {
     }
     if (example_files.len == 0) return error.NoExamplesFound;
 
+    const config_path = try tempConfigModule(io, alloc);
+    defer {
+        std.Io.Dir.deleteFileAbsolute(io, config_path) catch {};
+        alloc.free(config_path);
+    }
+    const config_mod = try std.fmt.allocPrint(alloc, "-Mconfig={s}", .{config_path});
+    defer alloc.free(config_mod);
+
     for (example_files) |example_path| {
         std.debug.print("examples-check: zig test {s}\n", .{example_path});
         const root_mod = try std.fmt.allocPrint(alloc, "-Mroot={s}", .{example_path});
         defer alloc.free(root_mod);
         const html_mod = "-Mhtmlparser=src/root.zig";
-        const config_mod = "-Mconfig=src/config.zig";
-        const build_config_mod = "-Mbuild_config=src/build_config.zig";
         const argv = [_][]const u8{
             "zig",
             "test",
@@ -2744,10 +2776,7 @@ fn runExamplesCheck(io: std.Io, alloc: std.mem.Allocator) !void {
             "--dep",
             "config",
             html_mod,
-            "--dep",
-            "build_config",
             config_mod,
-            build_config_mod,
         };
         try common.runInherit(io, alloc, &argv, REPO_ROOT);
     }