1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
|
//! pardes's syntax as a library: the `pardes-syntax` module a package that
//! depends on pardes imports (build.zig's `library`, docs/typ/building.typ),
//! for a program that draws source text itself and wants it parsed and
//! coloured as pardes has it. Nothing is copied here: these are the editor's
//! own grammars and highlighting (syntax.zig), themes (colors.zig) and line
//! arithmetic (modal.zig), under the names they have there. Whatever is
//! named here compiles with tree-sitter and the grammars alone; test/lib
//! imports it as such a package and holds it to that.
//!
//! A language is told by a path's extension, as in the editor; `pathFor`
//! gives a path for a language's name. One thread: each language's parser
//! is kept and shared between calls.
const syntax = @import("syntax.zig");
const colors = @import("colors.zig");
const modal = @import("modal.zig");
/// Every grammar pardes knows (`all`), by name or alias (`byName`) and by
/// path (`byPath`). The build's `tree-sitter` option says which of them are
/// compiled in, and `supportsPath` answers for this build.
pub const grammars = @import("grammar_manifest.zig");
pub const supportsPath = syntax.supportsPath;
/// A path that selects the language `name` (a grammar's name or an alias,
/// in any case: "c", "py", "Zig"); null when no grammar goes by it.
pub fn pathFor(name: []const u8) ?[]const u8 {
const i = grammars.byName(name) orelse return null;
inline for (grammars.all, 0..) |g, at| {
if (g.exts.len > 0 and at == i) return "a" ++ g.exts[0];
}
return null;
}
/// tree-sitter and the grammars' scanners allocate from `start`'s allocator
/// from then on, and from libc's malloc without it; before any other call
/// here, and once. `stop` frees the parsers and queries kept per language,
/// after a `start` or without one.
pub const start = syntax.start;
pub const stop = syntax.stop;
/// What a byte is drawn as. pardes has one colour each for keywords,
/// strings, numbers and comments (`synInk`); none is the text's own.
pub const Syn = syntax.Syn;
/// One `Syn` for each byte of `content[start..end]`, that range parsed as a
/// text of its own, the caller's to free; empty where the path has no
/// grammar.
pub const highlightFileRange = syntax.highlightFileRange;
/// A whole text in one parse: its `colors`, a `Syn` a byte, and its
/// `declarations`, the functions, types and tests of more than a line (the
/// editor's sticky headers), in source order, an outer one before its inner.
pub const SourceAnalysis = syntax.SourceAnalysis;
pub const ContextDeclaration = syntax.ContextDeclaration;
pub const analyzeSource = syntax.analyzeSource;
/// The tree-sitter bindings a tree is read through: `tree.rootNode()`, and
/// a node's `kind()`, `startByte()`, `endByte()`, `child(i)`, `parent()`.
pub const ts = syntax.ts;
/// `content` parsed by its path's grammar, the caller's to `destroy()`; null
/// without a grammar.
pub fn parse(path: []const u8, content: []const u8) ?*ts.Tree {
return @ptrCast(@alignCast(syntax.parseTree(path, content, null)));
}
/// helix's walks from a byte range to the nodes about it: the node that
/// holds it (`expand_node`), a sibling, its children.
pub const NodeWalk = syntax.NodeWalk;
pub const Span = syntax.Span;
pub const walkNodes = syntax.walkNodes;
pub const Theme = colors.Theme;
/// Every theme: pardes's own, then those imported from helix and zed. The
/// first is the default.
pub const themes: []const Theme = &colors.themes;
/// The theme named `name`, whatever its case.
pub fn theme(name: []const u8) ?*const Theme {
return &colors.themes[colors.themeIndex(name) orelse return null];
}
/// A theme's page and its text's ink as a file pane has them: its own, or
/// its tag's for the one theme with none (`dark`, a terminal's own).
pub fn page(th: *const Theme) [3]u8 {
return th.bg orelse th.tag_bg;
}
pub fn ink(th: *const Theme) [3]u8 {
return th.fg orelse th.tag_fg;
}
pub const synInk = colors.synInk;
/// A text's lines by its newlines: how many, the byte line `row` (from 0)
/// starts at, and its bytes.
pub const lineCount = modal.lineCount;
pub const lineStartOffset = modal.lineStartOffset;
pub const lineSlice = modal.lineSlice;
|