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
107. 107
108. 108
109. 109
110. 110
111. 111
112. 112
113. 113
114. 114
115. 115
116. 116
117. 117
118. 118

// Copyright 2025 Shota FUJI
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0

//! This file defines how `zig build` command behaves.
//! Run `zig build --help` for available subcommands and options.
//!
//! Learn more at
//! https://ziglang.org/learn/build-system/

const std = @import("std");

const BuildError = error{
    NonValaSourceInSourceListError,
};

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

    // Vala source codes to compile. As Vala does not have module system,
    // we have to list every source code files to include.
    const vala_sources = [_][]const u8{
        "src/Application.vala",
    };

    // System libraries to link.
    // Each library must be provided by packages listed in `plugin.json` (devbox package),
    // so anyone can build without manually installing system libraries.
    const system_libraries = [_][]const u8{
        "gtk4",
    };

    // A directory containing C source files compiled from Vala source code.
    // If you use this LazyPath in your artifact, the artifact automatically depends on
    // this Vala to C complication step. You don't have to manually `a.dependOn()`.
    const vala_cdir = vala: {
        const valac = b.addSystemCommand(&.{"valac"});

        // Tell Vala compiler to emit C rather than compile using system C compiler.
        valac.addArg("--ccode");

        // Tell Vala what system libraries to use. Perhaps type checking things?
        for (system_libraries) |lib| {
            valac.addArgs(&.{ "--pkg", lib });
        }

        // Tell Vala to emit C source files under the output directory.
        // The directory usually is Zig cache directory (like ".zig-cache/o/xxx").
        // For example, when there is "src/Foo.vala", this step produces
        // ".zig-cache/o/hash-or-something-idk/vala/src/Foo.c"
        valac.addArg("--directory");
        const dir = valac.addOutputDirectoryArg("vala");

        // Vala compiler takes a list of Vala source files, then process them all.
        for (vala_sources) |src| {
            valac.addFileArg(b.path(src));
        }

        break :vala dir;
    };

    // An executable.
    const exe = exe: {
        const exe = b.addExecutable(.{
            .name = "plac",
            .target = target,
            .optimize = optimize,
        });

        // This is a standard C application, so libc is required.
        exe.linkLibC();

        // Vala does not bundle system libraries (of course): we have to tell the
        // linker.
        for (system_libraries) |lib| {
            exe.linkSystemLibrary(lib);
        }

        // At this point, build does not run yet—we can't enumerate C source
        // directory. Since we already have a list of Vala source code, we can
        // build a list of paths of to-be-generated C source file.
        for (vala_sources) |src| {
            // Basically unreachable. Don't put non Vala source into `vala_sources`.
            if (!std.mem.endsWith(u8, src, ".vala")) {
                return BuildError.NonValaSourceInSourceListError;
            }

            // Looks fragile but it works. Even if it produced incorrect paths,
            // filesystem and Zig compiler will tell us a file is missing.
            const rel_path = b.fmt("{s}.c", .{src[0..(src.len - 5)]});

            // src = "src/Foo.vala"
            // rel_path = "src/Foo.c"
            // file = "(step cache directory)/vala/src/Foo.c"
            exe.addCSourceFile(.{
                .file = try vala_cdir.join(b.allocator, rel_path),
            });
        }

        break :exe exe;
    };

    // Install a main executable file on "zig build" without subcommand.
    b.installArtifact(exe);
}