summaryrefslogtreecommitdiff
path: root/anim/src/calls.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-10 18:06:30 -0300
committerGabriel Schneider <[email protected]>2026-11-10 19:01:23 -0300
commite63b0624f57472d40af32a006c32cc47d403b822 (patch)
treeb7295da62acd96bc7aba425720eed95605526693 /anim/src/calls.zig
parent318e16181a28725e218121363555580725d6d0d4 (diff)
downloadcomputeranim-e63b0624f57472d40af32a006c32cc47d403b822.tar.gz
computeranim-e63b0624f57472d40af32a006c32cc47d403b822.zip
canim: what the review found; the band as two panels; list and sort by instruction
The first videos were reviewed frame by frame and the catalogue changed with them. A lens is a drawing over the program column and its view over the state column, so the stack keeps six slots, its window on the whole frame. Operands are whole. list and sort are recorded by instruction from main (record --from), so their registers strike, links reach nodes and cells, rows that ran are marked and jumps are drawn. A call's node is a projection of its return address; pins travel and keep their side; a mark covers the bytes that changed, at the element's width; a syscall's result is stored after the kernel returns it and every panel is of one moment; fast passes are veiled; the clock stands still during a step; captions get their reading time and a scene's first step comes by four seconds. Co-Authored-By: Claude Fable 5.2 <[email protected]>
Diffstat (limited to 'anim/src/calls.zig')
-rw-r--r--anim/src/calls.zig139
1 files changed, 110 insertions, 29 deletions
diff --git a/anim/src/calls.zig b/anim/src/calls.zig
index 88bca71..e66da1a 100644
--- a/anim/src/calls.zig
+++ b/anim/src/calls.zig
@@ -13,6 +13,8 @@ const Cursor = cursors.Cursor;
const Recording = @import("Recording.zig");
const context = @import("context.zig");
const Stage = @import("stage.zig").Stage;
+const ties = @import("ties.zig");
+const rows = @import("rows.zig");
const theme = ui.theme;
const time = theme.time;
const Rect = ui.Rect;
@@ -30,80 +32,159 @@ pub const Tree = struct {
focus: bool = false,
pub fn draw(k: *const Tree, f: *sk.Frame, at: anim.Placed) void {
+ k.backtrace(f, at);
const box = k.stage.box(at, .band);
if (box.h < theme.metric.context.tag + 24) return;
- const u = context.at(f, at, box);
+ const u = context.at(f, at, box).faded(at.value(k.stage.drawing));
+ // A relayout moves the band: what is drawn in it stays inside it.
+ u.clip(.{ .x = 0, .y = 0, .w = box.w, .h = box.h });
+ defer u.unclip();
const now = k.cursor.now(at);
const rec = k.cursor.rec;
- const m = struct {
- const radius = 18;
- const level = 44;
- const badge = 24;
- };
- const body = u.panel(box.w, box.h, u.print("calls of {s}", .{k.function}), .{ .focus = k.focus, .note = "each call a node \u{00b7} its result on the shoulder \u{00b7} the frames are the stack's" });
+ const m = metric;
+ const body = u.panel(box.w, box.h, u.print("calls of {s}", .{k.function}), .{ .focus = k.focus, .note = "each call a node \u{00b7} its result on its shoulder" });
const nodes = layout(f.scratch, rec, k.function) catch return;
if (nodes.len == 0) return;
var leaves: f32 = 0;
for (nodes) |n| leaves = @max(leaves, n.x + 1);
- const pitch = @min(4.5 * m.radius, (body.w - 2 * theme.metric.panel.pad_x - 2 * m.radius) / @max(leaves - 1, 1));
- const left = (body.w - (leaves - 1) * pitch) / 2;
- const top = body.y + m.radius + 12;
- var deepest_level: f32 = 1;
- for (nodes) |n| deepest_level = @max(deepest_level, @as(f32, @floatFromInt(n.level)));
- const level_h = @min(m.level, (body.h - 2 * m.radius - 24) / deepest_level);
- // A call: its edge draws from the caller's node, then the node
- // fades in, gold, and the caller's goes from gold to a waiting
- // ring. A return: the badge is struck a little after the card's
- // result, and the node goes from gold to done.
+ // The caller's box left of the root on its level; the leaves spread over the rest.
+ const caller_room = m.caller[0] + 48;
+ const pitch = (body.w - 2 * theme.metric.panel.pad_x - 2 * m.radius - caller_room) / @max(leaves - 1, 1);
+ const left = theme.metric.panel.pad_x + caller_room + m.radius;
+ const top = body.y + m.root;
const since = now.since(.idea, 0);
const returned = now.walking() and rec.depths[now.stops[0]] < rec.depths[now.stops[1]];
const moment = if (now.plan.gait == .sprint or since >= (if (returned) @as(f32, badge_after) else 0)) now.stops[0] else now.stops[1];
const edge = cursors.standard(now.moving(.idea, time.quick, time.quick));
const appears = now.moving(.idea, 0, time.snap);
+ const at_of = struct {
+ fn c(lf: f32, p: f32, tp: f32, n: Node) ui.Vec {
+ return .{ lf + n.x * p, tp + @as(f32, @floatFromInt(n.level)) * metric.level };
+ }
+ }.c;
- // Edges under nodes: the waiting path in vellum.
+ // The caller: gold until the first call, then waiting, ringed; an edge into the root.
+ if (nodes[0].call.parent) |p| {
+ const caller = rec.calls[p];
+ const root_c = at_of(left, pitch, top, nodes[0]);
+ const r: Rect = .{ .x = theme.metric.panel.pad_x, .y = root_c[1] - m.caller[1] / 2, .w = m.caller[0], .h = m.caller[1] };
+ const called = nodes[0].call.enter <= moment;
+ if (nodes[0].call.enter <= now.stops[0]) {
+ const to = ui.Vec{ root_c[0] - m.radius, root_c[1] };
+ const from = ui.Vec{ r.x + r.w, root_c[1] };
+ const live = nodes[0].call.active(moment) or nodes[0].call.enter > moment;
+ u.line(from, if (nodes[0].call.enter > now.stops[1]) sk.math.mix(from, to, edge) else to, if (live) ui.rgb(t.primary) else ui.rgb(theme.color.rule), theme.stroke.line);
+ }
+ if (!called) {
+ u.fill(r, theme.mark(.current).solid);
+ u.label(.mono_bold, theme.size.mono.context, r, .center, rec.name(caller.function), theme.mark(.current).on_solid);
+ } else {
+ u.fill(r, theme.color.page);
+ u.frame(r, t.primary, theme.stroke.line);
+ u.label(.mono, theme.size.mono.context, r, .center, rec.name(caller.function), t.primary);
+ }
+ }
+ // Edges under nodes: the waiting path in primary.
for (nodes) |n| {
const parent = n.parent orelse continue;
if (n.call.enter > now.stops[0]) continue;
- const from = ui.Vec{ left + nodes[parent].x * pitch, top + @as(f32, @floatFromInt(nodes[parent].level)) * level_h };
- var to = ui.Vec{ left + n.x * pitch, top + @as(f32, @floatFromInt(n.level)) * level_h };
+ const from = at_of(left, pitch, top, nodes[parent]);
+ var to = at_of(left, pitch, top, n);
if (n.call.enter > now.stops[1]) to = sk.math.mix(from, to, edge);
const live = n.call.active(moment);
- u.line(from, to, if (live or n.call.enter > moment) ui.rgb(t.primary) else ui.rgb(theme.color.rule), if (live or n.call.enter > moment) theme.stroke.arrow else theme.stroke.line);
+ u.line(from, to, if (live or n.call.enter > moment) ui.rgb(t.primary) else ui.rgb(theme.color.rule), theme.stroke.line);
}
const deepest = deepestActive(nodes, moment);
for (nodes, 0..) |n, i| {
+ const c = at_of(left, pitch, top, n);
+ // Where a projection from its frame's way back (the word its
+ // call pushed, at the call's stack pointer) lands: under it,
+ // there before the node, which comes when it arrives.
+ if (n.call.enter <= now.stops[0]) ties.anchor(u, .{ .node_address = n.call.sp }, .{ .x = c[0] - m.radius, .y = c[1] - m.radius, .w = 2 * m.radius, .h = 2 * m.radius });
if (n.call.enter > moment) continue;
- const c = ui.Vec{ left + n.x * pitch, top + @as(f32, @floatFromInt(n.level)) * level_h };
const v = if (n.call.enter > now.stops[1]) u.faded(appears) else u;
if (deepest == i) {
v.disc(c, m.radius, ui.rgb(theme.mark(.current).solid), null, 0);
} else if (n.call.active(moment)) {
- v.disc(c, m.radius - theme.stroke.arrow / 2, ui.rgb(theme.color.page), ui.rgb(t.primary), theme.stroke.arrow);
+ v.disc(c, m.radius - theme.stroke.line / 2, ui.rgb(theme.color.page), ui.rgb(t.primary), theme.stroke.line);
} else v.disc(c, m.radius, ui.rgb(theme.color.raised), null, 0);
}
// Then the words, so shapes and text each go in one run.
- const size = theme.size.mono.context;
+ const size = theme.size.mono.small;
for (nodes, 0..) |n, i| {
if (n.call.enter > moment) continue;
- const cx = left + n.x * pitch;
- const cy = top + @as(f32, @floatFromInt(n.level)) * level_h;
+ const c = at_of(left, pitch, top, n);
const active = n.call.active(moment);
const words = if (n.call.arg) |arg| u.print("{d}", .{@as(i64, @bitCast(arg))}) else "?";
- const cell: Rect = .{ .x = cx - m.radius, .y = cy - m.radius, .w = 2 * m.radius, .h = 2 * m.radius };
+ const cell: Rect = .{ .x = c[0] - m.radius, .y = c[1] - m.radius, .w = 2 * m.radius, .h = 2 * m.radius };
const v = if (n.call.enter > now.stops[1]) u.faded(appears) else u;
if (deepest == i) {
v.label(.mono_bold, size, cell, .center, words, theme.mark(.current).on_solid);
- } else v.label(.mono, size, cell, .center, words, if (active) t.primary else t.dim);
+ } else v.label(.mono, size, cell, .center, words, t.primary);
if (active) continue;
// Done: what it returned, on its shoulder; struck as it lands.
- const badge: Rect = .{ .x = cx + 10, .y = cy - m.radius - 12, .w = m.badge, .h = m.badge };
+ const badge: Rect = .{ .x = c[0] + m.badge_at[0], .y = c[1] - m.badge_at[1], .w = m.badge, .h = m.badge };
const heat: ui.Heat = if (n.call.exit.? > now.stops[1]) now.heat(0, null, since - badge_after) else .none;
const ink = u.cellWritten(badge, heat, theme.color.page);
if (heat.level < 1) u.frame(badge, t.faint, theme.stroke.rule);
u.label(ink.face, size, badge, .center, u.print("{d}", .{@as(i64, @bitCast(n.call.result))}), if (heat.level >= 1) ink.ink else ui.rgb(t.primary));
}
}
+
+ /// Its view: the backtrace, the waiting path read as rows, newest on
+ /// top, with each call's arguments (`n=4`) and where it is.
+ fn backtrace(k: *const Tree, f: *sk.Frame, at: anim.Placed) void {
+ const box = k.stage.box(at, .view);
+ const cm = theme.metric.context;
+ if (box.h < cm.tag + cm.row) return;
+ const u = context.at(f, at, box).faded(at.value(k.stage.view));
+ u.clip(.{ .x = 0, .y = 0, .w = box.w, .h = box.h });
+ defer u.unclip();
+ const now = k.cursor.now(at);
+ const rec = k.cursor.rec;
+ // A frame is its words on the stack: the view changes with memory.
+ const moment = now.stop(.memory);
+ var buf: [24]context.Frame = undefined;
+ const chain = context.frames(rec, moment, &buf);
+ const room = theme.layout.rowsIn(box.h);
+ const body = u.panel(box.w, box.h, "backtrace", .{ .note = if (chain.len > room) u.print("the calls waiting \u{00b7} newest on top \u{00b7} {d} more", .{chain.len - room}) else "the calls waiting \u{00b7} newest on top" });
+ const open = rec.stack(f.scratch, moment);
+ for (chain[0..@min(chain.len, room)], 0..) |frame, i| {
+ const y = body.y + cm.pad + @as(f32, @floatFromInt(i)) * cm.row;
+ const name = ui.symbol(u, rec.strings.get(frame.pc) orelse u.print("{x}", .{frame.pc}));
+ // The call this frame is, by its place on the chain: its arguments.
+ const call: ?Recording.Call = if (i < open.len) open[open.len - 1 - i] else null;
+ const args = if (call) |c| arguments(u, rec, c) else "";
+ const line = if (i == 0) rec.own[now.marked()] else rec.lineOf(frame.pc) orelse 0;
+ const where = if (line > 0 and (i == 0 or rec.lineOf(frame.pc) != null)) u.print("{s}:{d}", .{ rec.file, line }) else "";
+ rows.callRow(u, y, box.w, i, name, args, where, i == 0);
+ }
+ context.veiled(u, box, now.sprint_veil);
+ }
+};
+
+/// A call's arguments as its backtrace row and its span say them: its
+/// parameter's name and value, `n=4`; "" for one that takes nothing.
+pub fn arguments(u: ui.Ui, rec: *const Recording, c: Recording.Call) []const u8 {
+ const f = for (rec.functions) |fun| {
+ if (std.mem.eql(u8, fun.name, rec.name(c.function))) break fun;
+ } else return "";
+ if (!f.takes) return "";
+ const arg = c.arg orelse return "";
+ const name = if (c.parameter_name) |id| rec.name(id) else f.param;
+ return u.print("{s}={d}", .{ name, @as(i64, @bitCast(arg)) });
+}
+
+/// The tree's measures (design/README.md, `calls`): a disc 48 across,
+/// levels 46 apart, the root 48 under the tag; the result's square of 30
+/// on the shoulder, 12 right of the centre and 42 up; the caller's box.
+const metric = struct {
+ const radius = 24;
+ const level = 46;
+ const root = 48;
+ const badge = 30;
+ const badge_at = [2]f32{ 12, 42 };
+ const caller = [2]f32{ 64, 28 };
};
pub const Node = struct {