1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29
30. 30
31. 31
32. 32
33. 33
34. 34
35. 35
36. 36
37. 37
38. 38
39. 39
40. 40
41. 41
42. 42
43. 43
44. 44
45. 45
46. 46
47. 47
48. 48
49. 49
50. 50
51. 51
52. 52
53. 53
54. 54
55. 55
56. 56
57. 57
58. 58
59. 59
60. 60
61. 61
62. 62
63. 63
64. 64
65. 65
66. 66
67. 67
68. 68
69. 69
70. 70
71. 71
72. 72
73. 73
74. 74
75. 75
76. 76
77. 77
78. 78
79. 79
80. 80
81. 81
82. 82
83. 83
84. 84
85. 85
86. 86
87. 87
88. 88
89. 89
90. 90
91. 91
92. 92
93. 93
94. 94
95. 95
96. 96
97. 97
98. 98
99. 99
100. 100
101. 101
102. 102
103. 103
104. 104
105. 105
106. 106

// Copyright 2025 Shota FUJI
//
// Licensed under the Zero-Clause BSD License or the Apache License, Version 2.0, at your option.
// You may not use, copy, modify, or distribute this file except according to those terms. You can
// find a copy of the Zero-Clause BSD License at LICENSES/0BSD.txt, and a copy of the Apache License,
// Version 2.0 at LICENSES/Apache-2.0.txt. You may also obtain a copy of the Apache License, Version
// 2.0 at <https://www.apache.org/licenses/LICENSE-2.0>
//
// SPDX-License-Identifier: 0BSD OR Apache-2.0
//
// ===
//
// This file defines how the steps and options for `zig build` command. See official documentation
// <https://ziglang.org/learn/build-system/> for more info.

const std = @import("std");

pub fn build(b: *std.Build) !void {
    const target = b.standardTargetOptions(.{});
    const optimize = b.standardOptimizeOption(.{});
    const linkage = b.option(std.builtin.LinkMode, "linkage", "Link mode of the generated library file") orelse .static;

    // Exports Zig API, so other project depends on this library.
    const module = b.addModule("sood", .{ .root_source_file = b.path("src/lib.zig") });

    // Library build (C API).
    const lib = b.addLibrary(.{
        .linkage = linkage,
        .name = "sood",
        .root_module = b.createModule(.{
            .root_source_file = b.path("src/c.zig"),
            .target = target,
            .optimize = optimize,
        }),
    });
    lib.installHeader(b.path("src/c.h"), "sood.h");
    b.installArtifact(lib);
    b.default_step.dependOn(&lib.step);

    // Man page
    const man_dir_path = try b.build_root.join(b.allocator, &.{"man"});
    var man_dir = try std.fs.cwd().openDir(man_dir_path, .{ .iterate = true });
    defer man_dir.close();

    var it = man_dir.iterate();
    while (try it.next()) |entry| {
        if (entry.kind != .file) {
            continue;
        }

        const section = entry.name[entry.name.len - 1];

        b.installFile(
            b.fmt("man/{s}", .{entry.name}),
            b.fmt("share/man/man{u}/{s}", .{ section, entry.name }),
        );
    }

    // Install WASM build.
    const wasm_step = b.step("wasm", "Build WebAssembly module");
    const wasm = b.addExecutable(.{
        .name = "sood",
        .root_source_file = b.path("src/wasm.zig"),
        .target = b.resolveTargetQuery(.{ .os_tag = .freestanding, .cpu_arch = .wasm32 }),
        .optimize = optimize,
    });
    // These two options are somehow needed.
    // <https://ziggit.dev/t/build-wasm-using-zig-build-system-when-ther-is-no-entry-point-but-function-to-export/4364/3>
    wasm.rdynamic = true;
    wasm.entry = .disabled;
    wasm_step.dependOn(&b.addInstallArtifact(wasm, .{}).step);

    // Example (Zig)
    const example_zig_step = b.step("example-zig", "Build Zig example");
    const example_zig = b.addExecutable(.{
        .name = "example_zig",
        .root_source_file = b.path("examples/basic.zig"),
        .target = target,
        .optimize = optimize,
    });
    example_zig.root_module.addImport("sood", module);
    example_zig_step.dependOn(&b.addInstallArtifact(example_zig, .{}).step);

    // Example (C)
    const example_c_step = b.step("example-c", "Build C example");
    const example_c = b.addExecutable(.{
        .name = "example_c",
        .target = target,
        .optimize = optimize,
    });
    example_c.addCSourceFile(.{ .file = b.path("examples/basic.c") });
    example_c.linkLibC();
    example_c.linkLibrary(lib);
    example_c.addIncludePath(.{ .cwd_relative = b.h_dir });
    example_c_step.dependOn(&b.addInstallArtifact(example_c, .{}).step);

    // Unit tests.
    const test_step = b.step("test", "Run unit tests");
    const unit_tests = b.addTest(.{
        .name = "sood_test",
        .root_source_file = b.path("src/lib.zig"),
        .target = target,
        .optimize = optimize,
    });
    test_step.dependOn(&b.addRunArtifact(unit_tests).step);
}