diff options
| author | Gabriel Schneider <[email protected]> | 2026-11-06 00:02:06 -0300 |
|---|---|---|
| committer | Gabriel Schneider <[email protected]> | 2026-11-06 01:21:34 -0300 |
| commit | 423440f25b4b23b56162008bba35218d438767fe (patch) | |
| tree | a7b06a88c7a55308e7e906ff49fa264a1fd147cf /src/Kind.zig | |
| parent | 94ca47f225632fefc8f688c0c0822d25d6a5db1e (diff) | |
| download | pardes-423440f25b4b23b56162008bba35218d438767fe.tar.gz pardes-423440f25b4b23b56162008bba35218d438767fe.zip | |
kinds #2, a pane of a kind is one slot and image is a kind compiled in: src/kinds/pardes_addon.h is the kinds' C ABI (the cell, the window a kind paints, placements and the tag prefix it hands back, keys, the mouse, pa_api of six functions over the pane's arena, words, the head and pa_ops of paint and sixteen optional functions), translated once by the build into the core's records, never mirrored; src/Kind.zig is the core's side: the kinds this process has (a registry with the checks a load makes: the head's size and abi major, a paint, a name, words, leaders and extensions none else has), a pane's Slot (the kind's state and arena, its path, the art bytes Petscii, Palette and Ascii set, its tick deadline and jobs) and the addon arm at the sites: Look and the initial file by extension, draw (cells into the grid, placements keyed by serial and the kind's key), the tag prefix from a paint over no cells, nextWake and the step (ticks, jobs' answers landing on the loop), close, Recent, paneDir, /index's kind word; a dump writes a slot by hand (kind name and version, path, where, art, the kind's own record) and loads it through the kind's open and load, or as a placeholder that keeps the record when the kind is not here; image.zig's pane is now a static pa_ops (open refuses what it cannot read, the decode a job whose answer lands at a step instead of a thread polled by draw, one placement fitted by the frontend, its record the file's bytes), Pane.image is Pane.addon, and the three art words act on the slot; no golden changes (images.snap and tagbottomimage.snap pass, the tag prefix and the placement key are the same bytes); tests: the image dump test, the Petscii/Palette/Ascii ctl tests, the image tag-prefix test and fs_namespace's decode test rewritten on the slot (the decode now lands at the step after the open), plus a registry test; gates: core-test 960/960 on both, unit-test 1487/1488 tui and 1531/1532 gui, behaviour-test 244/244, pane-test 171/172, snap all ok, process-test 0 of 37 failed on both
Co-Authored-By: Claude Fable 5.1 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNAtZenFv4weoMD3cge
Diffstat (limited to 'src/Kind.zig')
| -rw-r--r-- | src/Kind.zig | 997 |
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); +} |
