summaryrefslogtreecommitdiff
path: root/anim/src/regroup.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-12 01:44:59 -0300
committerGabriel Schneider <[email protected]>2026-11-12 03:17:32 -0300
commitbf0dfa135319f8c7ca49eace4d1f81152ebfd23e (patch)
tree9c80ade769dc9a741c9d00f63770d34dc1769ced /anim/src/regroup.zig
parentaefde257db6e7cf683b923498c0d471885ab67a9 (diff)
downloadcomputeranim-bf0dfa135319f8c7ca49eace4d1f81152ebfd23e.tar.gz
computeranim-bf0dfa135319f8c7ca49eace4d1f81152ebfd23e.zip
canim: the introduction, three chapters
From the user: a first-principles showcase that builds the views. I, memory: the stack's bytes, words read low byte first, the address space to true scale with each cluster enlarged and every band's addresses and size, the bytes tied to their place, ink and chains. II, the stack: the words become the stack panel, a real push, the return address aimed at the row it returns to, rbp and the frame, the registers. III, code: an instruction's bytes decoded into one listing of lines and addresses, then two columns, then the working frame assembled and the map. Recorded from main's call of reverse with record --until. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
Diffstat (limited to 'anim/src/regroup.zig')
-rw-r--r--anim/src/regroup.zig52
1 files changed, 36 insertions, 16 deletions
diff --git a/anim/src/regroup.zig b/anim/src/regroup.zig
index 431abd8..c9f618a 100644
--- a/anim/src/regroup.zig
+++ b/anim/src/regroup.zig
@@ -92,7 +92,8 @@ pub const Words = struct {
}
/// The return address the newest frame has, and the first word that
- /// points into the heap, into the stack, and the return address, top down.
+ /// points into the heap (or, with none, the first other address), into
+ /// the stack, and the return address, top down.
pub fn pick(rec: *const Recording, moment: u64) struct { walked: usize, three: [3]usize } {
const m = rec.moment(moment);
const rsp = rec.register(moment, "rsp");
@@ -109,12 +110,17 @@ pub const Words = struct {
const values = read(rec, moment);
var heap: ?usize = null;
var stack: ?usize = null;
+ var other: ?usize = null;
for (values.words, 0..) |v, i| switch (rows.regionOf(m, v)) {
.heap => heap = heap orelse i,
.stack => stack = stack orelse i,
- else => {},
+ .none => {},
+ else => if (i != walked) {
+ other = other orelse i;
+ },
};
- var three = [3]usize{ heap orelse 0, stack orelse 1, walked };
+ // With no heap word in the 128 bytes, the first other address that is not the walked one.
+ var three = [3]usize{ heap orelse other orelse 1, stack orelse 2, walked };
std.mem.sort(usize, &three, {}, std.sort.asc(usize));
return .{ .walked = walked, .three = three };
}
@@ -162,11 +168,11 @@ pub const Words = struct {
const data = read(w.rec, w.at);
const m = w.rec.moment(w.at);
// The header (mock 29), with the first row; gone as the dump is tied to its place.
- const header = clamp01(in / 18) * (1 - placed.value(w.placed));
+ // The veil over every row but the walked one, while it is walked (the header too).
+ const veil = clamp01((r - 48) / 18) - clamp01((r - 270) / 18);
+ const header = clamp01(in / 18) * (1 - placed.value(w.placed)) * (1 - veil);
if (header > 0) v.faded(header).text(.sans, theme.size.sans.micro, at.address, at.top - 12, "128 bytes, from where rsp points", t.faint);
- // The veil over every row but the walked one, while it is walked.
- const veil = clamp01((r - 48) / 18) - clamp01((r - 270) / 18);
const address_ink = ui.mix(t.faint, theme.color.region.stack, placed.value(w.placed));
const become = placed.value(w.become);
const g = glide(become);
@@ -178,9 +184,10 @@ pub const Words = struct {
const slot: f32 = @floatFromInt(@as(i64, @bitCast(data.base + 8 * i -% w.panel.first)) >> 3);
const y = std.math.lerp(p.y, w.panel.top + pitch * slot, g);
const base = theme.baseline(y, pitch, size);
- const ax = std.math.lerp(at.address, w.panel.x + theme.metric.slot.address, g);
+ // The bytes go first (9 f), then the addresses travel right to the slots' column: never over them.
+ const ax = std.math.lerp(at.address, w.panel.x + theme.metric.slot.address, glide((become - 0.25) / 0.75));
if (p.address > 0) _ = row.faded(p.address).address(ax, base, data.base + 8 * i, .{ .ink = address_ink });
- w.drawBytes(row.faded(1 - clamp01(become * 2)), data, i, p.x, base, r, placed);
+ w.drawBytes(row.faded(1 - clamp01(become * 4)), data, i, p.x, base, r, placed);
w.drawWord(row, m, data.words[i], i, y, r, placed);
}
if (r >= 0) w.walk(v, data, r);
@@ -258,7 +265,13 @@ pub const Words = struct {
// A code address's chain is its name: it comes in as a hop does (6 f).
const end = v.address(rect.x, base, value, .{ .ink = ink, .rwx = kind == .rwx });
var name_buf: [128]u8 = undefined;
- if (m.string(value, &name_buf) catch null) |name| v.faded(clamp01(since * 10)).text(.mono, size, end + 10, base, ui.symbol(u, name), t.primary);
+ if (m.string(value, &name_buf) catch null) |name| {
+ // Cut with `…` at the state column's edge, as the stack's rows cut theirs.
+ const sym = ui.symbol(u, name);
+ const fits: usize = @intFromFloat(@max((theme.layout.state.x + theme.layout.state.w - end - 10) / adv, 2));
+ const shown = if (sym.len > fits) u.print("{s}\u{2026}", .{sym[0 .. fits - 1]}) else sym;
+ v.faded(clamp01(since * 10)).text(.mono, size, end + 10, base, shown, t.primary);
+ }
return;
}
if (since >= 0) {
@@ -277,13 +290,20 @@ pub const Words = struct {
const y = at.top + pitch * @as(f32, @floatFromInt(w.walked));
const base = theme.baseline(y, pitch, size);
const value = data.words[w.walked];
- // Under the row, its offsets and labels on the page (the veiled rows under them give way).
+ // A row near the dump's top has no room over it for the arcs at x2 (the camera's frame
+ // begins two rows over the header): there the bytes fly under the row, over the veiled
+ // rows, and the offsets and labels stand over it, the header's place (veiled with the rest).
+ const flip = w.walked < 4;
+ const dir: f32 = if (flip) -1 else 1;
+ // Under the row (over it, flipped), its offsets and labels on the page (the veiled rows there give way).
// They go as the gaps close (192), not after: closed, their pairs are 24 apart and they would touch.
const labels = clamp01((r - 84) / 12) * (1 - clamp01((r - 192) / 12));
const offsets = clamp01((r - 66) / 12) * (1 - clamp01((r - 192) / 12));
const zeros_mark = clamp01((r - 204) / 12) * (1 - clamp01((r - 228) / 12));
- const under = @max(offsets, zeros_mark);
- if (under > 0) u.faded(under).fill(.{ .x = at.bytes - 12, .y = y + pitch, .w = at.field_end - at.bytes + 24, .h = 2 * pitch + 6 }, theme.color.page);
+ const page_x = at.bytes - 12;
+ const page_w = at.field_end - at.bytes + 24;
+ if (offsets > 0) u.faded(offsets).fill(.{ .x = page_x, .y = if (flip) y - 2 * pitch - 6 else y + pitch, .w = page_w, .h = 2 * pitch + 6 }, theme.color.page);
+ if (zeros_mark > 0) u.faded(zeros_mark).fill(.{ .x = page_x, .y = y + pitch, .w = page_w, .h = 2 * pitch + 6 }, theme.color.page);
const close = glide((r - 192) / 12);
for (0..8) |k| {
const kf: f32 = @floatFromInt(k);
@@ -294,7 +314,7 @@ pub const Words = struct {
const long = to - from;
const high = std.math.clamp(long / 4, theme.time.flight.arc_min, theme.time.flight.arc_max);
const x = std.math.lerp(from, to, theme.ease(.glide, s));
- const lift = high * @sin(std.math.pi * s);
+ const lift = dir * high * @sin(std.math.pi * s);
// The byte itself: bright and bold in the air (from 108 the walk draws it, not the row).
if (r >= 108) {
const air = s > 0 and s < 1;
@@ -310,13 +330,13 @@ pub const Words = struct {
}
// Its offset under it, going with it.
const off = offsets * clamp01((r - 66 - 2 * kf) / 12);
- if (off > 0 and s > 0 and s < 1) u.faded(off).fill(.{ .x = x - 3, .y = base + pitch - lift - 18, .w = 2 * adv + 6, .h = 24 }, theme.color.page);
- if (off > 0) u.faded(off).text(.mono, size, x, base + pitch - lift, u.print("+{d}", .{k}), t.dim);
+ if (off > 0 and s > 0 and s < 1) u.faded(off).fill(.{ .x = x - 3, .y = base + dir * pitch - lift - 18, .w = 2 * adv + 6, .h = 24 }, theme.color.page);
+ if (off > 0) u.faded(off).text(.mono, size, x, base + dir * pitch - lift, u.print("+{d}", .{k}), t.dim);
// `low byte` from its byte's left, `high byte` to its byte's right: under the bytes, never the addresses.
if (k == 0 or k == 7) if (labels > 0) {
const label = if (k == 0) "low byte" else "high byte";
const lw = u.width(.sans, theme.size.sans.tag, label);
- u.faded(labels).text(.sans, theme.size.sans.tag, if (k == 0) x else x + 2 * adv - lw, base + 2 * pitch + 2 - lift, label, t.dim);
+ u.faded(labels).text(.sans, theme.size.sans.tag, if (k == 0) x else x + 2 * adv - lw, base + dir * 2 * pitch + 2 - lift, label, t.dim);
};
}
// The zeros in front, bracketed (motion.md: 204 to 228).