//! 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 header's own sizes (src/kinds/pardes_addon.h's _Static_asserts), seen // from here: the records the core reads are the ones addons are built to. comptime { if (@sizeOf(usize) == 8) for (.{ .{ c.pa_cell, 20 }, .{ c.pa_window, 24 }, .{ c.pa_rect, 16 }, .{ c.pa_cells, 8 }, .{ c.pa_placement, 72 }, .{ c.pa_paint, 120 }, .{ c.pa_key, 8 }, .{ c.pa_mouse, 10 }, .{ c.pa_api, 64 }, .{ c.pa_out, 16 }, .{ c.pa_word, 40 }, .{ c.pa_head, 56 }, .{ c.pa_ops, 192 }, }) |r| if (@sizeOf(r[0]) != r[1]) @compileError(std.fmt.comptimePrint("{s} is {d} bytes, the header says {d}", .{ @typeName(r[0]), @sizeOf(r[0]), r[1] })); } // ---- 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) = .{}, /// The library file's BLAKE3, as it was loaded. hash: ?[32]u8 = null, 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 l.ops != skipping and std.mem.eql(u8, l.nameOf(), name)) return l.ops; return null; } /// The kind a reload replaces, which its successor's checks look past. var skipping: ?*const Ops = 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 (e.ops != skipping and 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 (w.ops != skipping and 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 or w.ops == skipping) 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 { return registerHashed(ops, path, lib, null); } pub fn registerHashed(ops: *const Ops, path: []const u8, lib: ?*anyopaque, hash: ?[32]u8) ?[]const u8 { // The kinds compiled in first: the checks below would list them under // this one's entry. statics(); if (nlisted == max_kinds) return "refused: no room for another kind"; const l = &listed[nlisted]; l.* = .{ .lib = lib, .hash = hash }; 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; addTail(ops); 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 addTail(ops: *const Ops) void { 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; } } fn dropTail(ops: *const Ops) void { 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; } 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.ops != skipping and 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]; dropTail(gone.ops.?); 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: ` /// static|loaded|refused: why` a line (`-` for no path, no hash). pub fn list(p: *const Pardes, 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} {d} {s} ", .{ name, l.version, l.abi >> 16, l.abi & 0xffff, if (l.ops != null) openPanes(p, name) else 0, if (l.path.len > 0) l.path.slice() else "-" }); if (l.hash) |h| try out.print(gpa, "{x}", .{h}) else try out.append(gpa, '-'); try out.print(gpa, " {s}\n", .{l.why.slice()}); } } // ---- 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) = .{}, /// Its words' last values, a `Word arg` line each, which a kind with /// no `dump` is given again when its pane comes back. values: Buf(256) = .{}, 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, values: []const u8 = "", }; 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(), .values = s.values.slice() }; var owned: ?[]u8 = null; defer if (owned) |o| gpa.free(o); if (s.ops) |ops| { const prev = enter(null, 0, @constCast(s), "dump"); 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); out.values.set(r.values); 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, "open"); 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)); }; // ...and its words' last values, a kind with no record of its own. if (s.record == null) if (ops.ctl) |f| { var lines = std.mem.tokenizeScalar(u8, s.values.slice(), '\n'); var reply: [160]u8 = undefined; while (lines.next()) |line| _ = f(st, line.ptr, @intCast(line.len), &reply, reply.len); }; s.ops = ops; s.st = st; s.version = ops.head.version; if (ops.tick != null) s.next_tick = 1; 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; } /// `Addon reload`: the kind `name` replaced by `ops` (a library loaded /// beside the old one), or why not, nothing changed. Everything is /// checked first: its head and collisions (the old kind's own looked /// past), its name the same, and every open pane of the kind opened anew /// in a fresh arena from the old state's `dump` (its `load`, else its /// place and words); only then are the old states closed and the panes /// swapped. A job the old library started is dropped, never handed to /// the new one. The old library's handle comes back in `old_lib`. pub fn replace(p: *Pardes, name: []const u8, ops: *const Ops, lib: *anyopaque, hash: [32]u8, old_lib: *?*anyopaque, why: *Buf(160)) bool { const l = listedNamed(name) orelse return fail(why, "no addon brought kind {s}", .{name}); const old = l.ops.?; var trial: Listed = .{}; skipping = old; const refused = check(ops, &trial); skipping = null; if (refused) |r| return fail(why, "{s}", .{r}); if (!std.mem.eql(u8, headName(ops), name)) return fail(why, "refused: its kind is now {s}, not {s}", .{ headName(ops), name }); if (ops.init) |init| if (init(&api) != 0) return fail(why, "refused: its init failed", .{}); var fresh: [pardes.MAX_PANES]?*Slot = @splat(null); defer for (fresh) |f| if (f) |s| { const gpa = s.gpa; s.free(); gpa.destroy(s); }; for (p.panes, 0..) |pslot, id| if (pslot) |pane| if (pane.addon) |s| if (s.ops == old) { const n = s.gpa.create(Slot) catch return fail(why, "out of memory", .{}); n.* = .{ .ops = null, .gpa = s.gpa, .arena = .init(s.gpa), .name = s.name, .version = s.version, .art = s.art, .values = s.values }; fresh[id] = n; n.path = s.gpa.dupe(u8, s.path) catch return fail(why, "out of memory", .{}); // The old state's record, by the old library. { const prev = enter(p, id, s, "dump"); defer leave(prev); var place: [32]u8 = undefined; if (old.where) |f| n.where_text.set(place[0..@min(place.len, f(s.st, &place, place.len))]); if (old.dump != null and ops.load != null) n.record = dumpOf(s) catch return fail(why, "out of memory", .{}); } reopen(p, id, n, ops); if (n.ops == null) { for (fresh) |f| if (f) |o| closeState(p, o); return fail(why, "refused: a pane of it would not open again: {s}", .{if (n.refused.len > 0) n.refused.slice() else "its load refused the record"}); } }; // Every pane opened: the old states go, the new take their slots. for (p.panes, 0..) |pslot, id| if (pslot) |pane| if (pane.addon) |s| if (fresh[id]) |n| { for (&s.jobs) |*j| if (j.*) |job| { job.wait(); job.destroy(); j.* = null; }; closeState(p, s); s.arena.deinit(); s.arena = n.arena; n.arena = .init(n.gpa); s.st = n.st; s.ops = ops; s.version = n.version; s.next_tick = n.next_tick; n.st = null; n.ops = null; }; dropTail(old); addTail(ops); old_lib.* = l.lib; l.ops = ops; l.lib = lib; l.hash = hash; l.version = ops.head.version; l.abi = ops.head.abi; return true; } fn closeState(p: *Pardes, s: *Slot) void { const ops = s.ops orelse return; const f = ops.close orelse return; const prev = enter(p, 0, s, "close"); defer leave(prev); f(s.st); } fn fail(why: *Buf(160), comptime fmt: []const u8, args: anytype) bool { _ = why.print(fmt, args); return false; } /// The kind's record of a slot's state, in `s.gpa`. fn dumpOf(s: *Slot) ![]u8 { const f = s.ops.?.dump.?; var cap: usize = 64 << 10; while (true) { const buf = try s.gpa.alloc(u8, cap); const n = f(s.st, buf.ptr, @intCast(cap)); if (n <= cap) return s.gpa.realloc(buf, n) catch buf[0..n]; s.gpa.free(buf); cap = n; } } 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; if (ops.tick != null) s.next_tick = 1; const prev = enter(p, id, s, "open"); 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, "close"); 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 "; 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(std.mem.sliceAsBytes(cells), 0); 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, "paint"); 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_PAINTED == 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, "paint"); 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, "key"); 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, "mouse"); 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, "job_done"); 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, "tick"); 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 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, "body"); 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, "where"); 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, "address"); 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, "ctl"); 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, "ctl_read"); 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; } // ---- the Addon word, and the words addons bring ---- pub const AddonOp = enum { load, unload, reload }; fn listedNamed(name: []const u8) ?*Listed { statics(); for (listed[0..nlisted]) |*l| if (l.ops != null and std.mem.eql(u8, l.nameOf(), name)) return l; return null; } /// `Addon load ` (relative to the pane's directory), `Addon unload /// ` (refused while a pane of its kind is open), `Addon reload /// ` (its panes kept through it, as their dumps); bare, the kinds /// this session has. The library is the host's to open: an effect, its /// answer an `addon` event (`landed`). pub fn addonWord(p: *Pardes, id: usize, arg: ?[]const u8) void { const a = std.mem.trim(u8, arg orelse "", " \t"); var said: [256]u8 = undefined; if (a.len == 0) { var w: std.Io.Writer = .fixed(&said); w.writeAll("addons:") catch {}; for (kinds()) |*l| if (l.ops != null) w.print(" {s} {d}{s}", .{ l.nameOf(), l.version, if (l.lib == null) " (compiled in)" else "" }) catch {}; return p.setMessage(id, w.buffered()); } const takes = "Addon takes load , unload or reload "; const sp = std.mem.indexOfAny(u8, a, " \t") orelse return p.reportFailure(id, takes); const op = std.meta.stringToEnum(AddonOp, a[0..sp]) orelse return p.reportFailure(id, takes); const rest = std.mem.trim(u8, a[sp..], " \t"); var target: [pardes.effect_path_cap]u8 = undefined; const what: []const u8 = switch (op) { .load => if (std.fs.path.isAbsolute(rest)) rest else std.fmt.bufPrint(&target, "{s}/{s}", .{ std.mem.trimEnd(u8, if (p.panes[id]) |pane| Pardes.paneDir(pane) else p.sessionDir(), "/"), rest }) catch rest, .unload, .reload => what: { const l = listedNamed(rest) orelse return p.reportFailure(id, std.fmt.bufPrint(&said, "Addon {t}: no addon brought kind {s}", .{ op, rest }) catch takes); if (l.lib == null) return p.reportFailure(id, std.fmt.bufPrint(&said, "Addon {t}: {s} is compiled in", .{ op, rest }) catch takes); const n = openPanes(p, rest); if (op == .unload and n > 0) return p.reportFailure(id, std.fmt.bufPrint(&said, "Addon unload: {d} {s} pane{s} open", .{ n, rest, if (n == 1) " is" else "s are" }) catch takes); break :what rest; }, }; if (what.len > pardes.effect_path_cap) return p.reportFailure(id, "Addon: that path is too long"); p.emit(.{ .addon = .{ .op = op, .pane = @intCast(id), .arg = .from(what) } }); } /// How the host's load, unload or reload went: `text` the kind's name, /// or why not. The panes that waited for that kind open. pub fn landed(p: *Pardes, op: AddonOp, pane: u8, ok: bool, text: []const u8) void { const id = if (pane < p.panes.len and p.panes[pane] != null) pane else p.active; var said: [256]u8 = undefined; if (!ok) return p.reportFailure(id, std.fmt.bufPrint(&said, "Addon {t}: {s}", .{ op, text }) catch "Addon: refused"); if (op == .unload) return p.setMessage(id, std.fmt.bufPrint(&said, "Addon unload: {s} is gone", .{text}) catch "Addon unload"); const n = reopenWaiting(p, text); const version = if (byName(text)) |o| o.head.version else 0; p.setMessage(id, std.fmt.bufPrint(&said, "Addon {t}: {s} {d}{s}", .{ op, text, version, if (n > 0) ", its panes back" else "" }) catch "Addon"); } /// A line whose first word is an addon's: run, and true; false for one /// that is no addon's word. pub fn runLine(p: *Pardes, id: usize, line: []const u8) bool { const end = std.mem.indexOfAny(u8, line, " \t") orelse line.len; const w = word(line[0..end]) orelse return false; runWord(p, id, w, line, std.mem.trim(u8, line[end..], " \t")); return true; } /// Word `w` from pane `id`: one that opens its kind opens a pane of it /// (`arg` its path), any other goes to the pane's kind, which must be /// the word's. pub fn runWord(p: *Pardes, id: usize, w: Word, line: []const u8, arg: []const u8) void { const name = std.mem.span(w.w.name); const kind = headName(w.ops); var said: [256]u8 = undefined; if (w.w.arg == c.PA_ARG_NONE and arg.len > 0) return p.reportFailure(id, std.fmt.bufPrint(&said, "{s} takes no argument", .{name}) catch name); if (w.w.arg == c.PA_ARG_REQUIRED and arg.len == 0) return p.reportFailure(id, std.fmt.bufPrint(&said, "{s} needs an argument", .{name}) catch name); if (w.w.opens != 0) { const free = p.freeSlot() orelse return p.reportError(id, name, error.NoPaneSlots); var path_buf: [4096]u8 = undefined; const path = if (arg.len == 0 or std.fs.path.isAbsolute(arg)) arg else std.fmt.bufPrint(&path_buf, "{s}/{s}", .{ std.mem.trimEnd(u8, if (p.panes[id]) |pane| Pardes.paneDir(pane) else p.sessionDir(), "/"), arg }) catch arg; const made = (if (path.len > 0) openFile(p, free, w.ops, path) else open(p, free, w.ops, null, null)) catch |err| return p.reportError(id, name, err); if (made.addon.?.refused.len > 0) { made.vweight = 0; p.unplaced.set(free); return p.reportFailure(id, std.fmt.bufPrint(&said, "{s}: {s}", .{ name, made.addon.?.refused.slice() }) catch name); } @import("exec.zig").placeNew(p, id, id, free, .doc); return; } const here = if (p.panes[id]) |pane| if (pane.addon) |s| s.ops == w.ops else false else false; if (!here) return p.reportFailure(id, std.fmt.bufPrint(&said, "{s} is a {s} pane's word: run it in one", .{ name, kind }) catch name); var reply: [160]u8 = undefined; if (ctl(p, id, line, &reply)) |why| return p.reportFailure(id, std.fmt.bufPrint(&said, "{s}: {s}", .{ name, why }) catch name); if (arg.len > 0) keepValue(p.panes[id].?.addon.?, name, arg); } /// `Word arg` kept as the word's last value, one line a word. fn keepValue(s: *Slot, name: []const u8, arg: []const u8) void { var next: Buf(256) = .{}; var w: std.Io.Writer = .fixed(&next.bytes); var lines = std.mem.tokenizeScalar(u8, s.values.slice(), '\n'); while (lines.next()) |line| { const head = line[0 .. std.mem.indexOfScalar(u8, line, ' ') orelse line.len]; if (!std.mem.eql(u8, head, name)) w.print("{s}\n", .{line}) catch return; } w.print("{s} {s}\n", .{ name, arg }) catch return; next.len = @intCast(w.buffered().len); s.values = next; } // ---- 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, call: []const u8 = "", 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, comptime call: []const u8) ?Current { const prev = current; current = .{ .p = p, .id = id, .slot = slot, .call = call }; return prev; } /// The call into an addon under way, for a crash record: `in addon /// fake.so, paint`. Null outside one, or in a kind compiled in. pub fn calling(buf: []u8) ?[]const u8 { const cur = current orelse return null; const ops = cur.slot.ops orelse return null; for (listed[0..nlisted]) |*l| if (l.ops == ops) { if (l.lib == null) return null; return std.fmt.bufPrint(buf, "in addon {s}, {s}", .{ std.fs.path.basename(l.path.slice()), cur.call }) catch null; }; return null; } 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, .seed = apiSeed, }; /// What every pane's seed is made from: 0, or `--addon-test`'s `seed N`. pub var seed_base: u64 = 0; fn apiSeed() callconv(.c) u64 { const cur = current orelse return seed_base; const serial: u32 = if (cur.p) |p| (if (p.panes[cur.id]) |pane| pane.serial else 0) else 0; return std.hash.Wyhash.hash(seed_base, std.mem.asBytes(&serial)); } 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); } }; /// A test's jobs (and --addon-test's) run at once, their answers landing /// at the step's end. pub var inline_jobs = builtin.is_test; 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 (!inline_jobs) { 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(""); for (kinds()) |*l| try std.testing.expect(!std.mem.startsWith(u8, l.nameOf(), "zzza")); }