browser/build.zig

const std = @import("std");

const jsruntime_path = "vendor/jsruntime-lib/";
const jsruntime = @import("vendor/jsruntime-lib/build.zig");
const jsruntime_pkgs = jsruntime.packages(jsruntime_path);

pub fn build(b: *std.build.Builder) !void {
    const target = b.standardTargetOptions(.{});
    const mode = b.standardOptimizeOption(.{});

    const options = try jsruntime.buildOptions(b);

    // browser
    // -------

    // compile and install
    const exe = b.addExecutable(.{
        .name = "browsercore",
        .root_source_file = .{ .path = "src/main.zig" },
        .target = target,
        .optimize = mode,
    });
    try common(exe, options);
    b.installArtifact(exe);

    // run
    const run_cmd = b.addRunArtifact(exe);
    run_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_cmd.addArgs(args);
    }

    // step
    const run_step = b.step("run", "Run the app");
    run_step.dependOn(&run_cmd.step);

    // shell
    // -----

    // compile and install
    const shell = b.addExecutable(.{
        .name = "browsercore-shell",
        .root_source_file = .{ .path = "src/main_shell.zig" },
        .target = target,
        .optimize = mode,
    });
    try common(shell, options);
    try jsruntime_pkgs.add_shell(shell);
    // do not install shell binary
    b.installArtifact(shell);

    // run
    const shell_cmd = b.addRunArtifact(shell);
    shell_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        shell_cmd.addArgs(args);
    }

    // step
    const shell_step = b.step("shell", "Run JS shell");
    shell_step.dependOn(&shell_cmd.step);

    // test
    // ----

    // compile
    const exe_tests = b.addTest(.{ .root_source_file = .{ .path = "src/run_tests.zig" } });
    try common(exe_tests, options);

    // step
    const test_step = b.step("test", "Run unit tests");
    test_step.dependOn(&exe_tests.step);
}

fn common(
    step: *std.Build.CompileStep,
    options: jsruntime.Options,
) !void {
    try jsruntime_pkgs.add(step, options);
    linkLexbor(step);
    linkNetSurf(step);
}

fn linkLexbor(step: *std.build.LibExeObjStep) void {
    // cmake . -DLEXBOR_BUILD_SHARED=OFF
    const lib_path = "vendor/lexbor/liblexbor_static.a";
    step.addObjectFile(.{ .path = lib_path });
    step.addIncludePath(.{ .path = "vendor/lexbor-src/source" });
}

fn linkNetSurf(step: *std.build.LibExeObjStep) void {

    // iconv
    var iconv_lib: []const u8 = undefined;
    var iconv_include: []const u8 = undefined;
    const os = step.target.getOsTag();
    if (os == .macos) {
        iconv_lib = "/opt/homebrew/opt/libiconv/lib/libiconv.a";
        iconv_include = "/opt/homebrew/opt/libiconv/include";
    } else if (os == .linux) {
        @panic("you need to modify build.zig to specify libiconv paths");
    }
    step.addObjectFile(iconv_lib);
    step.addIncludePath(iconv_include);

    // netsurf libs
    const ns = "vendor/netsurf/";
    const libs: [4][]const u8 = .{
        "libdom",
        "libhubbub",
        "libparserutils",
        "libwapcaplet",
    };
    inline for (libs) |lib| {
        step.addObjectFile(ns ++ "/build/" ++ lib ++ "/" ++ lib ++ ".a");
        step.addIncludePath(ns ++ lib ++ "/include");
    }
}