summaryrefslogtreecommitdiff
path: root/build.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-10-30 17:35:06 -0300
committerGabriel Schneider <[email protected]>2026-10-30 17:35:06 -0300
commit6d8da8721141284cf33bb901168b26135893eb86 (patch)
tree791d63401d4e85fbca1d597a8ce0326e70efd545 /build.zig
parentefd43a3a2cf03bb741366331158b368abf9ac583 (diff)
parentbf6810a8f9d6cc82050e7d9c0cfb06358301b574 (diff)
downloadpardes-6d8da8721141284cf33bb901168b26135893eb86.tar.gz
pardes-6d8da8721141284cf33bb901168b26135893eb86.zip
Merge latest upstream into the macOS branch for Zig 0.17
Retain the macOS branch history and local Acme selection color while adopting upstream's current core and platform changes. Pin Zig and ZLS to 0.17.0, and fetch the existing zstbi compatibility commit through upstream after its original fork was removed.
Diffstat (limited to 'build.zig')
-rw-r--r--build.zig1066
1 files changed, 849 insertions, 217 deletions
diff --git a/build.zig b/build.zig
index 0cd7f312..034d7284 100644
--- a/build.zig
+++ b/build.zig
@@ -6,6 +6,12 @@ const grammar_manifest = @import("src/grammar_manifest.zig");
/// The package manifest, imported UNTYPED on purpose — see the `version`
/// option in `shellOptions` for why that word is load-bearing.
const zon = @import("build.zig.zon");
+/// Releases are numbered 0.N; the zon holds "0.N.0" because it must be semver,
+/// and what a user sees drops that ".0".
+const display_version = if (std.mem.endsWith(u8, zon.version, ".0") and std.mem.count(u8, zon.version, ".") == 2)
+ zon.version[0 .. zon.version.len - 2]
+else
+ zon.version;
pub const Platform = enum { tty, gui, web, macos, esp32p4 };
@@ -30,38 +36,40 @@ const PerfBuild = struct {
pub const macos_min_version: std.SemanticVersion = .{ .major = 13, .minor = 0, .patch = 0 };
-const zls_version = "0.16.1-dev+3e0d0820";
-
-comptime {
- const plus = std.mem.indexOfScalar(u8, zls_version, '+') orelse
- @compileError("zls_version must end in +<short commit>");
- const short = zls_version[plus + 1 ..];
- const url = zon.dependencies.zls.url;
- const hash = std.mem.indexOfScalar(u8, url, '#') orelse
- @compileError("the zls dependency url must pin a commit with #<sha>");
- if (!std.mem.startsWith(u8, url[hash + 1 ..], short)) @compileError(
- "zls_version pins commit " ++ short ++ ", build.zig.zon pins " ++ url[hash + 1 ..],
- );
-}
pub const TreeSitterGrammars = enum { disabled, zig, minimal, full };
const gui_shaders = [_][]const u8{
- "ui.vert", "ui.frag",
- "overlay.vert", "overlay.frag",
- "image.vert", "image.frag",
- "crt.vert", "crt.frag",
+ "ui.vert",
+ "ui.frag",
+ "decor.frag",
+ "overlay.vert",
+ "overlay.frag",
+ "image.vert",
+ "image.frag",
+ "post.vert",
+ // The bundled post passes: shaders/post/<name>.glsl behind the
+ // Shadertoy prefix (shaderSource).
+ "post-crt.frag",
+ "post-bloom.frag",
+ "post-vignette.frag",
+ "post-grain.frag",
+ // Bloom's steps below the frame (src/gui/Post.zig bloomChain).
+ "bloom-down.frag",
+ "bloom-up.frag",
};
pub fn build(b: *std.Build) void {
const requested_platform = b.option(Platform, "platform", "which shell to build (tty, gui, web, macos, esp32p4); absent builds the tty cli and the SDL gui together");
const platform = requested_platform orelse .tty;
const also_gui = requested_platform == null;
- if (also_gui and prefixIsUntouched(b)) {
- if (b.graph.environ_map.get("HOME")) |home| {
- b.resolveInstallPrefix(b.pathJoin(&.{ home, ".local" }), .{});
- std.debug.print("pardes: installing into {s} (override with --prefix)\n", .{b.install_prefix});
- }
- }
+ // A bare `zig build` also copies the binaries into ~/.local/bin. Zig
+ // 0.17 keeps the prefix in the maker process, out of this script's
+ // reach, so `--prefix` no longer turns it off: -Dhome-install=false does.
+ const home_bin: ?[]const u8 = if (also_gui and (b.option(bool, "home-install", "a bare `zig build` also copies the binaries into ~/.local/bin (default: true)") orelse true))
+ if (b.graph.environ_map.get("HOME")) |home| b.pathJoin(&.{ home, ".local", "bin" }) else null
+ else
+ null;
+ const home_install = home_bin != null;
const esp32p4_target: std.Target.Query = .{
.cpu_arch = .riscv32,
.os_tag = .freestanding,
@@ -104,16 +112,54 @@ pub fn build(b: *std.Build) void {
ninep_options.addOption(bool, "quic", enable_quic);
const enable_mupdf = b.option(bool, "mupdf", "native PDF rendering with MuPDF (AGPL/commercial; native default on, web/esp32p4 off; -Dmupdf=false disables)") orelse !freestanding_core;
const enable_jpx = b.option(bool, "jpx", "JPEG 2000 in PDFs, for scanned documents (default on; -Djpx=false drops openjpeg)") orelse true;
- const embed_sources = b.option(bool, "embed-sources", "serve the editor's own sources under /src of its 9P tree (default off; on for -Dplatform=esp32p4, whose only source is the device)") orelse is_esp32p4;
+ // Off on the board too: the sources are ~1.8 MB, more than the whole
+ // 1.5 MiB app partition, and with them the image does not link.
+ const embed_sources = b.option(bool, "embed-sources", "serve the editor's own sources under /src of its 9P tree (default off; the esp32p4 image has no room for them)") orelse false;
const is_web_target = target.result.cpu.arch == .wasm32 and target.result.os.tag == .freestanding;
const is_esp32p4_target = target.result.cpu.arch == .riscv32 and target.result.os.tag == .freestanding;
const optimize = if (is_web)
- .ReleaseSmall
- else if (is_esp32p4_target and requested_optimize == .Debug)
- .ReleaseFast
+ .small
+ else if (is_esp32p4_target and requested_optimize == .debug)
+ .fast
else
requested_optimize;
const test_build = b.step("test-build", "compile unit-test programs without running them");
+ const doc_typ_opts = b.addOptions();
+ doc_typ_opts.addOptionPathUntracked("dir", b.path("docs/typ"));
+ // The docs (docs/typ, docs/site): each output is one typst run, and each
+ // reads docs/typ/builtins-*.json; `builtins-json` refreshes this build's from the
+ // registry first (the tool is wired below, once the core module is).
+ const typst_bin: ?[]const u8 = b.findProgram(.{ .names = &.{"typst"} });
+ var doc_renders: [3]?*std.Build.Step.Run = @splat(null);
+ const cheatsheet_step = b.step("cheatsheet", "render docs/typ/cheatsheet-a4.typ to <prefix>/share/doc/pardes/cheatsheet.pdf (needs typst)");
+ const book_step = b.step("book", "render docs/typ/book.typ to <prefix>/share/doc/pardes/pardes.pdf (needs typst)");
+ // The website: one Typst bundle run writes every page, the stylesheet,
+ // the fonts and the media (docs/site/site.typ).
+ const site_step = b.step("site", "render the docs website to <prefix>/share/doc/pardes/site (needs typst)");
+ if (typst_bin) |typst| {
+ // They read all of docs/typ, docs/site and the tutor, so they always
+ // run rather than track every file.
+ const sheet = b.addSystemCommand(&.{ typst, "compile", "--ignore-system-fonts" });
+ sheet.addFileArg(b.path("docs/typ/cheatsheet-a4.typ"));
+ sheet.has_side_effects = true;
+ cheatsheet_step.dependOn(&b.addInstallFile(sheet.addOutputFileArg("cheatsheet.pdf"), "share/doc/pardes/cheatsheet.pdf").step);
+ const book = b.addSystemCommand(&.{ typst, "compile", "--ignore-system-fonts", "--root", "." });
+ book.setCwd(b.path("."));
+ book.addFileArg(b.path("docs/typ/book.typ"));
+ book.has_side_effects = true;
+ book_step.dependOn(&b.addInstallFile(book.addOutputFileArg("pardes.pdf"), "share/doc/pardes/pardes.pdf").step);
+ const site = b.addSystemCommand(&.{ typst, "compile", "--format", "bundle", "--features", "bundle,html", "--root", "." });
+ site.setCwd(b.path("."));
+ site.addFileArg(b.path("docs/site/site.typ"));
+ const site_dir = site.addOutputDirectoryArg("site");
+ site.has_side_effects = true;
+ site_step.dependOn(&b.addInstallDirectory(.{ .source_dir = site_dir, .install_dir = .prefix, .install_subdir = "share/doc/pardes/site" }).step);
+ doc_renders = .{ sheet, book, site };
+ } else {
+ cheatsheet_step.dependOn(&b.addFail("zig build cheatsheet needs typst on PATH").step);
+ book_step.dependOn(&b.addFail("zig build book needs typst on PATH").step);
+ site_step.dependOn(&b.addFail("zig build site needs typst on PATH").step);
+ }
const test_nonce: ?*std.Build.Module = if (b.option(bool, "test-rebuild", "force fresh Zig test compilation while retaining cached C dependencies") orelse false) blk: {
const files = b.addTempFiles();
const source = files.add("test_nonce.zig", b.fmt("pub const nonce = {d};\n", .{std.Io.Clock.awake.now(b.graph.io).nanoseconds}));
@@ -128,7 +174,7 @@ pub fn build(b: *std.Build) void {
.root_source_file = b.path("test/unit_profile.zig"),
}),
});
- const c_optimize: std.builtin.OptimizeMode = if (optimize == .Debug) .ReleaseFast else optimize;
+ const c_optimize: std.lang.Optimize = if (optimize == .debug) .fast else optimize;
const default_grammars: TreeSitterGrammars = if (is_web) .zig else if (is_esp32p4) .disabled else .full;
const requested_grammars = b.option(TreeSitterGrammars, "tree-sitter", "tree-sitter grammar set: disabled, zig, minimal (c/c++/zig), full");
const tree_sitter_grammars = requested_grammars orelse default_grammars;
@@ -142,6 +188,7 @@ pub fn build(b: *std.Build) void {
const mupdf_check = b.step("mupdf-check", "compile, link, render, and search docs/design.pdf with MuPDF");
const pdf_bench_step = b.step("pdf-bench", "benchmark real MuPDF page rendering (-- [--json] [--reps N] [--warmup N] [--path FILE] [--page N] [--pages N])");
const pdf_sections_bench_step = b.step("pdf-sections-bench", "benchmark PDF outline/sections paths in ReleaseFast (-Doptimize=ReleaseFast -- [--json] [--reps N] [--warmup N])");
+ const pdf_pointer_bench_step = b.step("pdf-pointer-bench", "time PDF hover and selection gestures and prove their pixels (-Doptimize=ReleaseFast -- [--label L] [--reps N] [--path FILE] [--cell WxH])");
const pdf_scroll_bench_step = b.step("pdf-scroll-bench", "benchmark fast continuous-strip PDF scrolling in ReleaseFast (-Doptimize=ReleaseFast -- [--json] [--reps N] [--warmup N] [--path FILE])");
if (!enable_mupdf)
mupdf_check.dependOn(&b.addFail("mupdf-check is unavailable with -Dmupdf=false").step);
@@ -151,15 +198,13 @@ pub fn build(b: *std.Build) void {
pdf_sections_bench_step.dependOn(&b.addFail("pdf-sections-bench is unavailable with -Dmupdf=false").step);
if (!enable_mupdf)
pdf_scroll_bench_step.dependOn(&b.addFail("pdf-scroll-bench is unavailable with -Dmupdf=false").step);
+ if (!enable_mupdf)
+ pdf_pointer_bench_step.dependOn(&b.addFail("pdf-pointer-bench is unavailable with -Dmupdf=false").step);
- const shaders_step = b.step("shaders", "refresh paired shaders/prebuilt/*.spv + *.glsl snapshots (glslc)");
+ const shaders_step = b.step("shaders", "refresh the committed shaders/prebuilt/*.spv (glslc)");
const update_shaders = b.addUpdateSourceFiles();
for (gui_shaders) |name| {
update_shaders.addCopyFileToSource(compileGlsl(b, name), b.fmt("shaders/prebuilt/{s}.spv", .{name}));
- update_shaders.addCopyFileToSource(
- b.path(b.fmt("shaders/{s}.glsl", .{name})),
- b.fmt("shaders/prebuilt/{s}.glsl", .{name}),
- );
}
shaders_step.dependOn(&update_shaders.step);
@@ -169,7 +214,11 @@ pub fn build(b: *std.Build) void {
if (!is_web and (is_web_target or target.result.os.tag == .emscripten)) return failBuild(b, web_step, "wasm browser targets require -Dplatform=web");
if (platform == .web and dump_path == null) return failBuild(b, web_step, "-Dplatform=web requires -Ddump=<dump.zon> (the browser has no ptys; state replays from an embedded dump)");
if (enable_mupdf and is_web) return failBuild(b, web_step, "-Dmupdf=true is supported only by the native tty/Kitty and gui/SDL backends");
- if (is_esp32p4 and !is_esp32p4_target) return failBuild(b, web_step, "-Dplatform=esp32p4 requires -Dtarget=riscv32-freestanding (ESP32-P4 firmware)");
+ // The board's target is pinned (`target` above), so what is asked of
+ // -Dtarget is checked, not what was resolved: another arch is refused,
+ // not silently built for the board anyway.
+ const requested_board = requested_target.result.cpu.arch == .riscv32 and requested_target.result.os.tag == .freestanding;
+ if (is_esp32p4 and !requested_board) return failBuild(b, web_step, "-Dplatform=esp32p4 requires -Dtarget=riscv32-freestanding (ESP32-P4 firmware)");
if (enable_mupdf and is_esp32p4) return failBuild(b, web_step, "-Dmupdf=true is supported only by the native tty/Kitty and gui/SDL backends");
if (is_esp32p4 and requested_grammars != null and requested_grammars.? != .disabled) return failBuild(b, web_step, "-Dplatform=esp32p4 has no tree-sitter: the grammars' parse tables are megabytes and the flash partition is 1.5 MiB (-Dtree-sitter=disabled)");
@@ -268,7 +317,6 @@ pub fn build(b: *std.Build) void {
// The conditional dependencies, hoisted so one `wireCore` call at the end
// can name them all. The unconditional ones are ordinary consts below.
- var zls_mod: ?*std.Build.Module = null;
var ts_mod: ?*std.Build.Module = null;
var ts_queries_opts: ?*std.Build.Step.Options = null;
var mupdf_core_mod: ?*std.Build.Module = null;
@@ -279,7 +327,7 @@ pub fn build(b: *std.Build) void {
.name = "pardes-gen-themes",
.root_module = b.createModule(.{
.target = b.graph.host,
- .optimize = .Debug,
+ .optimize = .debug,
.root_source_file = b.path("tools/gen_themes.zig"),
}),
});
@@ -296,18 +344,25 @@ pub fn build(b: *std.Build) void {
if (target.result.os.tag == .freebsd or target.result.os.tag == .netbsd or target.result.os.tag == .openbsd)
root_mod.linkSystemLibrary("util", .{});
- const zls_backend = !freestanding_core;
-
const esp32p4_cols = b.option(u16, "esp32p4-cols", "the board's grid width in cells (-Dplatform=esp32p4 only)") orelse 56;
const esp32p4_rows = b.option(u16, "esp32p4-rows", "the board's grid height in cells (-Dplatform=esp32p4 only)") orelse 14;
const theme_animation = b.option(bool, "theme-animation", "animate chrome colors across a theme change (default: off for esp32p4)");
// The macOS shell carries the workspace tag row's commands in its native
// menu bar; the row itself goes away. `-Dworkspace-tag=true` puts it back.
const workspace_tag = b.option(bool, "workspace-tag", "draw the workspace tag row (default: on except on macOS, whose menu bar carries its commands)");
+ // The commit is a build input: every `jj new` or `jj commit` moves HEAD,
+ // changes the options module and so recompiles every binary that imports
+ // it, which is all of them (~0.6 GB of fresh test objects per move). Only
+ // builds someone keeps are stamped: release builds and the bare
+ // `zig build` that installs into ~/.local. Every other Debug build (any
+ // -Dplatform or --prefix, so every test and snapshot run) prints
+ // `pardes <version>` alone, like a tarball build; -Dstamp-commit=true
+ // stamps one anyway.
+ const stamp_commit = b.option(bool, "stamp-commit", "embed the git commit in --version and crash records (default: release builds and the ~/.local install)") orelse
+ (optimize != .debug or home_install);
const shell_cfg: ShellConfig = .{
.tree_sitter_grammars = tree_sitter_grammars,
.tracy = tracy != null,
- .zls_backend = zls_backend,
.mupdf = enable_mupdf,
.esp32p4_cols = esp32p4_cols,
.esp32p4_rows = esp32p4_rows,
@@ -315,21 +370,11 @@ pub fn build(b: *std.Build) void {
.workspace_tag = workspace_tag,
.prebuilt_shaders = prebuilt_shaders,
.embed_sources = embed_sources,
- .zig_lib_dir = b.graph.zig_lib_directory.path orelse "",
- .commit = gitCommit(b),
+ .commit = if (stamp_commit) gitCommit(b) else null,
};
const opts = shellOptions(b, shell_cfg, platform);
const gui_opts: ?*std.Build.Step.Options = if (also_gui) shellOptions(b, shell_cfg, .gui) else null;
- if (zls_backend) {
- const zls_dep = b.dependency("zls", .{
- .target = target,
- .optimize = optimize,
- .@"version-string" = @as([]const u8, zls_version),
- });
- zls_mod = zls_dep.module("zls");
- }
-
if (tracy) |tracy_path| {
for ([_]*std.Build.Module{ root_mod, core_module }) |mod| {
mod.addIncludePath(.{ .cwd_relative = tracy_path });
@@ -352,9 +397,7 @@ pub fn build(b: *std.Build) void {
if (tree_sitter_grammars != .disabled) {
const tree_sitter_mod = b.dependency("tree_sitter", .{ .target = target, .optimize = c_optimize }).module("tree_sitter");
if (is_web) {
- const web_libc_include: std.Build.LazyPath = .{
- .cwd_relative = b.path("src/web/libc/include").getPath(b),
- };
+ const web_libc_include = b.path("src/web/libc/include");
for (tree_sitter_mod.link_objects.items) |link_object| switch (link_object) {
.other_step => |lib| {
lib.root_module.link_libc = false;
@@ -378,16 +421,30 @@ pub fn build(b: *std.Build) void {
(tree_sitter_grammars == .zig and g.tier == .zig))
{
const dep = b.dependency(g.dep, .{});
- const query_path = dep.path(g.query);
- const query = std.Io.Dir.cwd().readFileAlloc(io, query_path.getPath(b), b.allocator, .limited(0x100000)) catch @panic("read " ++ g.name ++ " highlights");
+ const query = configureRead(b, io, dep.builder.root, g.query, 0x100000) catch @panic("read " ++ g.name ++ " highlights");
ts_queries.addOption([]const u8, g.name ++ "_highlights", query);
+ // helix's textobject queries, vendored (vendor/queries); a
+ // grammar without one gets none
+ const objects = configureRead(b, io, b.root, "vendor/queries/" ++ g.name ++ "/textobjects.scm", 0x100000) catch "";
+ ts_queries.addOption([]const u8, g.name ++ "_textobjects", objects);
const lib = b.addLibrary(.{
.name = "tree-sitter-" ++ g.name,
.root_module = b.createModule(.{ .target = target, .optimize = c_optimize, .link_libc = !is_web }),
.linkage = .static,
});
- const ts_cflags = [_][]const u8{"-fno-sanitize=function"};
+ // Every allocation a grammar's external scanner makes goes to the
+ // runtime's allocator, which syntax.zig points at a Zig one:
+ // TREE_SITTER_REUSE_ALLOCATOR for the scanners that use
+ // ts_malloc, and src/tree_sitter_heap.h for the ones that call
+ // malloc themselves.
+ const ts_cflags = [_][]const u8{
+ "-fno-sanitize=function",
+ "-DTREE_SITTER_REUSE_ALLOCATOR",
+ // Relative to the build root, the compiler's working directory.
+ "-include",
+ "src/tree_sitter_heap.h",
+ };
lib.root_module.addCSourceFile(.{ .file = dep.path(g.src ++ "/parser.c"), .flags = &ts_cflags });
if (g.scanner) lib.root_module.addCSourceFile(.{ .file = dep.path(g.src ++ "/scanner.c"), .flags = &ts_cflags });
lib.root_module.addIncludePath(dep.path(g.src));
@@ -405,7 +462,122 @@ pub fn build(b: *std.Build) void {
.root_source_file = b.path("src/web/zstbi.zig"),
});
- const mvzr_mod = b.dependency("mvzr", .{ .target = target, .optimize = optimize }).module("mvzr");
+ // mvzr backtracks with no bound on its work (its own test "do not make
+ // this test any longer": `a?` n times is 2^n steps), and pardes searches
+ // with it holding the editor. Its matcher gets a step budget, patched into
+ // the fetched source here at build time so that a fresh fetch keeps it:
+ // each entry to matchPattern, which its backtracking recurses through,
+ // spends a step, and with none left the match fails and says so
+ // (src/regexp.zig). A bump that moves the anchor stops the build.
+ const mvzr_mod = mvzr: {
+ const dep = b.dependency("mvzr", .{ .target = target, .optimize = optimize });
+ const src = configureRead(b, io, dep.builder.root, "src/mvzr.zig", 1 << 20) catch @panic("read mvzr");
+ const anchor = "fn matchPattern(patt: []const RegOp, sets: []const CharSet, haystack: []const u8, i_in: usize) ?OpMatch {\n";
+ const at = (std.mem.indexOf(u8, src, anchor) orelse @panic("mvzr's matchPattern changed: redo its step budget in build.zig")) + anchor.len;
+ const spend =
+ \\ if (steps_left == 0) {
+ \\ exhausted = true;
+ \\ return null;
+ \\ }
+ \\ steps_left -= 1;
+ \\
+ ;
+ const budget =
+ \\
+ \\/// pardes's patch (its build.zig): matchPattern entries left before a
+ \\/// match gives up, and whether one did. Set by the caller per search.
+ \\pub threadlocal var steps_left: u64 = std.math.maxInt(u64);
+ \\pub threadlocal var exhausted: bool = false;
+ \\
+ ;
+ const budgeted = b.fmt("{s}{s}{s}{s}", .{ src[0..at], spend, src[at..], budget });
+ // A group's greedy match never gave back to what follows the group:
+ // on `aab`, `(a+)ab` missed where `a+ab` matched. hasAlt counts the
+ // group's own `)` as an alternative, so every group with pattern
+ // after it takes matchGroup's alternatives branch, which tries each
+ // alternative's one (greedy) match and gives up. When the rest fails
+ // after it, try that alternative's shorter matches, longest first
+ // (docs/mvzr-group-backtrack.md is the report for upstream).
+ const group_anchor =
+ \\ const next_match = matchPattern(next_patt, sets, haystack, m1.i);
+ \\ if (next_match) |m2| {
+ \\ // Whole group matches, and we can use m2.j
+ \\ return m2;
+ \\ } else { // Try our next pattern, if any.
+ \\
+ ;
+ const group_backoff =
+ \\ const next_match = matchPattern(next_patt, sets, haystack, m1.i);
+ \\ if (next_match) |m2| {
+ \\ // Whole group matches, and we can use m2.j
+ \\ return m2;
+ \\ } else { // Try our next pattern, if any.
+ \\ // pardes's patch (its build.zig): back the group off.
+ \\ var e = m1.i;
+ \\ while (e > i) {
+ \\ e -= 1;
+ \\ const shorter = matchAlt(remaining_patt, sets, haystack[0..e], i) orelse continue;
+ \\ if (shorter.i != e) continue;
+ \\ if (matchPattern(next_patt, sets, haystack, e)) |whole| return whole;
+ \\ }
+ \\
+ ;
+ if (std.mem.count(u8, budgeted, group_anchor) != 1) @panic("mvzr's matchGroup changed: redo its group backtracking in build.zig");
+ const backed = std.mem.replaceOwned(u8, b.allocator, budgeted, group_anchor, group_backoff) catch @panic("OOM");
+ // `$` is refused anywhere but last, so `h$|zz` was a bad pattern
+ // while `zz|h$` was fine. An alternative or a group ends at `|` and
+ // `)`, and the matcher's `.end` ends the alternative it is in, so
+ // `$` may stand before either (docs/mvzr-group-backtrack.md).
+ const end_anchor =
+ \\ '$' => {
+ \\ if (i + 1 < in.len) {
+ \\
+ ;
+ const end_before_alt =
+ \\ '$' => {
+ \\ // pardes's patch (its build.zig): `$` may end an alternative.
+ \\ if (i + 1 < in.len and in[i + 1] != '|' and in[i + 1] != ')') {
+ \\
+ ;
+ if (std.mem.count(u8, backed, end_anchor) != 1) @panic("mvzr's parser changed: redo its `$` before `|` in build.zig");
+ var patched = std.mem.replaceOwned(u8, b.allocator, backed, end_anchor, end_before_alt) catch @panic("OOM");
+ // Zig 0.17 removed `**`; mvzr still has it (its PR #16 replaces it upstream).
+ for ([_][3][]const u8{
+ .{ "[1]RegOp{.{ .unused = {} }} ** ops", "@splat(.{ .unused = {} })", "1" },
+ .{ "[1]CharSet{.{ .low = 0, .hi = 0 }} ** char_sets", "@splat(.{ .low = 0, .hi = 0 })", "1" },
+ .{ "\"a\" ** 2048", "&@as([2048]u8, @splat('a'))", "2" },
+ .{ "\"12345,\" ** 255", "std.mem.asBytes(&@as([255][6]u8, @splat(\"12345,\".*)))", "1" },
+ }) |edit| {
+ if (std.mem.count(u8, patched, edit[0]) != std.fmt.parseInt(usize, edit[2], 10) catch unreachable) std.debug.panic("mvzr changed at `{s}`: redo its `**` patch in build.zig", .{edit[0]});
+ patched = std.mem.replaceOwned(u8, b.allocator, patched, edit[0], edit[1]) catch @panic("OOM");
+ }
+ break :mvzr b.createModule(.{ .root_source_file = b.addWriteFiles().add("mvzr.zig", patched), .target = target, .optimize = optimize });
+ };
+
+ // The C heap every C library with an allocator hook is handed: the core's
+ // tree-sitter and fonts, and pdf.zig's MuPDF, which is a module of its own.
+ const c_heap_mod = b.createModule(.{
+ .target = target,
+ .optimize = optimize,
+ .root_source_file = b.path("src/c_heap.zig"),
+ });
+
+ // One FreeType in a binary: the gui's glyph atlas links it and MuPDF is
+ // built against it (see mupdf.zig). At c_optimize with the rest of the
+ // vendored C, since MuPDF rasterizes a PDF's text through it.
+ const freetype_dep: ?*std.Build.Dependency = if (freestanding_core) null else b.dependency("freetype", .{
+ .target = target,
+ .optimize = c_optimize,
+ .@"enable-libpng" = false,
+ });
+ const freetype: ?*std.Build.Step.Compile = if (freetype_dep) |dep| dep.artifact("freetype") else null;
+ // ...and one zlib, the one FreeType links for its gzip module. Asked of
+ // FreeType's build with the options it asks with, the dependency cache
+ // hands back that same artifact rather than a second copy.
+ const zlib: ?*std.Build.Step.Compile = if (freetype_dep) |dep|
+ dep.builder.dependency("zlib", .{ .target = target, .optimize = c_optimize }).artifact("z")
+ else
+ null;
if (enable_mupdf) {
if (b.lazyDependency("mupdf", .{})) |mupdf_dep| {
@@ -413,6 +585,8 @@ pub fn build(b: *std.Build) void {
.target = target,
.optimize = c_optimize,
.jpx = enable_jpx,
+ .freetype = freetype.?,
+ .zlib = zlib.?,
});
const mupdf_mod = b.createModule(.{
.target = target,
@@ -421,6 +595,8 @@ pub fn build(b: *std.Build) void {
.link_libc = true,
});
mupdf.linkTo(mupdf_mod);
+ mupdf_mod.addImport("c_heap", c_heap_mod);
+ mupdf_mod.addImport("pdf_c", b.addTranslateC(.{ .root_source_file = b.path("src/pdf_bridge.h"), .target = target, .optimize = optimize }).createModule());
mupdf_mod.addIncludePath(b.path("src"));
mupdf_mod.addCSourceFile(.{
.file = b.path("src/pdf_bridge.c"),
@@ -438,11 +614,13 @@ pub fn build(b: *std.Build) void {
const pdf_bench_mod = b.createModule(.{
.target = target,
- .optimize = .ReleaseFast,
+ .optimize = .fast,
.root_source_file = b.path("src/pdf.zig"),
.link_libc = true,
});
mupdf.linkTo(pdf_bench_mod);
+ pdf_bench_mod.addImport("c_heap", c_heap_mod);
+ pdf_bench_mod.addImport("pdf_c", b.addTranslateC(.{ .root_source_file = b.path("src/pdf_bridge.h"), .target = target, .optimize = .fast }).createModule());
pdf_bench_mod.addIncludePath(b.path("src"));
pdf_bench_mod.addCSourceFile(.{
.file = b.path("src/pdf_bridge.c"),
@@ -452,14 +630,14 @@ pub fn build(b: *std.Build) void {
.name = "pardes-pdf-bench",
.root_module = b.createModule(.{
.target = target,
- .optimize = .ReleaseFast,
+ .optimize = .fast,
.root_source_file = b.path("test/pdf_bench.zig"),
.link_libc = true,
}),
});
pdf_bench.root_module.addImport("mupdf", pdf_bench_mod);
const run_pdf_bench = b.addRunArtifact(pdf_bench);
- if (b.args) |args| run_pdf_bench.addArgs(args);
+ run_pdf_bench.addPassthruArgs();
run_pdf_bench.setCwd(b.path("."));
pdf_bench_step.dependOn(&run_pdf_bench.step);
@@ -467,7 +645,7 @@ pub fn build(b: *std.Build) void {
.name = "pardes-pdf-sections-bench",
.root_module = b.createModule(.{
.target = target,
- .optimize = .ReleaseFast,
+ .optimize = .fast,
.root_source_file = b.path("test/pdf_sections_bench.zig"),
.link_libc = true,
}),
@@ -475,13 +653,29 @@ pub fn build(b: *std.Build) void {
pdf_sections_bench.root_module.addImport("pardes", core_module);
pdf_sections_bench.root_module.addImport("mupdf", mupdf_mod);
const sections_bench_opts = b.addOptions();
- sections_bench_opts.addOption(bool, "release_fast_core", optimize == .ReleaseFast);
+ sections_bench_opts.addOption(bool, "release_fast_core", optimize == .fast);
pdf_sections_bench.root_module.addOptions("pdf_sections_bench_config", sections_bench_opts);
const run_pdf_sections_bench = b.addRunArtifact(pdf_sections_bench);
- if (b.args) |args| run_pdf_sections_bench.addArgs(args);
+ run_pdf_sections_bench.addPassthruArgs();
run_pdf_sections_bench.setCwd(b.path("."));
pdf_sections_bench_step.dependOn(&run_pdf_sections_bench.step);
+ const pdf_pointer_bench = b.addExecutable(.{
+ .name = "pardes-pdf-pointer-bench",
+ .root_module = b.createModule(.{
+ .target = target,
+ .optimize = .fast,
+ .root_source_file = b.path("test/pdf_pointer_bench.zig"),
+ .link_libc = true,
+ }),
+ });
+ pdf_pointer_bench.root_module.addImport("pardes", core_module);
+ pdf_pointer_bench.root_module.addImport("mupdf", mupdf_mod);
+ const run_pdf_pointer_bench = b.addRunArtifact(pdf_pointer_bench);
+ run_pdf_pointer_bench.addPassthruArgs();
+ run_pdf_pointer_bench.setCwd(b.path("."));
+ pdf_pointer_bench_step.dependOn(&run_pdf_pointer_bench.step);
+
const pdf_scroll_bench = b.addExecutable(.{
.name = "pardes-pdf-scroll-bench",
.root_module = b.createModule(.{
@@ -494,11 +688,11 @@ pub fn build(b: *std.Build) void {
pdf_scroll_bench.root_module.addImport("pardes", core_module);
pdf_scroll_bench.root_module.addImport("mupdf", mupdf_mod);
const scroll_bench_opts = b.addOptions();
- scroll_bench_opts.addOption(bool, "release_fast_core", optimize == .ReleaseFast);
+ scroll_bench_opts.addOption(bool, "release_fast_core", optimize == .fast);
scroll_bench_opts.addOption([]const u8, "core_optimize", @tagName(optimize));
pdf_scroll_bench.root_module.addOptions("pdf_scroll_bench_config", scroll_bench_opts);
const run_pdf_scroll_bench = b.addRunArtifact(pdf_scroll_bench);
- if (b.args) |args| run_pdf_scroll_bench.addArgs(args);
+ run_pdf_scroll_bench.addPassthruArgs();
run_pdf_scroll_bench.setCwd(b.path("."));
pdf_scroll_bench_step.dependOn(&run_pdf_scroll_bench.step);
}
@@ -517,112 +711,356 @@ pub fn build(b: *std.Build) void {
.tables_path = uucode_tables,
}).module("uucode");
- const vaxis_mod = b.dependency("vaxis", .{
+ const vaxis_dep = b.dependency("vaxis", .{
.target = target,
.optimize = optimize,
.external_uucode = true,
- }).module("vaxis");
+ });
+ const vaxis_mod = vaxis_dep.module("vaxis");
+ // vaxis's input parser, patched here at build time like mvzr so that a
+ // fresh fetch keeps it: no reply, split read or malformed sequence may
+ // reach the editor as typed text, and none may panic or end input.
+ // - A cursor position report that no F3 could have sent is no key: the
+ // startup width queries' `CSI 1;1R` arrived as two F3s, which a shell
+ // pane took for text.
+ // - ESC before a CSI or SS3 key (rxvt's Alt+arrow) is Alt on that key,
+ // not Alt+Escape followed by `[A` as text.
+ // - An X10 mouse report and a kitty graphics reply cut short by a read
+ // wait for their rest: the first became three bytes of text, the
+ // second sliced past its input.
+ // - A byte no UTF-8 starts with is dropped instead of failing the parse,
+ // which stopped input. (vaxis itself now drops a malformed color or
+ // clipboard reply and ends an OSC at its first terminator.)
+ // - A device report's fields are sought in the sequence, not past it.
+ // A bump that moves an anchor stops the build.
+ {
+ var src = configureRead(b, io, vaxis_dep.builder.root, "src/Parser.zig", 1 << 20) catch @panic("read vaxis Parser.zig");
+ const edits = [_]struct { anchor: []const u8, with: []const u8, count: usize = 1 }{
+ .{
+ .anchor =
+ \\ 0x5F => return parseApc(input),
+ \\ else => {
+ ,
+ .with =
+ \\ 0x5F => return parseApc(input),
+ \\ // pardes's patch (its build.zig): ESC before a key's sequence is Alt on the key.
+ \\ 0x1B => if (input.len > 2 and (input[2] == '[' or input[2] == 'O')) {
+ \\ var inner = if (input[2] == '[') parseCsi(input[1..], &self.buf, self.cursor_position_requests) else parseSs3(input[1..]);
+ \\ if (inner.n == 0) return inner;
+ \\ if (inner.event) |*event| switch (event.*) {
+ \\ .key_press, .key_release => |*key| key.mods.alt = true,
+ \\ else => {},
+ \\ };
+ \\ inner.n += 1;
+ \\ return inner;
+ \\ } else return .{ .event = .{ .key_press = .{ .codepoint = Key.escape, .mods = .{ .alt = true } } }, .n = 2 },
+ \\ else => {
+ ,
+ },
+ .{
+ .anchor = " const first_cp = iter.next() orelse return error.InvalidUTF8;\n",
+ .with = " const first_cp = iter.next() orelse return .{ .event = null, .n = 1 }; // pardes's patch (its build.zig)\n",
+ },
+ .{
+ .anchor = " n = std.unicode.utf8CodepointSequenceLength(first_cp) catch return error.InvalidUTF8;\n",
+ .with = " n = std.unicode.utf8CodepointSequenceLength(first_cp) catch return .{ .event = null, .n = 1 }; // pardes's patch (its build.zig)\n",
+ },
+ .{
+ .anchor =
+ \\ const sequence = input[0 .. end + 1 + 1];
+ \\
+ \\ switch (input[2]) {
+ ,
+ .with =
+ \\ // pardes's patch (its build.zig): an ESC that ends the input is half an ST.
+ \\ if (input.len < end + 2) return .{ .event = null, .n = 0 };
+ \\ const sequence = input[0 .. end + 1 + 1];
+ \\
+ \\ switch (input[2]) {
+ ,
+ },
+ .{
+ .anchor =
+ \\ 'A', 'B', 'C', 'D', 'E', 'F', 'H', 'P', 'Q', 'R', 'S' => {
+ \\ // Legacy keys
+ \\
+ ,
+ .with =
+ \\ 'A', 'B', 'C', 'D', 'E', 'F', 'H', 'P', 'Q', 'R', 'S' => {
+ \\ // pardes's patch (its build.zig): a cursor position report is no key.
+ \\ if (final == 'R' and cursorReport(sequence)) return null_event;
+ \\ // Legacy keys
+ \\
+ ,
+ },
+ .{
+ .anchor = " std.debug.assert(sequence.len >= 4); // ESC [ ? c == 4 bytes\n",
+ .with = " if (sequence.len < 4) return null_event; // pardes's patch (its build.zig)\n",
+ },
+ .{
+ .anchor = "const delim_idx = std.mem.indexOfScalarPos(u8, input, 3, ';')",
+ .with = "const delim_idx = std.mem.indexOfScalarPos(u8, sequence, 3, ';')",
+ .count = 2,
+ },
+ .{
+ .anchor = "input[delim_idx + 1 .. sequence.len - 2]",
+ .with = "sequence[@min(delim_idx + 1, sequence.len - 2) .. sequence.len - 2]",
+ },
+ .{
+ .anchor = " if (input.len == 3 and (input[2] == 'M') and full_input.len >= 6) {\n",
+ .with =
+ \\ // pardes's patch (its build.zig): an X10 report still arriving is incomplete, not text.
+ \\ if (input.len == 3 and input[2] == 'M' and full_input.len < 6) return .{ .event = null, .n = 0 };
+ \\ if (input.len == 3 and (input[2] == 'M') and full_input.len >= 6) {
+ \\
+ ,
+ },
+ };
+ for (edits) |edit| {
+ if (std.mem.count(u8, src, edit.anchor) != edit.count) std.debug.panic("vaxis's Parser.zig changed at `{s}`: redo its patch in build.zig", .{edit.anchor});
+ src = std.mem.replaceOwned(u8, b.allocator, src, edit.anchor, edit.with) catch @panic("OOM");
+ }
+ const cursor_report =
+ \\
+ \\/// pardes's patch (its build.zig): whether `CSI ... R` answers a cursor
+ \\/// position query. Only `CSI 1 ; mods R` with mods past 1 is a modified F3
+ \\/// (a bare F3 is `SS3 R`); a report has another row, or col 1 (mods 1).
+ \\fn cursorReport(sequence: []const u8) bool {
+ \\ const params = sequence[2 .. sequence.len - 1];
+ \\ if (params.len > 0 and params[0] == '?') return true;
+ \\ var fields = std.mem.splitScalar(u8, params, ';');
+ \\ const row = fields.first();
+ \\ const col = fields.next() orelse return false;
+ \\ if (fields.next() != null or row.len == 0 or col.len == 0) return false;
+ \\ for (params) |c| if (c != ';' and !std.ascii.isDigit(c)) return false;
+ \\ return !std.mem.eql(u8, row, "1") or std.mem.eql(u8, col, "1");
+ \\}
+ \\
+ ;
+ // vaxis's render, patched the same way: a blank whose ink alone
+ // changed is not sent, since a blank's ink shows nowhere. A fade
+ // (InactiveDim on a focus change) sent every blank of every pane it
+ // touched again: 7 KB a click for three shell panes. The terminal
+ // keeps the old ink there, and so does vaxis's last frame.
+ var render_src = configureRead(b, io, vaxis_dep.builder.root, "src/Vaxis.zig", 1 << 20) catch @panic("read vaxis Vaxis.zig");
+ const render_anchor =
+ \\ if ((!self.refresh and
+ \\ last.eql(cell) and
+ ;
+ if (std.mem.count(u8, render_src, render_anchor) != 1) std.debug.panic("vaxis's Vaxis.zig changed at `{s}`: redo its patch in build.zig", .{render_anchor});
+ render_src = std.mem.replaceOwned(u8, b.allocator, render_src, render_anchor,
+ \\ if ((!self.refresh and
+ \\ (last.eql(cell) or blankInkOnly(&last, &cell)) and // pardes's patch (its build.zig)
+ \\
+ ) catch @panic("OOM");
+ // And the secondary cursors count as changed when they differ, not
+ // when they are the same: read the other way round, every render
+ // started a frame, ~40 bytes to the terminal with nothing changed.
+ const secondary_anchor = " std.meta.eql(self.screen.cursor_secondary, self.state.cursor_secondary);\n";
+ if (std.mem.count(u8, render_src, secondary_anchor) != 1) std.debug.panic("vaxis's Vaxis.zig changed at `{s}`: redo its patch in build.zig", .{secondary_anchor});
+ render_src = std.mem.replaceOwned(u8, b.allocator, render_src, secondary_anchor, " !std.meta.eql(self.screen.cursor_secondary, self.state.cursor_secondary); // pardes's patch (its build.zig)\n") catch @panic("OOM");
+ const blank_ink =
+ \\
+ \\/// pardes's patch (its build.zig): a blank cell (a space, no underline,
+ \\/// strike or reverse) that differs from the last frame's blank in its
+ \\/// ink alone, which shows nowhere.
+ \\inline fn blankInkOnly(last: *const InternalScreen.InternalCell, cell: *const Cell) bool {
+ \\ if (!(cell.char.grapheme.len == 1 and cell.char.grapheme[0] == ' ')) return false;
+ \\ if (last.default or cell.default) return false;
+ \\ if (!(last.char.items.len == 1 and last.char.items[0] == ' ')) return false;
+ \\ const s = cell.style;
+ \\ if (s.reverse or s.strikethrough or s.ul_style != .off) return false;
+ \\ if (!std.mem.eql(u8, last.uri.items, cell.link.uri)) return false;
+ \\ // Field by field: Style.eql is slow, and this runs for every blank
+ \\ // a scrolling shell moves.
+ \\ const l = last.style;
+ \\ return sameColor(l.bg, s.bg) and sameColor(l.ul, s.ul) and l.ul_style == s.ul_style and
+ \\ l.bold == s.bold and l.dim == s.dim and l.italic == s.italic and l.blink == s.blink and
+ \\ !l.reverse and !l.strikethrough and l.invisible == s.invisible;
+ \\}
+ \\
+ \\inline fn sameColor(a: Cell.Color, b: Cell.Color) bool {
+ \\ return switch (a) {
+ \\ .default => b == .default,
+ \\ .index => |i| b == .index and b.index == i,
+ \\ .rgb => |rgb| b == .rgb and rgb[0] == b.rgb[0] and rgb[1] == b.rgb[1] and rgb[2] == b.rgb[2],
+ \\ };
+ \\}
+ \\
+ ;
+ const files = b.addWriteFiles();
+ _ = files.add("Parser.zig", b.fmt("{s}{s}", .{ src, cursor_report }));
+ _ = files.add("Vaxis.zig", b.fmt("{s}{s}", .{ render_src, blank_ink }));
+ _ = files.addCopyFile(vaxis_dep.path("src/widgets/terminal/Parser.zig"), "widgets/terminal/Parser.zig");
+ // Suffixes: this leaves out both Parser.zig files and Vaxis.zig,
+ // written above.
+ _ = files.addCopyDirectory(vaxis_dep.path("src"), "", .{ .exclude_extensions = &.{ "Parser.zig", "Vaxis.zig" } });
+ vaxis_mod.root_source_file = files.getDirectory().path(b, "main.zig");
+ }
var ghostty_vt_for_snap: ?*std.Build.Module = null;
const ghostty_simd = !freestanding_core and (!target.result.os.tag.isDarwin() or b.graph.host.result.os.tag.isDarwin());
- const ghostty_optimize: std.builtin.OptimizeMode = if (optimize == .Debug) .ReleaseSafe else optimize;
+ const ghostty_optimize: std.lang.Optimize = if (optimize == .debug) .safe else optimize;
const ghostty_dep = if (is_esp32p4) null else b.lazyDependency("ghostty", .{ .target = target, .optimize = ghostty_optimize, .simd = ghostty_simd, .@"app-runtime" = .none, .@"emit-xcframework" = false });
if (ghostty_dep) |dep| {
const ghostty_vt = dep.module("ghostty-vt");
ghostty_vt_for_snap = ghostty_vt;
ghostty_vt.addImport("uucode", uucode_mod);
+ patchGhosttyKitty(b, io, dep, ghostty_vt);
ghostty_core_vt = ghostty_vt;
}
// override uucode on vaxis LAST so it wins over ghostty's build() wiring.
vaxis_mod.addImport("uucode", uucode_mod);
+ // One PNG and one JPEG decoder (docs/shared-libs.md): ghostty's, wuffs,
+ // which ghostty-vt links for kitty graphics whatever pardes does (its
+ // decoders stay in through wuffs's function tables). Where it is in the
+ // build, image.zig decodes PNG and JPEG through it, and stb_image is
+ // compiled without them, so without the inflate only its PNG used. Its
+ // writer goes too, and the deflate it carries: pardes writes no image
+ // through stb. A fresh fetch keeps both: the flags and the patch are
+ // applied here, at build time.
+ const wuffs_mod: ?*std.Build.Module = if (ghostty_core_vt) |vt| vt.import_table.get("wuffs") else null;
+ for ([_]?*std.Build.Step.Options{ opts, gui_opts }) |o| if (o) |x| x.addOption(bool, "wuffs_images", wuffs_mod != null);
+ if (wuffs_mod != null) if (zstbi_dep) |dep| {
+ var sources: usize = 0;
+ for (zstbi_mod.link_objects.items) |obj| switch (obj) {
+ .c_source_file => |csf| {
+ sources += 1;
+ const src = configureRead(b, io, dep.builder.root, "src/zstbi.c", 1 << 20) catch @panic("read zstbi.c");
+ const writer = "#define STB_IMAGE_WRITE_IMPLEMENTATION\n#include \"stb_image_write.h\"\n";
+ if (std.mem.count(u8, src, writer) != 1) std.debug.panic("zstbi.c changed at `{s}`: redo its patch in build.zig", .{writer});
+ // zstbi.deinit still resets the writer's flip flag.
+ const patched = std.mem.replaceOwned(u8, b.allocator, src, writer, "void stbi_flip_vertically_on_write(int flag) { (void)flag; }\n") catch @panic("OOM");
+ csf.file = b.addWriteFiles().add("zstbi.c", patched);
+ csf.flags = std.mem.concat(b.allocator, []const u8, &.{ csf.flags, &.{ "-DSTBI_NO_PNG", "-DSTBI_NO_JPEG" } }) catch @panic("OOM");
+ },
+ else => {},
+ };
+ if (sources != 1) @panic("zstbi's build no longer compiles one C file: redo its patch in build.zig");
+ };
+
// One call per module instead of one line per module per dependency, and
// BEFORE the fold below, which reads what these imports put in the table.
for (core_mods) |m| wireCore(m, .{
.themes = themes_mod,
- .zls = zls_mod,
.tree_sitter = ts_mod,
.ts_libs = ts_libs.items,
.ts_queries = ts_queries_opts,
.zstbi = zstbi_mod,
.mvzr = mvzr_mod,
+ .c_heap = c_heap_mod,
.mupdf = mupdf_core_mod,
.ghostty_vt = ghostty_core_vt,
.vaxis = vaxis_mod,
.uucode = uucode_mod,
+ .wuffs = wuffs_mod,
});
- var module_count: usize = 0;
- {
- var it = root_mod.import_table.iterator();
- while (it.next()) |e| {
- const lp = e.value_ptr.*.root_source_file orelse continue;
- switch (lp) {
- .src_path, .cwd_relative => module_count += 1,
- else => continue,
- }
- }
- }
- const mod_names = b.allocator.alloc([]const u8, module_count) catch @panic("OOM");
- const mod_roots = b.allocator.alloc([]const u8, module_count) catch @panic("OOM");
- var module_index: usize = 0;
- {
- var it = root_mod.import_table.iterator();
- while (it.next()) |e| {
- const lp = e.value_ptr.*.root_source_file orelse continue;
- // `generated` is a build artifact (the options modules): it has no
- // path until make() runs, and pointing an editor at one is useless
- const abs = switch (lp) {
- .src_path => |sp| sp.owner.pathFromRoot(sp.sub_path),
- .cwd_relative => |cr| cr,
- else => continue,
- };
- mod_names[module_index] = e.key_ptr.*;
- mod_roots[module_index] = abs;
- module_index += 1;
- }
- }
- std.debug.assert(module_index == module_count);
- for ([_]?*std.Build.Step.Options{ opts, gui_opts }) |maybe| if (maybe) |o| {
- o.addOption([]const []const u8, "module_names", mod_names);
- o.addOption([]const []const u8, "module_roots", mod_roots);
- };
-
const iso_off = b.addOptions();
iso_off.addOption(bool, "isolated", false);
const iso_on = b.addOptions();
iso_on.addOption(bool, "isolated", true);
- // Consulted only for a gui shell, so `-Dprebuilt-shaders` alone decides it
- // here; the platform half of that condition is the branch it sits in.
- const gui_effect_source_dir = if (prebuilt_shaders) "shaders/prebuilt" else "shaders";
for (core_mods, core_shells) |mod, shell| {
+ // config.zig's test checks the words and keys docs/typ names exist.
+ mod.addOptions("doc_typ", doc_typ_opts);
mod.addOptions("pardes_config", if (also_gui and shell == .gui) gui_opts.? else opts);
mod.addOptions("pardes_isolation", if (isolated_mod == mod) iso_on else iso_off);
if (shell == .gui) for (gui_shaders) |name| mod.addAnonymousImport(
b.fmt("effect-source-{s}.glsl", .{name}),
- .{ .root_source_file = b.path(b.fmt("{s}/{s}.glsl", .{ gui_effect_source_dir, name })) },
+ .{ .root_source_file = shaderSource(b, name) },
);
if (shell == .macos) mod.addAnonymousImport("effect-source-crt.ci.metal", .{
.root_source_file = b.path("shaders/crt.ci.metal"),
});
}
+ // docs/typ/builtins-<platform>.json: every builtin, from the registry and the Help
+ // rows (src/builtins_json.zig), rewritten in the source tree so a plain
+ // `typst compile` reads it too; a unit test fails when it is stale.
+ // A terminal build writes builtins-tty.json and a window build
+ // builtins-gui.json; style.typ merges the two into one glossary.
+ const builtins_json_step = b.step("builtins-json", "rewrite docs/typ/builtins-<tty|gui>.json from the builtin registry (-Dplatform=tty or gui)");
+ if (requested_platform == .tty or requested_platform == .gui) {
+ const gen = b.addExecutable(.{ .name = "pardes-gen-builtins-json", .root_module = b.createModule(.{
+ .target = target,
+ .optimize = optimize,
+ .root_source_file = b.path("tools/gen_builtins_json.zig"),
+ .imports = &.{.{ .name = "pardes", .module = core_module }},
+ }) });
+ const run_gen = b.addRunArtifact(gen);
+ const json = run_gen.addOutputFileArg("builtins.json");
+ const update = b.addUpdateSourceFiles();
+ update.addCopyFileToSource(json, b.fmt("docs/typ/builtins-{s}.json", .{@tagName(platform)}));
+ builtins_json_step.dependOn(&update.step);
+ for (doc_renders) |r| if (r) |run| run.step.dependOn(&update.step);
+ } else builtins_json_step.dependOn(&b.addFail("builtins-json writes one build's list: pass -Dplatform=tty or -Dplatform=gui").step);
+
const gui_shell_mod: ?*std.Build.Module = gui_mod orelse
if (platform == .gui) root_mod else null;
if (gui_shell_mod) |gm| {
const sdl_dep = b.lazyDependency("sdl", .{ .target = target, .optimize = optimize, .sanitize_c = .off, .preferred_linkage = .static });
if (sdl_dep) |dep| {
const sdl_lib = dep.artifact("SDL3");
+ // SDL's own stb_image (SDL_stb.c, for SDL_LoadPNG and a camera's
+ // MJPEG, neither of which pardes calls) is a second PNG and JPEG
+ // decoder beside the build's: off (docs/shared-libs.md).
+ sdl_lib.root_module.addCMacro("SDL_DISABLE_STB", "1");
gm.linkLibrary(sdl_lib);
gm.addIncludePath(dep.path("include"));
+ // gui.zig's `c`: SDL and the font shim, which @cImport gave it before Zig 0.17.
+ const header = b.addWriteFiles().add("gui_c.h",
+ \\#define SDL_DISABLE_OLD_NAMES 1
+ \\#include <SDL3/SDL.h>
+ \\#include "font.h"
+ \\
+ );
+ const gui_c = b.addTranslateC(.{ .root_source_file = header, .target = target, .optimize = optimize });
+ gui_c.addIncludePath(dep.path("include"));
+ gui_c.addIncludePath(b.path("src/gui"));
+ gm.addImport("gui_c", gui_c.createModule());
+ }
+ gm.linkLibrary(freetype.?);
+ // HarfBuzz from source, like FreeType: its FreeType integration
+ // (HAVE_FREETYPE, hb-ft) links the freetype artifact above, so the two
+ // share one FreeType. The flags are the ones Ghostty builds it with,
+ // plus its allocator: gui.zig's ui_malloc and friends, over a Zig
+ // allocator, as FreeType's is.
+ if (b.lazyDependency("harfbuzz", .{})) |upstream| {
+ const harfbuzz = b.addLibrary(.{
+ .name = "harfbuzz",
+ .linkage = .static,
+ .root_module = b.createModule(.{
+ .target = target,
+ .optimize = optimize,
+ .link_libc = true,
+ .link_libcpp = true,
+ }),
+ });
+ harfbuzz.root_module.linkLibrary(freetype.?);
+ harfbuzz.root_module.addIncludePath(upstream.path("src"));
+ harfbuzz.root_module.addCSourceFile(.{
+ .file = upstream.path("src/harfbuzz.cc"),
+ .flags = &.{
+ "-DHAVE_STDBOOL_H",
+ "-DHAVE_UNISTD_H",
+ "-DHAVE_SYS_MMAN_H",
+ "-DHAVE_PTHREAD=1",
+ "-DHAVE_FREETYPE=1",
+ "-DHAVE_FT_GET_VAR_BLEND_COORDINATES=1",
+ "-DHAVE_FT_SET_VAR_BLEND_COORDINATES=1",
+ "-DHAVE_FT_DONE_MM_VAR=1",
+ "-DHAVE_FT_GET_TRANSFORM=1",
+ "-Dhb_malloc_impl=ui_malloc",
+ "-Dhb_calloc_impl=ui_calloc",
+ "-Dhb_realloc_impl=ui_realloc",
+ "-Dhb_free_impl=ui_free",
+ },
+ });
+ gm.linkLibrary(harfbuzz);
+ gm.addIncludePath(upstream.path("src"));
}
- const freetype_dep = b.dependency("freetype", .{
- .target = target,
- .optimize = optimize,
- .@"enable-libpng" = false,
- });
- gm.linkLibrary(freetype_dep.artifact("freetype"));
if (target.result.os.tag.isDarwin())
gm.addRPath(.{ .cwd_relative = "/usr/local/lib" });
gm.addIncludePath(b.path("src/gui"));
@@ -632,6 +1070,8 @@ pub fn build(b: *std.Build) void {
gm.addAnonymousImport("AdwaitaMono-Regular.ttf", .{
.root_source_file = b.path("assets/AdwaitaMono-Regular.ttf"),
});
+ // Put before a user's Shadertoy file when the gui compiles it.
+ gm.addAnonymousImport("post-prefix.glsl", .{ .root_source_file = b.path("shaders/post/prefix.glsl") });
for (gui_shaders) |name| gm.addAnonymousImport(b.fmt("{s}.spv", .{name}), .{
.root_source_file = if (prebuilt_shaders)
b.path(b.fmt("shaders/prebuilt/{s}.spv", .{name}))
@@ -640,6 +1080,11 @@ pub fn build(b: *std.Build) void {
});
}
+ // A detached session compiles its attached GUIs' Shadertoy files
+ // (ShaderBuild.zig), whichever shell it was built for.
+ if (gui_shell_mod != root_mod)
+ root_mod.addAnonymousImport("post-prefix.glsl", .{ .root_source_file = b.path("shaders/post/prefix.glsl") });
+
if (is_web) {
const dp = dump_path.?;
root_mod.addAnonymousImport("embedded.dump.zon", .{
@@ -663,7 +1108,7 @@ pub fn build(b: *std.Build) void {
}) |file| web_step.dependOn(&b.addInstallFileWithDir(b.path(file[0]), .{ .custom = "web" }, file[1]).step);
const run_web_harness = b.addSystemCommand(&.{ "node", "test/web_harness.mjs" });
- run_web_harness.addArg(b.getInstallPath(.{ .custom = "web" }, ""));
+ run_web_harness.addDirectoryArg(installed("web"));
run_web_harness.step.dependOn(web_step);
b.step("web-harness", "run the dependency-free JS/WASM DOM harness").dependOn(&run_web_harness.step);
b.getInstallStep().dependOn(web_step);
@@ -707,9 +1152,9 @@ pub fn build(b: *std.Build) void {
const min_version = b.fmt("{d}.{d}", .{ macos_min_version.major, macos_min_version.minor });
const swift_mode: []const u8 = switch (optimize) {
- .Debug => "-Onone",
- .ReleaseSmall => "-Osize",
- .ReleaseFast, .ReleaseSafe => "-O",
+ .debug => "-Onone",
+ .small => "-Osize",
+ .fast, .safe => "-O",
};
const link = b.addSystemCommand(&.{ "swiftc", swift_mode, "-target", triple, "-import-objc-header" });
@@ -758,7 +1203,7 @@ pub fn build(b: *std.Build) void {
plist.addFileArg(b.path("src/macos/Info.plist"));
const version_plist = b.addSystemCommand(&.{
- "plutil", "-replace", "CFBundleShortVersionString", "-string", zon.version, "-o",
+ "plutil", "-replace", "CFBundleShortVersionString", "-string", display_version, "-o",
});
const version_plist_out = version_plist.addOutputFileArg("Info.plist");
version_plist.addFileArg(plist_out);
@@ -776,7 +1221,8 @@ pub fn build(b: *std.Build) void {
const sign = b.addSystemCommand(&.{ "codesign", "--force", "--sign", macos_identity });
if (!std.mem.eql(u8, macos_identity, "-")) sign.addArgs(&.{ "--options", "runtime", "--timestamp" });
- sign.addArg(b.getInstallPath(.prefix, "pardes.app"));
+ sign.setCwd(installed(""));
+ sign.addArg("pardes.app");
sign.has_side_effects = true;
sign.step.dependOn(&install_app_bin.step);
sign.step.dependOn(&install_plist.step);
@@ -785,8 +1231,8 @@ pub fn build(b: *std.Build) void {
app_step.dependOn(&sign.step);
const dmg = b.addSystemCommand(&.{ "hdiutil", "create", "-volname", "pardes", "-ov", "-format", "UDZO", "-srcfolder" });
- dmg.addArg(b.getInstallPath(.prefix, "pardes.app"));
- dmg.addArg(b.getInstallPath(.prefix, "pardes.dmg"));
+ dmg.setCwd(installed(""));
+ dmg.addArgs(&.{ "pardes.app", "pardes.dmg" });
dmg.has_side_effects = true;
dmg.step.dependOn(&sign.step);
dmg_step.dependOn(&dmg.step);
@@ -825,7 +1271,7 @@ pub fn build(b: *std.Build) void {
const run_e2e = std.Build.Step.Run.create(b, "run macos-e2e");
run_e2e.addFileArg(runnable);
run_e2e.setCwd(b.path("."));
- if (b.args) |args| run_e2e.addArgs(args);
+ run_e2e.addPassthruArgs();
run_e2e.has_side_effects = true;
e2e_step.dependOn(&run_e2e.step);
} else e2e_step.dependOn(&b.addFail("macos-e2e needs a Darwin host and target").step);
@@ -848,7 +1294,7 @@ pub fn build(b: *std.Build) void {
.linkage = if (static) .static else null,
.root_module = root_mod,
});
- b.installArtifact(exe);
+ installHome(b, exe, home_bin);
if (gui_mod) |gm| {
var gui_name: []const u8 = "pardes-gui";
if (target.result.os.tag != .linux or target.result.cpu.arch != .x86_64)
@@ -858,7 +1304,7 @@ pub fn build(b: *std.Build) void {
.linkage = if (static) .static else null,
.root_module = gm,
});
- b.installArtifact(gui_exe);
+ installHome(b, gui_exe, home_bin);
}
const run = b.addRunArtifact(exe);
b.step("run", "descend to the pardes").dependOn(&run.step);
@@ -870,7 +1316,7 @@ pub fn build(b: *std.Build) void {
});
const run_iso = b.addRunArtifact(iso_exe);
// Something to look at on arrival, read out of the binary itself.
- if (b.args) |args| run_iso.addArgs(args) else run_iso.addArg("src/pardes.zig");
+ run_iso.addPassthruArgs();
const iso_step = b.step("run-isolated", "descend to a pardes with no host but the terminal");
iso_step.dependOn(&run_iso.step);
}
@@ -904,6 +1350,40 @@ pub fn build(b: *std.Build) void {
run_image_harness.has_side_effects = true;
b.step("image-harness", "exercise native Kitty/SDL image rendering end to end").dependOn(&run_image_harness.step);
+ // Kitty graphics through a terminal pane, end to end: a client in
+ // the pane's bash (and kitten icat, chafa when installed), a kitty
+ // terminal outside (tty) or the GPU capture (gui). test/kitty.zig
+ // is the same protocol at the core.
+ const kitty_client = b.addExecutable(.{
+ .name = "pardes-kitty-client",
+ .root_module = b.createModule(.{
+ .target = target,
+ .optimize = optimize,
+ .root_source_file = b.path("test/kitty_client.zig"),
+ .link_libc = true,
+ }),
+ });
+ const kitty_harness = b.addExecutable(.{
+ .name = "pardes-kitty-harness",
+ .root_module = b.createModule(.{
+ .target = target,
+ .optimize = optimize,
+ .root_source_file = b.path("test/kitty_harness.zig"),
+ .link_libc = true,
+ }),
+ });
+ if (ghostty_vt_for_snap) |vt| kitty_harness.root_module.addImport("ghostty-vt", vt);
+ switch (target.result.os.tag) {
+ .freebsd, .netbsd, .openbsd => kitty_harness.root_module.linkSystemLibrary("util", .{}),
+ else => {},
+ }
+ const run_kitty_harness = b.addRunArtifact(kitty_harness);
+ run_kitty_harness.addArtifactArg(exe);
+ run_kitty_harness.addArtifactArg(kitty_client);
+ run_kitty_harness.addArg(if (platform == .gui) "gui" else "tty");
+ run_kitty_harness.has_side_effects = true;
+ b.step("kitty-harness", "kitty graphics through a terminal pane end to end (a client inside, a kitty terminal or the GPU capture outside)").dependOn(&run_kitty_harness.step);
+
const pdf_harness_step = b.step("pdf-harness", "exercise continuous PDF rendering, search, and sections navigation end to end");
if (enable_mupdf) {
const run_pdf_harness = b.addRunArtifact(image_harness);
@@ -928,15 +1408,9 @@ pub fn build(b: *std.Build) void {
hxdiff.root_module.addImport("pardes", core_module);
const run_hxdiff = b.addRunArtifact(hxdiff);
run_hxdiff.has_side_effects = true;
- if (b.args) |args| run_hxdiff.addArgs(args) else {
- run_hxdiff.addArgs(&.{
- "--strict",
- "test/hxcases/cases.jsonl",
- "test/hxcases/goldens.jsonl",
- "test/hxcases/waivers.jsonl",
- });
- run_hxdiff.setCwd(b.path("."));
- }
+ // Bare, it runs the checked-in suite (test/hxdiff.zig).
+ run_hxdiff.addPassthruArgs();
+ run_hxdiff.setCwd(b.path("."));
const hxdiff_step = b.step("hxdiff", "compare Helix results (-- --strict cases reference [waivers]; cases alone emits)");
hxdiff_step.dependOn(&run_hxdiff.step);
@@ -961,65 +1435,49 @@ pub fn build(b: *std.Build) void {
const run_hxparity = b.addRunArtifact(hxdiff);
run_hxparity.has_side_effects = true;
run_hxparity.addArg("--parity");
- if (b.args) |args| run_hxparity.addArgs(args) else {
- run_hxparity.addArgs(&.{
- "--strict",
- "--waivers",
- "test/hxcases/parity-waivers.jsonl",
- "test/hxcases/cases.jsonl",
- "test/hxcases/parity.jsonl",
- });
- run_hxparity.setCwd(b.path("."));
- }
+ run_hxparity.addPassthruArgs();
+ run_hxparity.setCwd(b.path("."));
const hxparity_step = b.step("hxparity", "run the file-vs-pty editing parity suite (-- [--waivers w.jsonl] <cases.jsonl>...)");
hxparity_step.dependOn(&run_hxparity.step);
+ // every helix-golf example, one case per step of its walkthrough
+ const run_hxgolf = b.addRunArtifact(hxdiff);
+ run_hxgolf.has_side_effects = true;
+ run_hxgolf.addArgs(&.{ "--strict", "test/hxcases/golf.jsonl", "test/hxcases/golf-goldens.jsonl", "test/hxcases/golf-waivers.jsonl" });
+ run_hxgolf.setCwd(b.path("."));
+ b.step("hxgolf", "compare the helix-golf examples against their Helix results").dependOn(&run_hxgolf.step);
+
const lspbench = b.addExecutable(.{
.name = "pardes-lspbench",
.root_module = b.createModule(.{
.target = target,
- .optimize = .ReleaseFast,
+ .optimize = .fast,
.root_source_file = b.path("test/lspbench.zig"),
.link_libc = true,
}),
});
lspbench.root_module.addImport("pardes", core_module);
const run_lspbench = b.addRunArtifact(lspbench);
- if (b.args) |args| run_lspbench.addArgs(args);
+ run_lspbench.addPassthruArgs();
run_lspbench.setCwd(b.path("."));
run_lspbench.has_side_effects = true;
- const lspbench_step = b.step("lspbench", "language-backend latency + feature matrix (-- [--json] [--check] [repo-root])");
+ const lspbench_step = b.step("lspbench", "language-backend latency + feature matrix (-- [--json] [--check] [repo-root]), or one query (-- probe <kind> <file> <line>:<col> [arg] [--reps N])");
lspbench_step.dependOn(&run_lspbench.step);
const run_lspbench_check = b.addRunArtifact(lspbench);
run_lspbench_check.addArg("--check");
- if (b.args) |args| run_lspbench_check.addArgs(args);
+ run_lspbench_check.addPassthruArgs();
run_lspbench_check.setCwd(b.path("."));
run_lspbench_check.has_side_effects = true;
const lspbench_check_step = b.step("lspbench-check", "require every configured language probe to complete correctly");
lspbench_check_step.dependOn(&run_lspbench_check.step);
- const lspprobe = b.addExecutable(.{
- .name = "pardes-lspprobe",
- .root_module = b.createModule(.{
- .target = target,
- .optimize = optimize,
- .root_source_file = b.path("tools/lspprobe.zig"),
- .link_libc = true,
- }),
- });
- lspprobe.root_module.addImport("pardes", core_module);
- const run_lspprobe = b.addRunArtifact(lspprobe);
- if (b.args) |args| run_lspprobe.addArgs(args);
- const lspprobe_step = b.step("lspprobe", "one language query against the real seam (-- <kind> <file> <line>:<col> [arg] [--reps N])");
- lspprobe_step.dependOn(&run_lspprobe.step);
-
const locations_bench_step = b.step("locations-bench", "measure cold/warm result formatting (-Doptimize=ReleaseFast; CSV on stderr)");
- if (optimize != .ReleaseFast) {
+ if (optimize != .fast) {
locations_bench_step.dependOn(&b.addFail("locations-bench requires -Doptimize=ReleaseFast").step);
} else {
const locations_bench_module = b.createModule(.{
.target = target,
- .optimize = .ReleaseFast,
+ .optimize = .fast,
.root_source_file = b.path("test/locations_bench.zig"),
.link_libc = true,
});
@@ -1030,7 +1488,7 @@ pub fn build(b: *std.Build) void {
locations_bench_step.dependOn(&run_locations_bench.step);
}
- const perf_optimize: std.builtin.OptimizeMode = .ReleaseFast;
+ const perf_optimize: std.lang.Optimize = .fast;
const perf_options = b.addOptions();
const perf_target = std.Target.Query.fromTarget(&target.result);
perf_options.addOption(PerfBuild, "identity", .{
@@ -1064,10 +1522,22 @@ pub fn build(b: *std.Build) void {
perf.root_module.addOptions("perf_options", perf_options);
const run_perf = b.addRunArtifact(perf);
run_perf.has_side_effects = true;
- if (b.args) |args| run_perf.addArgs(args);
+ run_perf.addPassthruArgs();
run_perf.setCwd(b.path("."));
const perf_step = b.step("perf", "gesture latency or bounded terminal stress (-- [--json] [--reps N] [--base old.json] [--terminal-mib N])");
perf_step.dependOn(&run_perf.step);
+ // The gate: the 50k-line file's gestures against the baseline this
+ // build shape recorded, each within 3x of its best. Record one with
+ // `zig build perf -Dplatform=P [-Doptimize=O] -- --only medium
+ // --reps 10 --json > test/perf-baseline-P-O.json` (a build that is
+ // known good). ponytail: the numbers are this machine's; another
+ // machine records its own.
+ const perf_gate = b.addRunArtifact(perf);
+ perf_gate.has_side_effects = true;
+ perf_gate.setCwd(b.path("."));
+ perf_gate.addArgs(&.{ "--only", "medium", "--reps", "10", "--base", b.fmt("test/perf-baseline-{t}-{t}.json", .{ platform, optimize }), "--max-ratio", "3" });
+ const perf_gate_step = b.step("perf-gate", "fail when a gesture on the 50k-line file takes over 3x its recorded baseline (test/perf-baseline-<platform>-<optimize>.json)");
+ perf_gate_step.dependOn(&perf_gate.step);
const perf_tests = b.addTest(.{
.root_module = b.createModule(.{
.target = target,
@@ -1089,7 +1559,7 @@ pub fn build(b: *std.Build) void {
.name = "pardes-fs-bench",
.root_module = b.createModule(.{
.target = target,
- .optimize = .ReleaseFast,
+ .optimize = .fast,
.root_source_file = b.path("test/fs_bench.zig"),
.link_libc = true,
}),
@@ -1097,7 +1567,7 @@ pub fn build(b: *std.Build) void {
fs_bench.root_module.addImport("pardes", core_module);
const run_fs_bench = b.addRunArtifact(fs_bench);
run_fs_bench.has_side_effects = true;
- if (b.args) |args| run_fs_bench.addArgs(args);
+ run_fs_bench.addPassthruArgs();
run_fs_bench.setCwd(b.path("."));
const fs_bench_step = b.step("fs-bench", "9P filesystem request cost and allocation count (-- [--json] [--reps N])");
fs_bench_step.dependOn(&run_fs_bench.step);
@@ -1122,7 +1592,7 @@ pub fn build(b: *std.Build) void {
.link_libc = true,
});
syntax_module.addOptions("pardes_config", opts);
- wireCore(syntax_module, .{ .tree_sitter = ts_mod, .ts_libs = ts_libs.items, .ts_queries = ts_queries_opts });
+ wireCore(syntax_module, .{ .tree_sitter = ts_mod, .ts_libs = ts_libs.items, .ts_queries = ts_queries_opts, .c_heap = c_heap_mod });
const syntax_runner = b.addExecutable(.{
.name = "pardes-syntax",
.root_module = b.createModule(.{
@@ -1134,11 +1604,11 @@ pub fn build(b: *std.Build) void {
});
syntax_runner.root_module.addImport("syntax", syntax_module);
const run_syntax = b.addRunArtifact(syntax_runner);
- if (b.args) |args| run_syntax.addArgs(args);
+ run_syntax.addPassthruArgs();
b.step("syntax", "emit deterministic syntax snapshots").dependOn(&run_syntax.step);
const run_syntax_bench = b.addRunArtifact(syntax_runner);
run_syntax_bench.addArg("--bench");
- if (b.args) |args| run_syntax_bench.addArgs(args);
+ run_syntax_bench.addPassthruArgs();
run_syntax_bench.has_side_effects = true;
b.step("syntax-bench", "measure highlighting latency and allocations").dependOn(&run_syntax_bench.step);
const syntax_test = b.addTest(.{
@@ -1156,7 +1626,37 @@ pub fn build(b: *std.Build) void {
if (enable_quic) run_fs_test.addArg("--quic");
run_fs_test.setCwd(b.path("."));
run_fs_test.has_side_effects = true;
- b.step("fs-test", "exercise default 9P service and mounts with an independent client").dependOn(&run_fs_test.step);
+ const fs_test_step = b.step("fs-test", "exercise default 9P service and mounts with an independent client");
+ fs_test_step.dependOn(&run_fs_test.step);
+
+ // Random 9P operations against a throwaway detached session, checking
+ // the documented rules (test/monkey9p.py). The fixed-seed smoke run is
+ // part of fs-test; the long run is manual.
+ const run_monkey9p = b.addSystemCommand(&.{ "python3", "-B", "test/monkey9p.py" });
+ run_monkey9p.addArtifactArg(exe);
+ run_monkey9p.addPassthruArgs();
+ run_monkey9p.setCwd(b.path("."));
+ run_monkey9p.has_side_effects = true;
+ b.step("monkey-9p", "random 9P operations checking the documented rules (-- [--seed N]... [--steps M] [--replay F] [--shrink F] [--no-shrink])").dependOn(&run_monkey9p.step);
+ // The GUI's effects under random input in a hidden test window, each
+ // Motion x Lift x Bloom (test/gui_monkey.py): a gate, not part of
+ // fs-test, since it needs a Wayland display.
+ const monkey_gui_step = b.step("monkey-gui", "random input to hidden GUI test windows across the effect settings (-Dplatform=gui; -- [--seed N] [--steps M])");
+ if (platform == .gui) {
+ const run_monkey_gui = b.addSystemCommand(&.{ "python3", "-B", "test/gui_monkey.py" });
+ run_monkey_gui.addArtifactArg(exe);
+ run_monkey_gui.addPassthruArgs();
+ run_monkey_gui.setCwd(b.path("."));
+ run_monkey_gui.has_side_effects = true;
+ monkey_gui_step.dependOn(&run_monkey_gui.step);
+ } else monkey_gui_step.dependOn(&b.addFail("monkey-gui needs -Dplatform=gui").step);
+ const run_monkey9p_smoke = b.addSystemCommand(&.{ "python3", "-B", "test/monkey9p.py" });
+ run_monkey9p_smoke.addArtifactArg(exe);
+ run_monkey9p_smoke.addArg("--smoke");
+ run_monkey9p_smoke.setCwd(b.path("."));
+ run_monkey9p_smoke.has_side_effects = true;
+ b.step("monkey-9p-smoke", "a short fixed-seed 9P monkey run (part of fs-test)").dependOn(&run_monkey9p_smoke.step);
+ fs_test_step.dependOn(&run_monkey9p_smoke.step);
const run_discovery = b.addSystemCommand(&.{ "python3", "-B", "test/fs.py" });
run_discovery.addArtifactArg(exe);
@@ -1176,7 +1676,7 @@ pub fn build(b: *std.Build) void {
}),
});
// Ordinary executable; each launch asks sudo inside its own PTY.
- b.installArtifact(v9fs_helper);
+ installHome(b, v9fs_helper, home_bin);
const run_v9fs = b.addSystemCommand(&.{ "python3", "-B", "test/v9fs.py" });
run_v9fs.addArtifactArg(exe);
run_v9fs.addArtifactArg(v9fs_helper);
@@ -1211,11 +1711,33 @@ pub fn build(b: *std.Build) void {
}),
});
const run_history = b.addRunArtifact(history);
- if (b.args) |args| run_history.addArgs(args);
+ run_history.addPassthruArgs();
run_history.has_side_effects = true;
b.step("history", "compare command output and test/build runtime across jj revisions").dependOn(&run_history.step);
const unit_step = b.step("unit-test", "run native shell and module unit tests");
+ // One copy of each codec in the binary (docs/shared-libs.md): the
+ // linked symbol table, read for the families the build chose against.
+ // ELF only; it runs with every unit-test, like the perf gate.
+ if (target.result.ofmt == .elf) {
+ const libs_check = b.addExecutable(.{
+ .name = "pardes-shared-libs-check",
+ .root_module = b.createModule(.{
+ .target = b.graph.host,
+ .optimize = .debug,
+ .root_source_file = b.path("tools/shared_libs_check.zig"),
+ .link_libc = true,
+ }),
+ });
+ const run_libs_check = b.addRunArtifact(libs_check);
+ run_libs_check.addArtifactArg(exe);
+ const libs_check_step = b.step("shared-libs-check", "fail when the binary links a second copy of a codec the build chose one of (docs/shared-libs.md)");
+ libs_check_step.dependOn(&run_libs_check.step);
+ unit_step.dependOn(&run_libs_check.step);
+ }
+ // The perf gate runs with every unit-test (a regression like a
+ // contrast search per grapheme costs 100x, far past the gate).
+ unit_step.dependOn(perf_gate_step);
const unit_match = testMatch(b, unit_profile, test_filters, unit_step);
const lspbench_tests = b.addTest(.{ .root_module = lspbench.root_module, .filters = test_filters });
const run_lspbench_tests = b.addRunArtifact(lspbench_tests);
@@ -1224,18 +1746,6 @@ pub fn build(b: *std.Build) void {
lspbench_test_step.dependOn(&run_lspbench_tests.step);
lspbench_check_step.dependOn(&run_lspbench_tests.step);
if (testMatch(b, unit_profile, test_filters, lspbench_test_step)) |check| check.addArtifactArg(lspbench_tests);
- const config_module = b.createModule(.{
- .target = target,
- .optimize = optimize,
- .root_source_file = b.path("src/config.zig"),
- });
- config_module.addImport("pardes_config", core_module.import_table.get("pardes_config").?);
- const config_tests = b.addTest(.{ .root_module = config_module, .filters = test_filters });
- const run_config_tests = b.addRunArtifact(config_tests);
- run_config_tests.has_side_effects = true;
- const config_test_step = b.step("config-test", "run configuration tests without compiling the editor");
- config_test_step.dependOn(&run_config_tests.step);
- if (testMatch(b, unit_profile, test_filters, config_test_step)) |check| check.addArtifactArg(config_tests);
const diff_tests = b.addTest(.{ .root_module = hxdiff.root_module, .filters = test_filters });
const run_diff_tests = b.addRunArtifact(diff_tests);
run_diff_tests.has_side_effects = true;
@@ -1271,6 +1781,28 @@ pub fn build(b: *std.Build) void {
pane_test_step.dependOn(&run_pane_tests.step);
if (testMatch(b, unit_profile, test_filters, pane_test_step)) |check| check.addArtifactArg(pane_tests);
+ // Kitty graphics conformance at the core: what a terminal pane's
+ // program sends, what it reads back, what ghostty stores and what a
+ // frame draws (test/kitty.zig). The end-to-end arm, through a real
+ // pty and the shell's output, is the kitty-harness step.
+ const kitty_module = b.createModule(.{
+ .target = target,
+ .optimize = optimize,
+ .root_source_file = b.path("test/kitty.zig"),
+ .link_libc = true,
+ });
+ kitty_module.addImport("pardes", core_module);
+ const kitty_tests = b.addTest(.{ .root_module = kitty_module, .filters = test_filters });
+ if (test_nonce) |nonce| kitty_tests.root_module.addImport("test_rebuild_nonce", nonce);
+ test_build.dependOn(&kitty_tests.step);
+ const run_kitty_tests = b.addRunArtifact(kitty_tests);
+ run_kitty_tests.has_side_effects = true;
+ unit_step.dependOn(&run_kitty_tests.step);
+ if (unit_match) |check| check.addArtifactArg(kitty_tests);
+ const kitty_test_step = b.step("kitty-test", "run the kitty graphics conformance cases for terminal panes");
+ kitty_test_step.dependOn(&run_kitty_tests.step);
+ if (testMatch(b, unit_profile, test_filters, kitty_test_step)) |check| check.addArtifactArg(kitty_tests);
+
// Keep native transport integration reachable even when the core's
// anonymous test-import block is filtered out by Zig.
const ninep_io_module = b.createModule(.{
@@ -1288,7 +1820,7 @@ pub fn build(b: *std.Build) void {
}
const ninep_io_tests = b.addTest(.{
.root_module = ninep_io_module,
- .filters = &.{ "Unix TCP", "one fetch", "expired sessions" },
+ .filters = &.{ "Unix TCP", "one fetch", "expired sessions", "posts itself" },
});
b.step("9p-io-test", "run native 9P transport and client integration tests")
.dependOn(&b.addRunArtifact(ninep_io_tests).step);
@@ -1319,7 +1851,7 @@ pub fn build(b: *std.Build) void {
.{ .path = "src/esp32p4_gpio.zig", .libc = false },
.{ .path = "src/esp32p4/input_rescue.zig", .libc = false },
.{ .path = "src/fonts.zig", .libc = true },
- .{ .path = "src/gui/crt.zig", .libc = false },
+ .{ .path = "src/c_heap.zig", .libc = false },
}) |entry| {
const tests = b.addTest(.{
.root_module = b.createModule(.{
@@ -1375,7 +1907,7 @@ pub fn build(b: *std.Build) void {
if (unit_match) |check| check.addArtifactArg(shell_test);
const run_profile = b.addRunArtifact(unit_profile);
run_profile.addArtifactArg(shell_test);
- if (b.args) |args| run_profile.addArgs(args);
+ run_profile.addPassthruArgs();
run_profile.has_side_effects = true;
b.step("unit-profile", "report test request time and process memory as JSONL (-- optional filter, --timeout-ms=N)").dependOn(&run_profile.step);
const profile_test = b.addExecutable(.{
@@ -1408,19 +1940,112 @@ fn testMatch(b: *std.Build, profiler: *std.Build.Step.Compile, filters: []const
return check;
}
-fn prefixIsUntouched(b: *std.Build) bool {
- if (b.dest_dir != null) return false;
- const zig_out = b.build_root.join(b.allocator, &.{"zig-out"}) catch @panic("OOM");
- if (!std.mem.eql(u8, b.install_prefix, zig_out)) return false;
- return std.mem.eql(u8, b.exe_dir, b.pathJoin(&.{ b.install_path, "bin" })) and
- std.mem.eql(u8, b.lib_dir, b.pathJoin(&.{ b.install_path, "lib" })) and
- std.mem.eql(u8, b.h_dir, b.pathJoin(&.{ b.install_path, "include" }));
+/// Installs `artifact` in the prefix and, given `home_bin`, copies it there
+/// too (`install` unlinks first, so a running binary is replaced).
+fn installHome(b: *std.Build, artifact: *std.Build.Step.Compile, home_bin: ?[]const u8) void {
+ b.installArtifact(artifact);
+ const dir = home_bin orelse return;
+ const copy = b.addSystemCommand(&.{ "install", "-Dm755" });
+ copy.addArtifactArg(artifact);
+ copy.addArg(b.pathJoin(&.{ dir, artifact.name }));
+ copy.has_side_effects = true;
+ b.getInstallStep().dependOn(&copy.step);
+}
+
+/// A file read while configuring, under a package's root. A dependency's is
+/// hash-addressed and never changes under the same pin; this repo's are not
+/// tracked one by one, since the configure runs again on every build anyway
+/// (findProgram and gitCommit poison its cache).
+// ponytail: untracked repo reads; b.dependOnFileContents each one if the configure cache ever stays pure.
+/// ghostty's kitty graphics loader (src/terminal/kitty/graphics_image.zig),
+/// patched at build time so a fresh fetch keeps it, for what a program in a
+/// pane may name with t=f, t=t and t=s (test/kitty.zig):
+/// - a path is opened for reading only once it is known to be a regular
+/// file: ghostty opens first and checks after, and the open of a FIFO
+/// waits for a writer (pardes hung) while a device's open may do
+/// something. On Linux an O_PATH probe looks, which opens nothing, and
+/// the same inode is reopened through /proc/self/fd.
+/// - shared memory is opened non-blocking and must be a regular file, so
+/// a FIFO in /dev/shm (or a symlink there to one) neither hangs nor maps.
+/// - an image may be no larger than a screen's storage
+/// (TerminalImages.storage_limit) rather than ghostty's 400 MB, which a
+/// program could make pardes read and hold before refusing it.
+fn patchGhosttyKitty(b: *std.Build, io: std.Io, dep: *std.Build.Dependency, vt: *std.Build.Module) void {
+ const rel = "src/terminal/kitty/graphics_image.zig";
+ var src = configureRead(b, io, dep.builder.root, rel, 1 << 22) catch @panic("read ghostty's graphics_image.zig");
+ const edits = [_][2][]const u8{
+ .{
+ "const max_size = 400 * 1024 * 1024; // 400MB",
+ "const max_size = 64 * 1024 * 1024; // pardes (build.zig): a screen's storage, TerminalImages.storage_limit",
+ },
+ .{
+ \\ var file = std.Io.Dir.cwd().openFile(
+ \\ io,
+ \\ path,
+ \\ .{},
+ \\ ) catch |err| {
+ ,
+ \\ var file = pardesOpenRegular(io, path) catch |err| {
+ },
+ .{
+ " const fd = std.c.shm_open(pathz, @as(c_int, @bitCast(std.c.O{ .ACCMODE = .RDONLY })), @as(u16, 0));",
+ \\ // pardes (build.zig): a FIFO there must not hang the open, and
+ \\ // on Linux nothing but a regular file is opened at all.
+ \\ if (comptime builtin.target.os.tag == .linux) if (path.len > 0 and path[0] == '/') {
+ \\ var dev: [std.Io.Dir.max_path_bytes]u8 = undefined;
+ \\ const full = std.fmt.bufPrint(&dev, "/dev/shm{s}", .{path}) catch return error.InvalidData;
+ \\ const shm_stat = std.Io.Dir.cwd().statFile(io, full, .{}) catch return error.InvalidData;
+ \\ if (shm_stat.kind != .file) return error.InvalidData;
+ \\ };
+ \\ const fd = std.c.shm_open(pathz, @as(c_int, @bitCast(std.c.O{ .ACCMODE = .RDONLY, .NONBLOCK = true })), @as(u16, 0));
+ },
+ .{
+ " if (stat.size <= 0) return error.InvalidData;",
+ " if (stat.kind != .file) return error.InvalidData; // pardes (build.zig)\n if (stat.size <= 0) return error.InvalidData;",
+ },
+ };
+ for (edits) |edit| {
+ if (std.mem.count(u8, src, edit[0]) != 1) std.debug.panic("ghostty's {s} changed at `{s}`: redo its patch in build.zig", .{ rel, edit[0] });
+ src = std.mem.replaceOwned(u8, b.allocator, src, edit[0], edit[1]) catch @panic("OOM");
+ }
+ const helper =
+ \\
+ \\/// pardes (build.zig): `path`, opened for reading only once it is known
+ \\/// to be a regular file. Elsewhere than Linux, ghostty's open as it was.
+ \\fn pardesOpenRegular(io: std.Io, path: []const u8) !std.Io.File {
+ \\ if (comptime builtin.target.os.tag != .linux) return std.Io.Dir.cwd().openFile(io, path, .{});
+ \\ const probe = try std.Io.Dir.cwd().openFile(io, path, .{ .path_only = true });
+ \\ defer probe.close(io);
+ \\ const stat = try probe.stat(io);
+ \\ if (stat.kind != .file) return error.NotRegularFile;
+ \\ var buf: [32]u8 = undefined;
+ \\ const same = std.fmt.bufPrint(&buf, "/proc/self/fd/{d}", .{probe.handle}) catch unreachable;
+ \\ return std.Io.Dir.cwd().openFile(io, same, .{});
+ \\}
+ \\
+ ;
+ const files = b.addWriteFiles();
+ // The rest of src as it is; fonts are the app's, not the library's.
+ _ = files.addCopyDirectory(dep.path("src"), "", .{ .exclude_extensions = &.{ "graphics_image.zig", ".ttf", ".otf" } });
+ _ = files.add("terminal/kitty/graphics_image.zig", b.fmt("{s}{s}", .{ src, helper }));
+ vt.root_source_file = files.getDirectory().path(b, "lib_vt.zig");
+}
+
+fn configureRead(b: *std.Build, io: std.Io, root: std.Build.Cache.Path, sub: []const u8, limit: usize) ![]u8 {
+ return root.root_dir.handle.readFileAlloc(io, b.pathJoin(&.{ root.subPathOrDot(), sub }), b.allocator, .limited(limit));
+}
+
+/// `sub` under the install prefix, known only when the build runs.
+fn installed(sub: []const u8) std.Build.LazyPath {
+ return .{ .relative = .{ .base = .install_prefix, .sub_path = sub } };
}
fn gitCommit(b: *std.Build) ?[]const u8 {
+ // HEAD is not a file the configure cache can track.
+ b.graph.poisonCache();
var code: u8 = 0;
const out = b.runAllowFail(
- &.{ "git", "-C", b.build_root.path orelse ".", "rev-parse", "--short=12", "HEAD" },
+ &.{ "git", "rev-parse", "--short=12", "HEAD" },
&code,
.ignore,
) catch return null;
@@ -1431,7 +2056,6 @@ fn gitCommit(b: *std.Build) ?[]const u8 {
const ShellConfig = struct {
tree_sitter_grammars: TreeSitterGrammars,
tracy: bool,
- zls_backend: bool,
mupdf: bool,
esp32p4_cols: u16,
esp32p4_rows: u16,
@@ -1443,7 +2067,6 @@ const ShellConfig = struct {
workspace_tag: ?bool,
prebuilt_shaders: bool,
embed_sources: bool,
- zig_lib_dir: []const u8,
commit: ?[]const u8,
};
@@ -1455,22 +2078,16 @@ fn shellOptions(b: *std.Build, cfg: ShellConfig, platform: Platform) *std.Build.
o.addOption(bool, "syntax_minimal_grammars", cfg.tree_sitter_grammars == .minimal or cfg.tree_sitter_grammars == .full);
o.addOption(bool, "syntax_full_grammars", cfg.tree_sitter_grammars == .full);
o.addOption(bool, "enable_tracy", cfg.tracy);
- o.addOption(bool, "zls_backend", cfg.zls_backend);
o.addOption(bool, "mupdf", cfg.mupdf);
o.addOption(u16, "esp32p4_cols", cfg.esp32p4_cols);
o.addOption(u16, "esp32p4_rows", cfg.esp32p4_rows);
o.addOption(bool, "workspace_tag", cfg.workspace_tag orelse (platform != .macos));
o.addOption(bool, "theme_animation", cfg.theme_animation orelse (platform != .esp32p4));
- // Meaningful only for the SDL shell. Keeping the platform condition here
- // prevents Config/EffectCode from describing tty/macOS/web as "prebuilt".
- o.addOption(bool, "gui_shader_sources_prebuilt", platform == .gui and cfg.prebuilt_shaders);
- o.addOption([]const u8, "zls_version", if (cfg.zls_backend) zls_version else "none");
o.addOption(bool, "embed_sources", cfg.embed_sources);
- o.addOption([]const u8, "version", zon.version);
- // ...and the commit it was built from, when there is one. See `gitCommit`
- // for why this is optional and why it is read at configure time.
+ o.addOption([]const u8, "version", display_version);
+ // ...and the commit it was built from, when there is one and the build
+ // is stamped at all (see `stamp_commit`). Read at configure time.
o.addOption(?[]const u8, "commit", cfg.commit);
- o.addOption([]const u8, "zig_lib_dir", cfg.zig_lib_dir);
return o;
}
@@ -1501,10 +2118,23 @@ fn reindexed(b: *std.Build, archive: std.Build.LazyPath, index: usize) std.Build
// glslc shaders/<name>.glsl -fshader-stage=<vertex|fragment> -o <name>.spv,
// returned as a LazyPath for @embedFile. The stage is the name's own suffix.
+/// The GLSL a shader is compiled from: shaders/<name>.glsl, or for a bundled
+/// post pass (post-<name>.frag) shaders/post/<name>.glsl behind the Shadertoy
+/// prefix, the one the gui puts before a user's file at run time.
+fn shaderSource(b: *std.Build, name: []const u8) std.Build.LazyPath {
+ if (!std.mem.startsWith(u8, name, "post-")) return b.path(b.fmt("shaders/{s}.glsl", .{name}));
+ const joined = b.addSystemCommand(&.{"cat"});
+ joined.addFileArg(b.path("shaders/post/prefix.glsl"));
+ joined.addFileArg(b.path(b.fmt("shaders/post/{s}.glsl", .{name["post-".len .. name.len - ".frag".len]})));
+ return joined.captureStdOut(.{});
+}
+
+/// The one glslc invocation every shader is compiled with, at build time here
+/// and at run time for a user's post pass (src/gui/Post.zig).
fn compileGlsl(b: *std.Build, name: []const u8) std.Build.LazyPath {
const stage = if (std.mem.endsWith(u8, name, ".vert")) "vertex" else "fragment";
const cmd = b.addSystemCommand(&.{ "glslc", b.fmt("-fshader-stage={s}", .{stage}) });
- cmd.addFileArg(b.path(b.fmt("shaders/{s}.glsl", .{name})));
+ cmd.addFileArg(shaderSource(b, name));
cmd.addArg("-o");
return cmd.addOutputFileArg(b.fmt("{s}.spv", .{name}));
}
@@ -1512,7 +2142,7 @@ fn compileGlsl(b: *std.Build, name: []const u8) std.Build.LazyPath {
fn vendoredThemes(b: *std.Build, io: std.Io) []const []const u8 {
var count: usize = 0;
{
- var dir = b.build_root.handle.openDir(io, "vendor/themes", .{ .iterate = true }) catch @panic("open vendor/themes");
+ var dir = b.root.root_dir.handle.openDir(io, "vendor/themes", .{ .iterate = true }) catch @panic("open vendor/themes");
defer dir.close(io);
var it = dir.iterate();
while (it.next(io) catch @panic("read vendor/themes")) |e| {
@@ -1522,7 +2152,7 @@ fn vendoredThemes(b: *std.Build, io: std.Io) []const []const u8 {
}
const names = b.allocator.alloc([]const u8, count) catch @panic("OOM");
- var dir = b.build_root.handle.openDir(io, "vendor/themes", .{ .iterate = true }) catch @panic("open vendor/themes");
+ var dir = b.root.root_dir.handle.openDir(io, "vendor/themes", .{ .iterate = true }) catch @panic("open vendor/themes");
defer dir.close(io);
var it = dir.iterate();
var index: usize = 0;
@@ -1542,34 +2172,36 @@ fn vendoredThemes(b: *std.Build, io: std.Io) []const []const u8 {
fn wireCore(m: *std.Build.Module, d: struct {
themes: ?*std.Build.Module = null,
- zls: ?*std.Build.Module = null,
tree_sitter: ?*std.Build.Module = null,
ts_libs: []const *std.Build.Step.Compile = &.{},
ts_queries: ?*std.Build.Step.Options = null,
zstbi: ?*std.Build.Module = null,
mvzr: ?*std.Build.Module = null,
+ c_heap: ?*std.Build.Module = null,
mupdf: ?*std.Build.Module = null,
ghostty_vt: ?*std.Build.Module = null,
vaxis: ?*std.Build.Module = null,
uucode: ?*std.Build.Module = null,
+ wuffs: ?*std.Build.Module = null,
}) void {
if (d.themes) |x| m.addImport("generated_themes", x);
- if (d.zls) |x| m.addImport("zls", x);
if (d.tree_sitter) |x| m.addImport("tree-sitter", x);
for (d.ts_libs) |lib| m.linkLibrary(lib);
if (d.ts_queries) |x| m.addOptions("ts_queries", x);
if (d.zstbi) |x| m.addImport("zstbi", x);
if (d.mvzr) |x| m.addImport("mvzr", x);
+ if (d.c_heap) |x| m.addImport("c_heap", x);
if (d.mupdf) |x| m.addImport("mupdf", x);
if (d.ghostty_vt) |x| m.addImport("ghostty-vt", x);
if (d.vaxis) |x| m.addImport("vaxis", x);
if (d.uucode) |x| m.addImport("uucode", x);
+ if (d.wuffs) |x| m.addImport("wuffs", x);
}
/// The CPU feature set for the ESP32-P4 firmware target, as a `Cpu.Feature.Set`. Spelled as a
/// helper because `cpu_features_add` wants a set and there is no literal syntax for one.
fn riscvFeatures(comptime features: []const std.Target.riscv.Feature) std.Target.Cpu.Feature.Set {
var set = std.Target.Cpu.Feature.Set.empty;
- for (features) |f| set.addFeature(@intFromEnum(f));
+ for (features) |f| set.addFeature(@backingInt(f));
return set;
}