summaryrefslogtreecommitdiff
path: root/src/Kind.zig
diff options
context:
space:
mode:
Diffstat (limited to 'src/Kind.zig')
-rw-r--r--src/Kind.zig997
1 files changed, 997 insertions, 0 deletions
diff --git a/src/Kind.zig b/src/Kind.zig
new file mode 100644
index 00000000..24448aa5
--- /dev/null
+++ b/src/Kind.zig
@@ -0,0 +1,997 @@
+//! A kind of pane that is neither text nor a terminal: a picture, a game,
+//! anything an addon (a library, Addon.zig) brings. Its records and
+//! functions are the C ABI of src/kinds/pardes_addon.h (translated, the
+//! one copy); this file is the core's side of it: the kinds this process
+//! has (compiled in, or an addon's, with the words and extensions they
+//! bring), and a pane's `Slot`, the state the core keeps round the kind's
+//! own (its path, its art bytes, its jobs, the record of one whose addon
+//! is not here).
+//!
+//! The core calls a kind at these places alone: Look and a word open a
+//! pane (`open`), the frame paints it (`draw`), its tag asks its prefix,
+//! keys and the mouse go to it, a tick steps it, a job's answer lands,
+//! 9P reads its body and writes its words, a dump keeps it, and its close.
+const std = @import("std");
+const builtin = @import("builtin");
+pub const c = @import("pardes_addon");
+const pardes = @import("pardes.zig");
+const walk = @import("walk.zig");
+const tape = @import("tape.zig");
+const surface = @import("surface.zig");
+const Placement = surface.Placement;
+const Pardes = pardes.Pardes;
+const Pane = pardes.panes.Pane;
+const Kind = @This();
+
+pub const Ops = c.pa_ops;
+pub const abi_major: u32 = c.PA_ABI_MAJOR;
+pub const abi: u32 = c.PA_ABI;
+
+// ---- the kinds this process has ----
+
+/// A kind as /addons lists it: an addon's loaded, one compiled in, or an
+/// addon refused and why.
+pub const Listed = struct {
+ name: [16]u8 = @splat(0),
+ version: u32 = 0,
+ abi: u32 = 0,
+ /// Null: refused.
+ ops: ?*const Ops = null,
+ /// Its addon's handle (Addon.zig), none for one compiled in.
+ lib: ?*anyopaque = null,
+ path: Buf(256) = .{},
+ why: Buf(128) = .{},
+
+ pub fn nameOf(l: *const Listed) []const u8 {
+ return std.mem.sliceTo(&l.name, 0);
+ }
+};
+
+pub const max_kinds = 16;
+var listed: [max_kinds]Listed = undefined;
+var nlisted: usize = 0;
+
+/// The run-time tail of the builtin registry (builtins.zig keeps the
+/// comptime part): each kind's words, found after the comptime map misses.
+pub const Word = struct { ops: *const Ops, w: *const c.pa_word };
+var words: [64]Word = undefined;
+var nwords: usize = 0;
+var exts: [32]struct { ext: []const u8, ops: *const Ops } = undefined;
+var nexts: usize = 0;
+
+/// The kinds compiled in, registered before any lookup.
+var statics_done = false;
+fn statics() void {
+ if (statics_done) return;
+ statics_done = true;
+ _ = register(&@import("image.zig").kind, "", null);
+}
+
+pub fn kinds() []const Listed {
+ statics();
+ return listed[0..nlisted];
+}
+
+/// The kind named `name` (`image`), if this process has it.
+pub fn byName(name: []const u8) ?*const Ops {
+ for (kinds()) |*l| if (l.ops != null and std.mem.eql(u8, l.nameOf(), name)) return l.ops;
+ return null;
+}
+
+/// The kind that opens `path`, by its extension (any case).
+pub fn forPath(path: []const u8) ?*const Ops {
+ statics();
+ const dot = std.mem.lastIndexOfScalar(u8, path, '.') orelse return null;
+ if (std.mem.indexOfScalarPos(u8, path, dot, '/') != null) return null;
+ for (exts[0..nexts]) |e| if (std.ascii.eqlIgnoreCase(e.ext, path[dot..])) return e.ops;
+ return null;
+}
+
+/// A kind's word `name`, the tail's linear scan.
+pub fn word(name: []const u8) ?Word {
+ statics();
+ for (words[0..nwords]) |w| if (std.mem.eql(u8, std.mem.span(w.w.name), name)) return w;
+ return null;
+}
+
+pub fn wordsOf() []const Word {
+ statics();
+ return words[0..nwords];
+}
+
+/// The kind of the word whose leader path is `keys`, or whether one has
+/// a path `keys` begins (`prefix`).
+pub fn leader(keys: []const u8) union(enum) { none, prefix, word: Word } {
+ statics();
+ var begun = false;
+ for (words[0..nwords]) |w| {
+ if (w.w.leader == null) continue;
+ const path = std.mem.span(w.w.leader);
+ if (std.mem.eql(u8, path, keys)) return .{ .word = w };
+ if (std.mem.startsWith(u8, path, keys)) begun = true;
+ }
+ return if (begun) .prefix else .none;
+}
+
+fn headWords(ops: *const Ops) []const c.pa_word {
+ return if (ops.head.nwords == 0 or ops.head.words == null) &.{} else ops.head.words[0..ops.head.nwords];
+}
+
+fn extsOf(ops: *const Ops) []const u8 {
+ return if (ops.head.exts == null) "" else std.mem.span(ops.head.exts);
+}
+
+pub fn headName(ops: *const Ops) []const u8 {
+ return std.mem.sliceTo(&ops.head.name, 0);
+}
+
+/// `ops` taken in, its words and extensions with it, or refused in
+/// words: a head this pardes cannot read, another ABI, no paint, a name,
+/// a word, a leader path or an extension already someone's, or its init
+/// failing. Listed either way (/addons), the refusal's words returned.
+/// `taken(word)` says whether the core has a word of that name, and
+/// `leader_taken(path)` a leader path that path begins or is begun by.
+pub fn register(ops: *const Ops, path: []const u8, lib: ?*anyopaque) ?[]const u8 {
+ if (nlisted == max_kinds) return "refused: no room for another kind";
+ const l = &listed[nlisted];
+ l.* = .{ .lib = lib };
+ l.path.set(path);
+ const why = check(ops, l) orelse {
+ l.name = ops.head.name;
+ l.name[15] = 0;
+ l.version = ops.head.version;
+ l.abi = ops.head.abi;
+ if (ops.init) |init| if (init(&api) != 0) {
+ l.why.set("refused: its init failed");
+ nlisted += 1;
+ return l.why.slice();
+ };
+ l.ops = ops;
+ for (headWords(ops)) |*w| {
+ words[nwords] = .{ .ops = ops, .w = w };
+ nwords += 1;
+ }
+ var it = std.mem.tokenizeScalar(u8, extsOf(ops), ' ');
+ while (it.next()) |ext| {
+ exts[nexts] = .{ .ext = ext, .ops = ops };
+ nexts += 1;
+ }
+ l.why.set(if (lib == null) "static" else "loaded");
+ nlisted += 1;
+ return null;
+ };
+ if (ops.head.size >= @sizeOf(c.pa_head)) {
+ l.name = ops.head.name;
+ l.name[15] = 0;
+ l.version = ops.head.version;
+ l.abi = ops.head.abi;
+ }
+ l.why.set(why);
+ nlisted += 1;
+ return l.why.slice();
+}
+
+fn check(ops: *const Ops, l: *Listed) ?[]const u8 {
+ const h = &ops.head;
+ if (h.size < @sizeOf(c.pa_head)) return "refused: its head is too short for this pardes";
+ if (h.abi >> 16 != abi_major) return l.why.print("refused: wants abi {d}, this pardes speaks {d}", .{ h.abi >> 16, abi_major });
+ if (ops.paint == null) return "refused: it has no paint";
+ const name = std.mem.sliceTo(&h.name, 0);
+ if (name.len == 0 or name.len > 15) return "refused: its name is empty or longer than 15 bytes";
+ for (name) |ch| if (!std.ascii.isAlphanumeric(ch) and ch != '_' and ch != '-') return "refused: its name is not a word";
+ if (byName(name) != null) return l.why.print("refused: kind {s} is here already", .{name});
+ if (h.nwords > 0 and ops.ctl == null) return "refused: it has words and no ctl";
+ if ((ops.job_run == null) != (ops.job_done == null)) return "refused: a job needs job_run and job_done";
+ if (nwords + h.nwords > words.len) return "refused: no room for its words";
+ for (headWords(ops), 0..) |*w, i| {
+ if (w.size < @sizeOf(c.pa_word) or w.name == null) return "refused: a word it brings is malformed";
+ const wn = std.mem.span(w.name);
+ if (wn.len == 0 or wn.len > 32) return "refused: a word's name is empty or longer than 32 bytes";
+ if (coreWord(wn)) return l.why.print("refused: word {s} is the core's", .{wn});
+ if (word(wn)) |other| return l.why.print("refused: word {s} is {s}'s", .{ wn, headName(other.ops) });
+ for (headWords(ops)[0..i]) |*before| if (std.mem.eql(u8, std.mem.span(before.name), wn)) return l.why.print("refused: word {s} twice", .{wn});
+ if (w.leader != null) {
+ const keys = std.mem.span(w.leader);
+ if (keys.len == 0 or coreLeader(keys) or leader(keys) != .none) return l.why.print("refused: leader SPC {s} is taken", .{keys});
+ for (words[0..nwords]) |o| if (o.w.leader != null and std.mem.startsWith(u8, keys, std.mem.span(o.w.leader))) return l.why.print("refused: leader SPC {s} is taken", .{keys});
+ }
+ }
+ var it = std.mem.tokenizeScalar(u8, extsOf(ops), ' ');
+ var n: usize = 0;
+ while (it.next()) |ext| : (n += 1) {
+ if (ext.len < 2 or ext[0] != '.') return l.why.print("refused: extension {s} has no dot", .{ext});
+ if (forPath(ext)) |other| return l.why.print("refused: extension {s} is {s}'s", .{ ext, headName(other) });
+ }
+ if (nexts + n > exts.len) return "refused: no room for its extensions";
+ return null;
+}
+
+fn coreWord(name: []const u8) bool {
+ const builtins = @import("builtins.zig");
+ return std.meta.stringToEnum(builtins.registry.Builtin(), name) != null or builtins.absentWhy(name) != null;
+}
+
+fn coreLeader(keys: []const u8) bool {
+ return @import("keys.zig").leaderTaken(keys);
+}
+
+/// `name` out of the list, its words and extensions with it: its
+/// library's handle, to close, or null when no such kind is loaded.
+/// The caller sees no pane of it is open.
+pub fn unregister(name: []const u8) ?Listed {
+ statics();
+ const at = for (listed[0..nlisted], 0..) |*l, i| {
+ if (l.ops != null and std.mem.eql(u8, l.nameOf(), name)) break i;
+ } else return null;
+ const gone = listed[at];
+ const ops = gone.ops.?;
+ var n: usize = 0;
+ for (words[0..nwords]) |w| if (w.ops != ops) {
+ words[n] = w;
+ n += 1;
+ };
+ nwords = n;
+ n = 0;
+ for (exts[0..nexts]) |e| if (e.ops != ops) {
+ exts[n] = e;
+ n += 1;
+ };
+ nexts = n;
+ std.mem.copyForwards(Listed, listed[at .. nlisted - 1], listed[at + 1 .. nlisted]);
+ nlisted -= 1;
+ return gone;
+}
+
+/// An addon at `path` that brought no kind, listed with why.
+pub fn note(path: []const u8, why: []const u8) void {
+ statics();
+ if (nlisted == max_kinds) return;
+ listed[nlisted] = .{};
+ listed[nlisted].path.set(path);
+ listed[nlisted].why.set(why);
+ nlisted += 1;
+}
+
+/// The refused ones forgotten, as a load of the same path tries again.
+pub fn forgetRefused(path: []const u8) void {
+ var n: usize = 0;
+ for (listed[0..nlisted]) |l| if (l.ops != null or !std.mem.eql(u8, l.path.slice(), path)) {
+ listed[n] = l;
+ n += 1;
+ };
+ nlisted = n;
+}
+
+/// /addons: `name version abi state [path]` a line.
+pub fn list(out: *std.ArrayList(u8), gpa: std.mem.Allocator) !void {
+ for (kinds()) |*l| {
+ const name = if (l.nameOf().len > 0) l.nameOf() else std.fs.path.basename(l.path.slice());
+ try out.print(gpa, "{s} {d} {d}.{d} {s}", .{ name, l.version, l.abi >> 16, l.abi & 0xffff, l.why.slice() });
+ if (l.path.len > 0) try out.print(gpa, " {s}", .{l.path.slice()});
+ try out.append(gpa, '\n');
+ }
+}
+
+// ---- a pane of a kind ----
+
+/// What the core keeps of a pane of a kind, round the kind's own state.
+/// The walker sees none of it (it is the kind's): a dump writes its
+/// record by hand (`dumpWrite`), a digest takes its name and path, and a
+/// rollback copy leaves it be, as a terminal's emulator.
+pub const Slot = struct {
+ /// Null: a placeholder, its kind not here (a dump's, loaded without
+ /// it), which keeps its record for the day it comes.
+ ops: ?*const Ops,
+ st: ?*anyopaque = null,
+ /// What the slot's memory comes from; the kind's allocations are its
+ /// arena's, freed at the close.
+ gpa: std.mem.Allocator,
+ arena: std.heap.ArenaAllocator,
+ name: [16]u8 = @splat(0),
+ version: u32 = 0,
+ path: []u8 = &.{},
+ /// Petscii, Palette and Ascii: how a frontend shows its placements.
+ art: Placement.Art = .{},
+ /// When `tick` asked to be called next; 0, never.
+ next_tick: u64 = 0,
+ jobs: [4]?*Job = @splat(null),
+ tokens: u32 = 0,
+ /// A placeholder's: the kind's record and its `where`, kept whole.
+ record: ?[]u8 = null,
+ where_text: Buf(32) = .{},
+ /// An error the kind said while opening: the open refused.
+ refused: Buf(96) = .{},
+
+ pub fn nameOf(s: *const Slot) []const u8 {
+ return std.mem.sliceTo(&s.name, 0);
+ }
+
+ pub fn is(s: *const Slot, name: []const u8) bool {
+ return std.mem.eql(u8, s.nameOf(), name);
+ }
+
+ /// The core's words of a pane: a kind's with keys is raw, as a raw
+ /// terminal is.
+ pub fn takesKeys(s: *const Slot) bool {
+ return if (s.ops) |o| o.key != null else false;
+ }
+
+ pub fn takesMouse(s: *const Slot) bool {
+ return if (s.ops) |o| o.mouse != null else false;
+ }
+
+ pub fn digest(s: *const Slot, h: *walk.Hasher) void {
+ h.update(s.nameOf());
+ h.update(s.path);
+ h.update(std.mem.asBytes(&s.art));
+ h.update(&.{@intFromBool(s.ops != null)});
+ }
+
+ /// What a dump keeps of it: the kind, its path, its place, the art
+ /// bytes, and the kind's own record when it has one.
+ const Record = struct {
+ name: []const u8 = "",
+ version: u32 = 0,
+ path: []const u8 = "",
+ where: []const u8 = "",
+ art: Placement.Art = .{},
+ record: ?[]const u8 = null,
+ };
+
+ pub fn dumpWrite(s: *const Slot, gpa: std.mem.Allocator, w: *std.Io.Writer) !void {
+ var place: [32]u8 = undefined;
+ var r: Record = .{ .name = s.nameOf(), .version = s.version, .path = s.path, .art = s.art, .record = s.record, .where = s.where_text.slice() };
+ var owned: ?[]u8 = null;
+ defer if (owned) |o| gpa.free(o);
+ if (s.ops) |ops| {
+ const prev = enter(null, 0, @constCast(s));
+ defer leave(prev);
+ if (ops.where) |f| r.where = place[0..@min(place.len, f(s.st, &place, place.len))];
+ if (ops.dump) |f| {
+ var cap: usize = 64 << 10;
+ while (true) {
+ const buf = try gpa.alloc(u8, cap);
+ const n = f(s.st, buf.ptr, @intCast(cap));
+ if (n <= cap) {
+ owned = buf;
+ r.record = buf[0..n];
+ break;
+ }
+ gpa.free(buf);
+ cap = n;
+ }
+ }
+ }
+ const bytes = try walk.save(Record, gpa, &r);
+ defer gpa.free(bytes);
+ try w.writeAll(bytes);
+ }
+
+ pub fn dumpFree(s: *Slot, gpa: std.mem.Allocator) void {
+ _ = gpa;
+ s.free();
+ }
+
+ /// The pane back from its record: through its kind's `open` and
+ /// `load` (or `address` with its place) when this process has it,
+ /// else a placeholder holding the record.
+ pub fn dumpRead(out: *Slot, gpa: std.mem.Allocator, bytes: []const u8) !void {
+ var arena: std.heap.ArenaAllocator = .init(gpa);
+ defer arena.deinit();
+ const r = try walk.load(Record, arena.allocator(), bytes, null);
+ out.* = .{ .ops = null, .gpa = gpa, .arena = .init(gpa), .version = r.version, .art = r.art };
+ errdefer out.free();
+ @memcpy(out.name[0..@min(15, r.name.len)], r.name[0..@min(15, r.name.len)]);
+ out.path = try gpa.dupe(u8, r.path);
+ out.where_text.set(r.where);
+ if (r.record) |rec| out.record = try gpa.dupe(u8, rec);
+ if (byName(out.nameOf())) |ops| reopen(null, 0, out, ops);
+ }
+
+ fn free(s: *Slot) void {
+ for (&s.jobs) |*j| if (j.*) |job| {
+ job.wait();
+ job.destroy();
+ j.* = null;
+ };
+ s.arena.deinit();
+ s.gpa.free(s.path);
+ if (s.record) |r| s.gpa.free(r);
+ s.* = undefined;
+ }
+};
+
+/// A placeholder made whole by its kind: `open` from its path, then
+/// `load` with its record, or `address` with its place. A refused load
+/// keeps it a placeholder, its record kept.
+fn reopen(p: ?*Pardes, id: usize, s: *Slot, ops: *const Ops) void {
+ const prev = enter(p, id, s);
+ defer leave(prev);
+ const path_z = s.arena.allocator().dupeSentinel(u8, s.path, 0) catch return;
+ current.?.opening = true;
+ const st = if (ops.open) |f| f(if (s.path.len > 0) path_z.ptr else null, null, 0) else null;
+ current.?.opening = false;
+ if (s.refused.len > 0) {
+ if (ops.close) |f| f(st);
+ return;
+ }
+ if (s.record) |rec| if (ops.load) |f| if (f(st, rec.ptr, @intCast(rec.len), s.version) != 0) {
+ if (ops.close) |cl| cl(st);
+ s.refused.set("its load refused the record");
+ return;
+ };
+ if (s.record == null and s.where_text.len > 0) if (ops.address) |f| {
+ _ = f(st, s.where_text.slice().ptr, @intCast(s.where_text.len));
+ };
+ s.ops = ops;
+ s.st = st;
+ s.version = ops.head.version;
+ if (s.record) |r| s.gpa.free(r);
+ s.record = null;
+}
+
+/// The panes of kind `name` that waited for it (placeholders), opened.
+pub fn reopenWaiting(p: *Pardes, name: []const u8) usize {
+ const ops = byName(name) orelse return 0;
+ var n: usize = 0;
+ for (p.panes, 0..) |slot, id| if (slot) |pane| if (pane.addon) |s| if (s.ops == null and s.is(name)) {
+ s.refused = .{};
+ reopen(p, id, s, ops);
+ if (s.ops != null) n += 1;
+ };
+ return n;
+}
+
+/// The panes of kind `name`, closed into placeholders (their records
+/// kept by the kind's `dump`), so the kind can go.
+pub fn makeWaiting(p: *Pardes, name: []const u8) void {
+ for (p.panes, 0..) |slot, id| if (slot) |pane| if (pane.addon) |s| if (s.ops != null and s.is(name)) {
+ const ops = s.ops.?;
+ const prev = enter(p, id, s);
+ defer leave(prev);
+ var place: [32]u8 = undefined;
+ if (ops.where) |f| s.where_text.set(place[0..@min(place.len, f(s.st, &place, place.len))]);
+ if (ops.dump) |f| keep: {
+ var cap: usize = 64 << 10;
+ while (true) {
+ const buf = s.gpa.alloc(u8, cap) catch break :keep;
+ const n = f(s.st, buf.ptr, @intCast(cap));
+ if (n <= cap) {
+ s.record = s.gpa.realloc(buf, n) catch buf[0..n];
+ break;
+ }
+ s.gpa.free(buf);
+ cap = n;
+ }
+ }
+ for (&s.jobs) |*j| if (j.*) |job| {
+ job.wait();
+ job.destroy();
+ j.* = null;
+ };
+ if (ops.close) |f| f(s.st);
+ _ = s.arena.reset(.free_all);
+ s.st = null;
+ s.ops = null;
+ s.next_tick = 0;
+ };
+}
+
+pub fn openPanes(p: *const Pardes, name: []const u8) usize {
+ var n: usize = 0;
+ for (p.panes) |slot| if (slot) |pane| if (pane.addon) |s| if (s.ops != null and s.is(name)) {
+ n += 1;
+ };
+ return n;
+}
+
+/// A new pane of kind `ops` in slot `id`, showing `path` (null for one a
+/// word opened) from `bytes`: made whatever the kind says, with what it
+/// refused in `slot.refused` for the caller to say.
+pub fn open(p: *Pardes, id: usize, ops: *const Ops, path: ?[]const u8, bytes: ?[]const u8) !*Pane {
+ const gpa = p.image_gpa;
+ const s = try gpa.create(Slot);
+ s.* = .{ .ops = ops, .gpa = gpa, .arena = .init(gpa), .version = ops.head.version, .name = ops.head.name };
+ s.name[15] = 0;
+ errdefer {
+ s.free();
+ gpa.destroy(s);
+ }
+ s.path = try gpa.dupe(u8, path orelse "");
+ const pane = try p.newDocPane(id);
+ pane.addon = s;
+ const prev = enter(p, id, s);
+ defer leave(prev);
+ const path_z = try s.arena.allocator().dupeSentinel(u8, s.path, 0);
+ current.?.opening = true;
+ if (ops.open) |f| s.st = f(if (path != null) path_z.ptr else null, if (bytes) |b| b.ptr else null, if (bytes) |b| b.len else 0);
+ return pane;
+}
+
+/// `open` of the file at `path`, read here (a file that cannot be read
+/// is no bytes: its kind may refuse it). The slot stays ours across the
+/// read: another request may make a pane meanwhile.
+pub fn openFile(p: *Pardes, id: usize, ops: *const Ops, path: []const u8) !*Pane {
+ p.reserved_slots[id] = true;
+ const bytes: ?[]u8 = @import("fs.zig").read(p, path) catch null;
+ p.reserved_slots[id] = false;
+ defer if (bytes) |b| p.gpa.free(b);
+ return open(p, id, ops, path, bytes orelse "");
+}
+
+/// Its kind's close, then everything it had.
+pub fn close(p: *Pardes, pane: *Pane) void {
+ const s = pane.addon orelse return;
+ if (s.ops) |ops| if (ops.close) |f| {
+ const prev = enter(p, 0, s);
+ defer leave(prev);
+ f(s.st);
+ };
+ const gpa = s.gpa;
+ s.free();
+ gpa.destroy(s);
+ pane.addon = null;
+}
+
+/// The pane's body painted over the `cols` x `rows` cells at (x, y):
+/// its cells into `s`, its placements after the frame's others. A
+/// placeholder says what it waits for.
+pub fn draw(p: *Pardes, s: *surface.Surface, arena: std.mem.Allocator, pane: *Pane, id: usize, x: u16, y: u16, cols: u16, rows: u16) void {
+ const slot = pane.addon orelse return;
+ if (cols == 0 or rows == 0) return;
+ const th = p.theme();
+ const fg: surface.Color = if (th.fg) |f| .{ .rgb = f } else .default;
+ const bg: surface.Color = if (th.bg) |b| .{ .rgb = b } else .default;
+ const ops = slot.ops orelse {
+ var line: [160]u8 = undefined;
+ const why = if (slot.refused.len > 0) slot.refused.slice() else "Addon load <path>";
+ const text = std.fmt.bufPrint(&line, "addon {s} {d} is not loaded: {s}", .{ slot.nameOf(), slot.version, why }) catch &line;
+ _ = s.print(x, y, cols, text, .{ .fg = fg, .bg = bg });
+ return;
+ };
+ const cells = arena.alloc(c.pa_cell, @as(usize, cols) * rows) catch return;
+ @memset(cells, std.mem.zeroInit(c.pa_cell, .{ .fg = c.PA_DEFAULT, .bg = c.PA_DEFAULT, .flags = c.PA_UNPAINTED }));
+ var places: [16]c.pa_placement = undefined;
+ var out: c.pa_paint = std.mem.zeroInit(c.pa_paint, .{ .placements = &places, .cap = places.len });
+ const win = window(p, slot, pane, cells.ptr, cols, rows);
+ {
+ const prev = enter(p, id, slot);
+ defer leave(prev);
+ current.?.painting = true;
+ ops.paint.?(slot.st, &win, &out);
+ }
+ for (0..rows) |r| for (0..cols) |col| {
+ const cell = &cells[r * cols + col];
+ if (cell.flags & c.PA_UNPAINTED != 0) continue;
+ const len = @min(cell.len, 7);
+ s.set(x + @as(u16, @intCast(col)), y + @as(u16, @intCast(r)), if (len == 0) " " else cell.text[0..len], styleOf(cell, fg, bg));
+ };
+ for (places[0..@min(out.n, places.len)]) |pl| {
+ if (pl.rgba == null or pl.w == 0 or pl.h == 0) continue;
+ const dx = @min(pl.dst.x, cols);
+ const dy = @min(pl.dst.y, rows);
+ _ = p.appendPlacement(.{
+ .pane = @intCast(id),
+ .raster = .{ .ptr = pl.rgba, .w = pl.w, .h = pl.h, .stride = pl.stride },
+ .src = .{ .x = pl.src.x, .y = pl.src.y, .w = pl.src.w, .h = pl.src.h },
+ .dst = .{ .x = x + dx, .y = y + dy, .w = @min(pl.dst.w, cols - dx), .h = @min(pl.dst.h, rows - dy) },
+ .at = if (pl.at.w == 0) null else .{ .x = pl.at.x, .y = pl.at.y, .w = pl.at.w, .h = pl.at.h },
+ .key = Placement.keyOf(pane.serial, @truncate(pl.key >> 32), @truncate(pl.key)),
+ .art = slot.art,
+ });
+ }
+}
+
+fn window(p: *const Pardes, slot: *const Slot, pane: *const Pane, cells: [*]c.pa_cell, cols: u16, rows: u16) c.pa_window {
+ const px = if (comptime pardes.pdf_enabled) p.cell_pixels else struct { w: u16 = 8, h: u16 = 16 }{};
+ return std.mem.zeroInit(c.pa_window, .{
+ .cells = cells,
+ .stride = cols,
+ .rows = rows,
+ .cols = cols,
+ .cell_w = px.w,
+ .cell_h = px.h,
+ .focused = @intFromBool(p.panes[p.active] == pane),
+ .glyphs = @intFromBool(slot.art.glyph or !p.frontend.native_images),
+ .palette = @intFromEnum(slot.art.palette),
+ .ascii = @intFromBool(slot.art.ascii),
+ });
+}
+
+fn styleOf(cell: *const c.pa_cell, fg: surface.Color, bg: surface.Color) surface.CellStyle {
+ const a = cell.attrs;
+ return .{
+ .fg = colorOf(cell.fg, fg),
+ .bg = colorOf(cell.bg, bg),
+ .bold = a & c.PA_BOLD != 0,
+ .dim = a & c.PA_DIM != 0,
+ .italic = a & c.PA_ITALIC != 0,
+ .reverse = a & c.PA_REVERSE != 0,
+ .ul = if (a & c.PA_UNDERLINE != 0) .single else .off,
+ };
+}
+
+fn colorOf(v: u32, default: surface.Color) surface.Color {
+ return switch (v & 0xff000000) {
+ c.PA_DEFAULT => default,
+ 0x02000000 => .{ .index = @truncate(v) },
+ else => .{ .rgb = .{ @truncate(v >> 16), @truncate(v >> 8), @truncate(v) } },
+ };
+}
+
+/// The start of its tag: what its kind's paint says over no cells, else
+/// its path (a word's pane: the kind's name).
+pub fn prefix(p: *const Pardes, arena: std.mem.Allocator, pane: *const Pane) ![]const u8 {
+ const slot = pane.addon.?;
+ const fallback = if (slot.path.len > 0) slot.path else slot.nameOf();
+ const ops = slot.ops orelse return fallback;
+ var out: c.pa_paint = std.mem.zeroes(c.pa_paint);
+ const win = window(p, slot, pane, undefined, 0, 0);
+ {
+ const prev = enter(null, 0, slot);
+ defer leave(prev);
+ current.?.painting = true;
+ ops.paint.?(slot.st, &win, &out);
+ }
+ if (out.prefix_len == 0) return fallback;
+ return arena.dupe(u8, out.prefix[0..@min(out.prefix_len, out.prefix.len)]);
+}
+
+/// A key at a pane whose kind takes keys: whether it did. A replica's
+/// speculation leaves it to the authority (the kind's state is not in
+/// the rollback copy).
+pub fn key(p: *Pardes, id: usize, k: pardes.Key) bool {
+ const slot = (p.panes[id] orelse return false).addon orelse return false;
+ const f = (slot.ops orelse return false).key orelse return false;
+ if (authorityOnly("a key into a kind's pane")) return true;
+ const pk: c.pa_key = .{ .cp = k.cp, .ctrl = @intFromBool(k.ctrl), .alt = @intFromBool(k.alt), .shift = @intFromBool(k.shift), .pad = 0 };
+ const prev = enter(p, id, slot);
+ defer leave(prev);
+ return f(slot.st, &pk) != 0;
+}
+
+/// The pointer at (col, row) of its body.
+pub fn mouse(p: *Pardes, id: usize, m: pardes.Mouse, col: u16, row: u16) bool {
+ const slot = (p.panes[id] orelse return false).addon orelse return false;
+ const f = (slot.ops orelse return false).mouse orelse return false;
+ if (authorityOnly("the mouse in a kind's pane")) return true;
+ const pm: c.pa_mouse = .{
+ .button = switch (m.button) {
+ .left => c.PA_LEFT,
+ .middle => c.PA_MIDDLE,
+ .right => c.PA_RIGHT,
+ .wheel_up => c.PA_WHEEL_UP,
+ .wheel_down => c.PA_WHEEL_DOWN,
+ else => 255,
+ },
+ .action = switch (m.kind) {
+ .press => c.PA_PRESS,
+ .release => c.PA_RELEASE,
+ .motion => c.PA_MOTION,
+ .drag => c.PA_DRAG,
+ },
+ .ctrl = @intFromBool(m.ctrl),
+ .shift = @intFromBool(m.shift),
+ .alt = @intFromBool(m.alt),
+ .pad = 0,
+ .col = col,
+ .row = row,
+ };
+ const prev = enter(p, id, slot);
+ defer leave(prev);
+ return f(slot.st, &pm) != 0;
+}
+
+/// A step of the session's clock: each kind whose time has come ticks,
+/// and each job's answer lands.
+pub fn step(p: *Pardes) void {
+ if (tape.speculating()) return;
+ const now = p.clock.stepped_ns;
+ for (p.panes, 0..) |pslot, id| if (pslot) |pane| if (pane.addon) |slot| {
+ const ops = slot.ops orelse continue;
+ for (&slot.jobs) |*j| if (j.*) |job| if (job.done.load(.acquire)) {
+ j.* = null;
+ if (job.thread) |t| t.join();
+ const prev = enter(p, id, slot);
+ ops.job_done.?(slot.st, job.token, job.out.ptr, @intCast(job.out.len));
+ leave(prev);
+ job.destroy();
+ p.needs_frame = true;
+ };
+ if (slot.next_tick != 0 and now >= slot.next_tick) if (ops.tick) |f| {
+ const prev = enter(p, id, slot);
+ slot.next_tick = f(slot.st, now);
+ leave(prev);
+ p.needs_frame = true;
+ };
+ };
+}
+
+/// When the kinds next want a step: `0` a frame from now (a job under
+/// way), a time, or null.
+pub fn wake(p: *const Pardes) ?u64 {
+ var soonest: ?u64 = null;
+ for (p.panes) |pslot| if (pslot) |pane| if (pane.addon) |slot| {
+ for (slot.jobs) |j| if (j != null) return 0;
+ if (slot.next_tick != 0) soonest = @min(soonest orelse slot.next_tick, slot.next_tick);
+ };
+ return soonest;
+}
+
+/// The pane's first tick, asked of a kind that has `tick` as it opens.
+pub fn startTicking(p: *const Pardes, pane: *Pane) void {
+ const slot = pane.addon orelse return;
+ const ops = slot.ops orelse return;
+ if (ops.tick != null and slot.next_tick == 0) slot.next_tick = @max(1, p.clock.stepped_ns);
+}
+
+/// The pane's body as text (its 9P body), from the kind's `body`.
+pub fn body(pane: *const Pane, gpa: std.mem.Allocator) ![]u8 {
+ const slot = pane.addon orelse return gpa.alloc(u8, 0);
+ const ops = slot.ops orelse return gpa.alloc(u8, 0);
+ const len_f = ops.body_len orelse return gpa.alloc(u8, 0);
+ const read = ops.body orelse return gpa.alloc(u8, 0);
+ const prev = enter(null, 0, slot);
+ defer leave(prev);
+ const n: usize = @intCast(@min(len_f(slot.st), 64 << 20));
+ const buf = try gpa.alloc(u8, n);
+ var off: usize = 0;
+ while (off < n) {
+ const got = read(slot.st, off, buf[off..].ptr, @intCast(@min(n - off, 1 << 20)));
+ if (got == 0) break;
+ off += got;
+ }
+ return buf[0..off];
+}
+
+/// Where in it the pane is, as a text its `address` takes back.
+pub fn where(pane: *const Pane, buf: *[32]u8) []const u8 {
+ const slot = pane.addon orelse return "";
+ const ops = slot.ops orelse return slot.where_text.slice();
+ const f = ops.where orelse return "";
+ const prev = enter(null, 0, slot);
+ defer leave(prev);
+ return buf[0..@min(buf.len, f(slot.st, buf, buf.len))];
+}
+
+/// Go to `text` in it; false when the kind has no such place.
+pub fn address(p: *Pardes, id: usize, text: []const u8) bool {
+ const slot = (p.panes[id] orelse return false).addon orelse return false;
+ const f = (slot.ops orelse return false).address orelse return false;
+ if (authorityOnly("an address in a kind's pane")) return true;
+ const prev = enter(p, id, slot);
+ defer leave(prev);
+ return f(slot.st, text.ptr, @intCast(text.len)) != 0;
+}
+
+/// A kind's word as written to its pane: null taken, else why not.
+pub fn ctl(p: *Pardes, id: usize, line: []const u8, reply: *[160]u8) ?[]const u8 {
+ const slot = (p.panes[id] orelse return "no such pane").addon orelse return "not a kind's pane";
+ const f = (slot.ops orelse return "its addon is not loaded").ctl orelse return "its kind takes no words";
+ if (authorityOnly("a kind's word")) return null;
+ const prev = enter(p, id, slot);
+ defer leave(prev);
+ @memset(reply, 0);
+ if (f(slot.st, line.ptr, @intCast(line.len), reply, reply.len) == 0) return null;
+ const said = std.mem.sliceTo(reply, 0);
+ return if (said.len > 0) said else "refused";
+}
+
+/// What its ctl file reads after the core's fields.
+pub fn ctlRead(pane: *const Pane, buf: []u8) []const u8 {
+ const slot = pane.addon orelse return "";
+ const f = (slot.ops orelse return "").ctl_read orelse return "";
+ const prev = enter(null, 0, slot);
+ defer leave(prev);
+ return buf[0..@min(buf.len, f(slot.st, buf.ptr, @intCast(buf.len)))];
+}
+
+fn authorityOnly(comptime why: []const u8) bool {
+ if (!tape.speculating()) return false;
+ tape.poison(why);
+ return true;
+}
+
+// ---- what the core does for a kind (pa_api) ----
+
+/// The pane a call into a kind is for: what `api` acts on.
+const Current = struct {
+ p: ?*Pardes,
+ id: usize,
+ slot: *Slot,
+ painting: bool = false,
+ /// In `open`: an error said refuses the pane.
+ opening: bool = false,
+ look: Buf(256) = .{},
+};
+var current: ?Current = null;
+
+fn enter(p: ?*Pardes, id: usize, slot: *Slot) ?Current {
+ const prev = current;
+ current = .{ .p = p, .id = id, .slot = slot };
+ return prev;
+}
+
+fn leave(prev: ?Current) void {
+ const done = current.?;
+ current = prev;
+ // A Look the kind asked for, once its call is over: it may change
+ // the panes the call was among.
+ if (done.look.len > 0) if (done.p) |p| @import("look.zig").lookAt(p, done.id, done.look.slice());
+}
+
+pub const api: c.pa_api = .{
+ .size = @sizeOf(c.pa_api),
+ .alloc = apiAlloc,
+ .free = apiFree,
+ .job = apiJob,
+ .look = apiLook,
+ .say = apiSay,
+ .text = apiText,
+};
+
+fn apiAlloc(n: usize) callconv(.c) ?*anyopaque {
+ const cur = current orelse return null;
+ const mem = cur.slot.arena.allocator().alignedAlloc(u8, .@"16", @max(n, 1)) catch return null;
+ @memset(mem, 0);
+ return mem.ptr;
+}
+
+fn apiFree(ptr: ?*anyopaque, n: usize) callconv(.c) void {
+ const cur = current orelse return;
+ const at: [*]align(16) u8 = @ptrCast(@alignCast(ptr orelse return));
+ cur.slot.arena.allocator().free(at[0..@max(n, 1)]);
+}
+
+fn apiLook(text: [*c]const u8, n: u32) callconv(.c) void {
+ if (current == null or current.?.painting or text == null) return;
+ current.?.look.set(text[0..n]);
+}
+
+fn apiSay(text: [*c]const u8, n: u32, err: c_int) callconv(.c) void {
+ const cur = current orelse return;
+ if (cur.painting or text == null) return;
+ const said = text[0..n];
+ // Refusing its open: the opener says so, as it says why it could not.
+ if (err != 0 and cur.opening) return cur.slot.refused.set(said);
+ const p = cur.p orelse return;
+ if (err != 0) p.reportFailure(cur.id, said) else p.setMessage(cur.id, said);
+}
+
+fn apiText(name: [*c]const u8, name_len: u32, bytes: [*c]const u8, n: u32) callconv(.c) u32 {
+ const cur = current orelse return 0;
+ if (cur.painting or name == null) return 0;
+ const p = cur.p orelse return 0;
+ const dir = std.fs.path.dirname(cur.slot.path) orelse p.sessionDir();
+ const path = std.fmt.allocPrint(p.gpa, "{s}/{s}", .{ std.mem.trimEnd(u8, dir, "/"), name[0..name_len] }) catch return 0;
+ const content = p.gpa.dupe(u8, if (bytes == null) "" else bytes[0..n]) catch {
+ p.gpa.free(path);
+ return 0;
+ };
+ const free = p.freeSlot() orelse {
+ p.gpa.free(path);
+ p.gpa.free(content);
+ return 0;
+ };
+ const history = pardes.panes.File.History.create(p.gpa) catch {
+ p.gpa.free(path);
+ p.gpa.free(content);
+ return 0;
+ };
+ const pane = p.newDocPane(free) catch {
+ p.gpa.destroy(history);
+ p.gpa.free(path);
+ p.gpa.free(content);
+ return 0;
+ };
+ pane.file = .{ .path = path, .content = content, .history = history };
+ pane.body.cur_pinned = true;
+ @import("exec.zig").placeNew(p, cur.id, cur.id, free, .doc);
+ return pane.serial;
+}
+
+/// A kind's job: its input copied, run on a thread of its own (inline in
+/// a test), its answer kept for `step` to hand back on the loop.
+const Job = struct {
+ token: u32,
+ gpa: std.mem.Allocator,
+ run: *const fn ([*c]const u8, u32, [*c]c.pa_out) callconv(.c) u32,
+ in: []u8,
+ out: []u8 = &.{},
+ thread: ?std.Thread = null,
+ done: std.atomic.Value(bool) = .init(false),
+
+ fn work(j: *Job) void {
+ var out: c.pa_out = .{ .alloc = outAlloc, .ctx = j };
+ const n = j.run(j.in.ptr, @intCast(j.in.len), &out);
+ j.out = j.out[0..@min(n, j.out.len)];
+ j.done.store(true, .release);
+ }
+
+ fn outAlloc(out: [*c]c.pa_out, n: usize) callconv(.c) ?*anyopaque {
+ const j: *Job = @ptrCast(@alignCast(out.*.ctx));
+ if (j.out.len > 0) return null;
+ j.out = j.gpa.alloc(u8, n) catch return null;
+ return j.out.ptr;
+ }
+
+ fn wait(j: *Job) void {
+ if (j.thread) |t| t.join();
+ j.thread = null;
+ }
+
+ fn destroy(j: *Job) void {
+ j.gpa.free(j.in);
+ j.gpa.free(j.out);
+ j.gpa.destroy(j);
+ }
+};
+
+fn apiJob(in: ?*const anyopaque, n: u32) callconv(.c) u32 {
+ const cur = current orelse return 0;
+ if (cur.painting) return 0;
+ const slot = cur.slot;
+ const run = (slot.ops orelse return 0).job_run orelse return 0;
+ const free_at = for (&slot.jobs) |*j| {
+ if (j.* == null) break j;
+ } else return 0;
+ const job = slot.gpa.create(Job) catch return 0;
+ slot.tokens +%= 1;
+ if (slot.tokens == 0) slot.tokens = 1;
+ job.* = .{ .token = slot.tokens, .gpa = slot.gpa, .run = run, .in = slot.gpa.dupe(u8, if (in) |b| @as([*]const u8, @ptrCast(b))[0..n] else "") catch {
+ slot.gpa.destroy(job);
+ return 0;
+ } };
+ if (comptime !builtin.is_test) {
+ if (std.Thread.spawn(.{}, Job.work, .{job})) |t| job.thread = t else |_| job.work();
+ } else job.work();
+ free_at.* = job;
+ return job.token;
+}
+
+// ---- small things ----
+
+pub fn Buf(comptime n: usize) type {
+ return struct {
+ bytes: [n]u8 = undefined,
+ len: std.math.IntFittingRange(0, n) = 0,
+
+ const Self = @This();
+ pub fn set(b: *Self, s: []const u8) void {
+ const k = @min(s.len, n);
+ std.mem.copyForwards(u8, b.bytes[0..k], s[0..k]);
+ b.len = @intCast(k);
+ }
+ pub fn slice(b: *const Self) []const u8 {
+ return b.bytes[0..b.len];
+ }
+ pub fn print(b: *Self, comptime fmt: []const u8, args: anytype) []const u8 {
+ const s = std.fmt.bufPrint(&b.bytes, fmt, args) catch &b.bytes;
+ b.len = @intCast(s.len);
+ return b.slice();
+ }
+ };
+}
+
+test "a kind's head is checked before it is taken" {
+ const Fake = struct {
+ fn paint(_: ?*anyopaque, _: [*c]const c.pa_window, _: [*c]c.pa_paint) callconv(.c) void {}
+ };
+ var ops = std.mem.zeroInit(Ops, .{ .head = std.mem.zeroInit(c.pa_head, .{ .size = @sizeOf(c.pa_head), .abi = abi, .version = 3 }), .paint = Fake.paint });
+ @memcpy(ops.head.name[0..5], "zzzab");
+ var wrong = ops;
+ wrong.head.abi = (abi_major + 1) << 16;
+ @memcpy(wrong.head.name[0..5], "zzzac");
+ try std.testing.expectEqualStrings("refused: wants abi 2, this pardes speaks 1", register(&wrong, "/x/wrong.so", null).?);
+ try std.testing.expect(register(&ops, "", null) == null);
+ try std.testing.expect(byName("zzzab") == &ops);
+ try std.testing.expectEqualStrings("refused: kind zzzab is here already", register(&ops, "", null).?);
+ _ = unregister("zzzab");
+ try std.testing.expect(byName("zzzab") == null);
+ forgetRefused("/x/wrong.so");
+ forgetRefused("");
+ var it: std.ArrayList(u8) = .empty;
+ defer it.deinit(std.testing.allocator);
+ try list(&it, std.testing.allocator);
+ try std.testing.expect(std.mem.indexOf(u8, it.items, "zzza") == null);
+}