summaryrefslogtreecommitdiff
path: root/src/syntax.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-17 02:31:20 -0300
committerGabriel Schneider <[email protected]>2026-11-17 12:15:01 -0300
commitf749eb712d990a9b03f1db372d5311e77bd32edd (patch)
treeee4d9966f1eb293054b7ed865c9d4d6eb49e432b /src/syntax.zig
parent8f6621f9f70db86d56266a59b56dfb92b324b0d9 (diff)
parentb3d32656413734952bc918c2d4cfd12fede6c214 (diff)
downloadpardes-f749eb712d990a9b03f1db372d5311e77bd32edd.tar.gz
pardes-f749eb712d990a9b03f1db372d5311e77bd32edd.zip
integration: the terminal behind src/Term.zig, with the diff viewer and the plumber's first phase
A merge of term-phase0 and pardes-next. File.zig's recolorSyntax keeps the theme's grounds and names Term.Filter and Term.Span; the changelog keeps both sides' entries, the palette sentence in the place of the entry the terminal work cut down. core-test 985/985 on tui; the diff, pager and tree process cases pass, goldens unchanged. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
Diffstat (limited to 'src/syntax.zig')
-rw-r--r--src/syntax.zig171
1 files changed, 37 insertions, 134 deletions
diff --git a/src/syntax.zig b/src/syntax.zig
index 2526e113..70399bf7 100644
--- a/src/syntax.zig
+++ b/src/syntax.zig
@@ -22,7 +22,7 @@ const ts_queries = if (enabled) @import("ts_queries") else struct {};
const LanguageFn = *const fn () callconv(.c) *const ts.Language;
-pub const Syn = enum(u8) { none, keyword, string, number, comment };
+pub const Syn = grammar_manifest.Syn;
/// A query compiled when first asked for: "" for none, null when it fails.
const Lazy = struct { src: []const u8 = "", query: ?*ts.Query = null, failed: bool = false };
@@ -55,81 +55,6 @@ fn specCount() comptime_int {
}
return count;
}
-const typst_supplement =
- \\
- \\(call item: (ident) @keyword)
- \\(call item: (field field: (ident) @keyword))
- \\"#" @keyword
- \\
-;
-
-fn querySrc(comptime g: grammar_manifest.Grammar) []const u8 {
- const base = @field(ts_queries, g.name ++ "_highlights");
- const source = if (comptime std.mem.eql(u8, g.name, "typst")) base ++ typst_supplement else base;
- return comptime colorQuery(source);
-}
-
-fn colorQuery(comptime source: []const u8) []const u8 {
- @setEvalBranchQuota(2_000_000);
- var result: [source.len]u8 = undefined;
- var written: usize = 0;
- var at: usize = 0;
- while (at < source.len) {
- while (at < source.len) {
- if (std.ascii.isWhitespace(source[at])) {
- at += 1;
- } else if (source[at] == ';') {
- while (at < source.len and source[at] != '\n') at += 1;
- } else break;
- }
- const begin = at;
- var depth: usize = 0;
- var colored = false;
- var complete = false;
- while (at < source.len) {
- const byte = source[at];
- if (complete and (byte == '(' or byte == '[' or byte == '"')) break;
- if (byte == ';') {
- while (at < source.len and source[at] != '\n') at += 1;
- continue;
- }
- if (byte == '"') {
- at += 1;
- while (at < source.len) : (at += 1) {
- if (source[at] == '\\') {
- at += 1;
- } else if (source[at] == '"') {
- at += 1;
- break;
- }
- }
- if (depth == 0) complete = true;
- continue;
- }
- if (byte == '(' or byte == '[') depth += 1;
- if (byte == ')' or byte == ']') {
- depth -= 1;
- if (depth == 0) complete = true;
- }
- if (byte == '@') {
- const name = at + 1;
- at = name;
- while (at < source.len and (std.ascii.isAlphanumeric(source[at]) or
- source[at] == '_' or source[at] == '.' or source[at] == '-')) at += 1;
- colored = colored or synFor(source[name..at]) != .none;
- continue;
- }
- at += 1;
- }
- if (colored) {
- @memcpy(result[written..][0 .. at - begin], source[begin..at]);
- written += at - begin;
- }
- }
- const filtered = result[0..written].*;
- return &filtered;
-}
-
fn initSpecs() [specCount()]Spec {
var out: [specCount()]Spec = undefined;
var i = 0;
@@ -139,7 +64,7 @@ fn initSpecs() [specCount()]Spec {
.name = g.name,
.exts = g.exts,
.language = @extern(LanguageFn, .{ .name = "tree_sitter_" ++ g.name }),
- .query_src = querySrc(g),
+ .query_src = @field(ts_queries, g.name ++ "_highlights"),
.objects = .{ .src = @field(ts_queries, g.name ++ "_textobjects") },
.indents = .{ .src = @field(ts_queries, g.name ++ "_indents") },
};
@@ -219,7 +144,7 @@ fn ensure(spec: *Spec) !Selected {
const capture_styles = spec.capture_styles[0..query.captureCount()];
for (capture_styles, 0..) |*style, id| {
const name = query.captureNameForId(@intCast(id)) orelse "";
- style.* = @backingInt(synFor(name));
+ style.* = @backingInt(grammar_manifest.synFor(name));
if (style.* == 0) query.disableCapture(name);
}
const parser = ts.Parser.create();
@@ -260,34 +185,6 @@ fn runQuery(styles: []u8, sel: Selected, tree: *ts.Tree, base: usize) void {
}
}
-fn synFor(name: []const u8) Syn {
- for ([_]struct { []const u8, Syn }{
- .{ "comment", .comment },
- .{ "string", .string },
- .{ "character", .string },
- .{ "number", .number },
- .{ "numeric", .number },
- .{ "float", .number },
- .{ "boolean", .number },
- .{ "keyword", .keyword },
- .{ "include", .keyword },
- .{ "conditional", .keyword },
- .{ "repeat", .keyword },
- .{ "title", .keyword },
- .{ "uri", .string },
- .{ "reference", .number },
- .{ "heading", .keyword },
- .{ "strong", .comment },
- .{ "bold", .comment },
- .{ "emphasis", .number },
- .{ "italic", .number },
- .{ "literal", .string },
- .{ "raw", .string },
- }) |m| {
- if (std.mem.indexOf(u8, name, m[0]) != null) return m[1];
- }
- return .none;
-}
pub fn highlightFileRange(gpa: std.mem.Allocator, path: []const u8, content: []const u8, start_raw: usize, end_raw: usize) ![]u8 {
const zone = tracy.zone(@src(), "highlightFileRange");
defer zone.end();
@@ -1036,16 +933,17 @@ fn childOfKind(node: ts.Node, kind: []const u8) ?ts.Node {
return null;
}
-/// A diff line's style byte carries whether the line was added or removed
-/// over its syntax style (the low bits), so the painter can tint its row
-/// and mark its prefix; Diff marks the words a changed line changed
-/// (hunks.zig), drawn on a stronger tint.
-pub const diff_added: u8 = 0x80;
-pub const diff_removed: u8 = 0x40;
-pub const diff_emph: u8 = 0x20;
-/// A +Diff line added or removed whole, paired with no line it changed:
-/// its row takes a faint tint, on its marker's byte.
-pub const diff_whole: u8 = 0x10;
+/// A style byte: a Syn in its low bits (syn_bits), and over them the
+/// grounds a theme resolves (colors.Grounds): `ground_add` or `ground_del`,
+/// a row added or removed (its hue); `ground_emph`, the stronger ground;
+/// `ground_line`, the faint one. A row's first byte says its row's ground:
+/// emph the stronger to the pane's edge, line the faint one, neither none
+/// (only its marker in the hue). Any later byte's emph is its own cell's
+/// ground: the words a changed line changed (hunks.zig).
+pub const ground_add: u8 = 0x80;
+pub const ground_del: u8 = 0x40;
+pub const ground_emph: u8 = 0x20;
+pub const ground_line: u8 = 0x10;
pub const syn_bits: u8 = 0x0f;
/// A file section's hunks are parsed together, each side as one text, in
@@ -1070,7 +968,8 @@ var diff_clock: u64 = 0;
/// the file its section names. A hunk's old side (context and removed
/// lines) and new side (context and added lines) are each parsed whole, so
/// a string or comment that spans lines colours as it does in the file.
-/// Added and removed lines carry `diff_added`/`diff_removed`. A file in no
+/// Added and removed lines carry `ground_add`/`ground_del`, the first byte
+/// the strong row ground too (`ground_emph`). A file in no
/// language pardes knows keeps the plain colours: added lines as strings,
/// removed ones as numbers.
pub fn highlightDiff(gpa: std.mem.Allocator, content: []const u8, start_raw: usize, end_raw: usize) ![]u8 {
@@ -1185,13 +1084,14 @@ fn paintDiffPiece(gpa: std.mem.Allocator, window: DiffWindow, bytes: []const u8,
for (kinds) |kind| {
const line = lines.next() orelse break;
const style: u8 = switch (kind) {
- .added => @backingInt(Syn.string) | diff_added,
- .removed => @backingInt(Syn.number) | diff_removed,
+ .added => @backingInt(Syn.string) | ground_add,
+ .removed => @backingInt(Syn.number) | ground_del,
.no_newline => @backingInt(Syn.comment),
.hunk => @backingInt(Syn.keyword),
else => 0,
};
if (style != 0) window.fill(at + offset, line.len, style);
+ if (style & (ground_add | ground_del) != 0 and line.len > 0) window.fill(at + offset, 1, style | ground_emph);
offset += line.len + 1;
}
}
@@ -1273,13 +1173,14 @@ fn paintHunk(gpa: std.mem.Allocator, out: []u8, bytes: []const u8, kinds: []cons
if (kind == .context or kind == .removed) old_at += code_len + 1;
if (kind == .context or kind == .added) new_at += code_len + 1;
const flag: u8 = switch (kind) {
- .added => diff_added,
- .removed => diff_removed,
+ .added => ground_add,
+ .removed => ground_del,
else => 0,
};
if (flag != 0) for (out[offset..][0..line.len]) |*b| {
b.* |= flag;
};
+ if (flag != 0 and line.len > 0) out[offset] |= ground_emph;
}
}
@@ -1680,9 +1581,12 @@ test "syntax highlightDiff colors unified diff lines by prefix" {
// A file in no known language: each line in one colour, and tinted.
try std.testing.expectEqual(Syn.number, diffSynAt(styles, diff_text, "-old line", 0));
try std.testing.expectEqual(Syn.string, diffSynAt(styles, diff_text, "+new line", 0));
- try std.testing.expect(styles[std.mem.indexOf(u8, diff_text, "-old line").?] & diff_removed != 0);
- try std.testing.expect(styles[std.mem.indexOf(u8, diff_text, "+new line").? + 4] & diff_added != 0);
- try std.testing.expect(styles[std.mem.indexOf(u8, diff_text, " context").?] & (diff_added | diff_removed) == 0);
+ try std.testing.expect(styles[std.mem.indexOf(u8, diff_text, "-old line").?] & ground_del != 0);
+ try std.testing.expect(styles[std.mem.indexOf(u8, diff_text, "+new line").? + 4] & ground_add != 0);
+ try std.testing.expect(styles[std.mem.indexOf(u8, diff_text, " context").?] & (ground_add | ground_del) == 0);
+ // The row's ground on its first byte: the strong one, its other bytes none.
+ try std.testing.expect(styles[std.mem.indexOf(u8, diff_text, "-old line").?] & ground_emph != 0);
+ try std.testing.expect(styles[std.mem.indexOf(u8, diff_text, "+new line").? + 4] & (ground_emph | ground_line) == 0);
}
test "syntax a Zig hunk is coloured as Zig, each side parsed whole" {
@@ -1714,9 +1618,9 @@ test "syntax a Zig hunk is coloured as Zig, each side parsed whole" {
try std.testing.expectEqual(Syn.string, diffSynAt(styles, diff_text, "new words defer", 10));
// The prefix is no code: it carries the tint alone.
const added = std.mem.indexOf(u8, diff_text, "+ side").?;
- try std.testing.expectEqual(diff_added, styles[added]);
- try std.testing.expect(styles[std.mem.indexOf(u8, diff_text, "42").?] & diff_added != 0);
- try std.testing.expect(styles[std.mem.indexOf(u8, diff_text, "7,").?] & diff_removed != 0);
+ try std.testing.expectEqual(ground_add | ground_emph, styles[added]);
+ try std.testing.expect(styles[std.mem.indexOf(u8, diff_text, "42").?] & ground_add != 0);
+ try std.testing.expect(styles[std.mem.indexOf(u8, diff_text, "7,").?] & ground_del != 0);
try std.testing.expectEqual(Syn.comment, diffSynAt(styles, diff_text, "index 111", 0));
// A window in the middle is coloured as the whole is.
@@ -1763,7 +1667,7 @@ test "syntax a deleted file's lines are coloured in its language" {
defer std.testing.allocator.free(styles);
try std.testing.expectEqual(Syn.keyword, diffSynAt(styles, diff_text, "enum", 0));
try std.testing.expectEqual(Syn.comment, diffSynAt(styles, diff_text, "// the end", 3));
- try std.testing.expect(styles[std.mem.indexOf(u8, diff_text, "enum").?] & diff_removed != 0);
+ try std.testing.expect(styles[std.mem.indexOf(u8, diff_text, "enum").?] & ground_del != 0);
try std.testing.expectEqual(Syn.comment, diffSynAt(styles, diff_text, "deleted file", 0));
}
@@ -1812,9 +1716,9 @@ test "syntax git diff output in a command pane is told and coloured by its rows"
try std.testing.expectEqual(Syn.keyword, diffSynAt(styles, text, "fn main", 0));
try std.testing.expectEqual(Syn.number, diffSynAt(styles, text, "42", 0));
// The wrapped row stays an added line, and inside the comment.
- try std.testing.expect(styles[std.mem.indexOf(u8, text, "wrapped rest").?] & diff_added != 0);
+ try std.testing.expect(styles[std.mem.indexOf(u8, text, "wrapped rest").?] & ground_add != 0);
try std.testing.expectEqual(Syn.comment, diffSynAt(styles, text, "wrapped rest", 0));
- try std.testing.expect(styles[std.mem.indexOf(u8, text, "return").?] & diff_removed != 0);
+ try std.testing.expect(styles[std.mem.indexOf(u8, text, "return").?] & ground_del != 0);
}
test "syntax a section's small hunks share one parse" {
@@ -1836,7 +1740,7 @@ test "syntax a section's small hunks share one parse" {
try std.testing.expectEqual(@as(usize, 2), cached); // x.zig's three hunks, and y.zig's
try std.testing.expectEqual(Syn.keyword, diffSynAt(styles, diff_text, "@@ -10", 0));
try std.testing.expectEqual(Syn.number, diffSynAt(styles, diff_text, "2;\n@@ -20", 0));
- try std.testing.expect(styles[std.mem.indexOf(u8, diff_text, "@@ -10").?] & (diff_added | diff_removed) == 0);
+ try std.testing.expect(styles[std.mem.indexOf(u8, diff_text, "@@ -10").?] & (ground_add | ground_del) == 0);
}
test "syntax a hunk painted once is kept, and a long one is parsed in pieces" {
@@ -1909,8 +1813,7 @@ test "syntax query filtering preserves upstream colors" {
inline for (grammar_manifest.all) |grammar| {
if (comptime grammarSelected(grammar)) {
const selected = (try forLang(grammar.name)).?;
- const raw_source = @field(ts_queries, grammar.name ++ "_highlights") ++
- (if (comptime std.mem.eql(u8, grammar.name, "typst")) typst_supplement else "");
+ const raw_source = @field(ts_queries, grammar.name ++ "_highlights_unfiltered");
var error_offset: u32 = 0;
const raw_query = try ts.Query.create(selected.lang, raw_source, &error_offset);
defer raw_query.destroy();
@@ -1918,7 +1821,7 @@ test "syntax query filtering preserves upstream colors" {
reference.query = raw_query;
reference.capture_styles = try std.testing.allocator.alloc(u8, raw_query.captureCount());
defer std.testing.allocator.free(reference.capture_styles);
- for (reference.capture_styles, 0..) |*style, id| style.* = @backingInt(synFor(raw_query.captureNameForId(@intCast(id)) orelse ""));
+ for (reference.capture_styles, 0..) |*style, id| style.* = @backingInt(grammar_manifest.synFor(raw_query.captureNameForId(@intCast(id)) orelse ""));
const tree = selected.parser.parseString(source, null) orelse return error.ParseFailed;
defer tree.destroy();
var expected: [source.len]u8 = @splat(0);