diff options
| author | Gabriel Schneider <[email protected]> | 2026-11-12 01:44:59 -0300 |
|---|---|---|
| committer | Gabriel Schneider <[email protected]> | 2026-11-12 03:17:32 -0300 |
| commit | bf0dfa135319f8c7ca49eace4d1f81152ebfd23e (patch) | |
| tree | 9c80ade769dc9a741c9d00f63770d34dc1769ced /anim/src/aligned.zig | |
| parent | aefde257db6e7cf683b923498c0d471885ab67a9 (diff) | |
| download | computeranim-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/aligned.zig')
| -rw-r--r-- | anim/src/aligned.zig | 154 |
1 files changed, 127 insertions, 27 deletions
diff --git a/anim/src/aligned.zig b/anim/src/aligned.zig index a7c225d..ce2f5a0 100644 --- a/anim/src/aligned.zig +++ b/anim/src/aligned.zig @@ -19,15 +19,19 @@ //! first row of its run; a line with no code of its own in source order //! after the line before it, faint, `no code of their own`. //! -//! `align` between them (6. Verbs): the addresses and instructions glide -//! right into the instruction column (24 f, the bytes going), then every +//! `align` between them (6. Verbs): the bytes go (8 f), the addresses and +//! instructions glide right into the instruction column (24 f), then every //! row glides to its height (36 f: the verb's 24 read too quick for rows //! crossing a column), then the lines with no code fade in (12 f). +//! +//! The lines as the mocks set them, without their indentation; the pc's +//! row says what it reads (its address and chain, mock 33's annotation). const std = @import("std"); const sk = @import("sketch"); const anim = @import("anim"); const ui = @import("ui.zig"); const disasm = @import("disasm.zig"); +const rows = @import("rows.zig"); const Recording = @import("Recording.zig"); const theme = ui.theme; const Rect = ui.Rect; @@ -47,6 +51,9 @@ const col = struct { const mnemonic = 360; const seam_after = 48; const instr = 156; + /// The pc's row's annotation, from its mnemonic: interleaved, columns (mocks 32, 36). + const note = 540; + const note_columns = 360; }; /// The dump row's first byte (`bytes`: at 132 at least). @@ -83,15 +90,25 @@ pub const Aligned = struct { rows_in: anim.Value, chrome: anim.Value, form: anim.Value, + /// `stack` (6. Verbs, `align` backwards), frames: the heads' paper and + /// rules, the seam and the tag out (12 f), then each line glides to its + /// row of the source panel (36 f, `glide`) and each instruction to its + /// row of the disassembly, down its column first (24 f), then left into + /// the panel (24 f): an instruction never passes over a line. Those the + /// working frame's windows do not show go on past their edge, fading. + /// 60 f in all; the scene then brings the panels in under them and lets this go. + stack: anim.Value, + /// Where they stack to: the working frame's source and disassembly boxes. + to: struct { source: Rect = .{ .x = 0, .y = 0, .w = 0, .h = 0 }, disasm: Rect = .{ .x = 0, .y = 0, .w = 0, .h = 0 } } = .{}, pub fn init(s: *anim.Frame, rec: *const Recording, moment: u64) Aligned { - return .{ .rec = rec, .at = moment, .bytes = s.value(-1), .decode = s.value(-1), .rows_in = s.value(-1), .chrome = s.value(-1), .form = s.value(0) }; + return .{ .rec = rec, .at = moment, .bytes = s.value(-1), .decode = s.value(-1), .rows_in = s.value(-1), .chrome = s.value(-1), .form = s.value(0), .stack = s.value(-1) }; } fn sourceLine(a: *const Aligned, n: u32) []const u8 { var it = std.mem.splitScalar(u8, a.rec.source, '\n'); var k: u32 = 1; - while (it.next()) |l| : (k += 1) if (k == n) return std.mem.trimEnd(u8, l, " \r"); + while (it.next()) |l| : (k += 1) if (k == n) return std.mem.trim(u8, l, " \t\r"); return ""; } @@ -177,14 +194,32 @@ pub const Aligned = struct { if (built.rows.len == 0) return; const m = a.rec.moment(a.at); const form = placed.value(a.form); - const across = glide(form / 24); - const down = glide((form - 24) / 36); - const bare = clamp01((form - 60) / 12); - const seam = col.text + built.longest + col.seam_after; + // The bytes first (interleaved alone has them), then the columns glide: never over them. + const bytes_go = clamp01(form / 8); + const across = glide((form - 8) / 24); + const down = glide((form - 32) / 36); + const bare = clamp01((form - 68) / 12); + // The seam 48 after the longest line, or after a second run's line and its note; the + // mnemonics after the longest instruction's bytes (mock 32's 360 holds five). + var seam = col.text + built.longest + col.seam_after; + var most: usize = 0; + for (built.rows) |r| { + if (r.kind == .head and r.again) seam = @max(seam, col.text + lineWidth(a, r.line) + again_gap + u.width(.sans, theme.size.sans.micro, again_note) + 24); + if (r.insn) |insn| most = @max(most, insn.len); + } + const mnemonic = @max(col.mnemonic, col.bytes + @as(f32, @floatFromInt(3 * most)) * adv + 12); const rows_in = placed.value(a.rows_in); - const chrome = clamp01(placed.value(a.chrome) / 12); - const tag_in = clamp01((placed.value(a.chrome) - 12) / 12); + const st = placed.value(a.stack); + const kept = 1 - clamp01(st / 12); + const going = glide((st - 12) / 36); + const down_first = glide((st - 12) / 24); + const then_left = glide((st - 36) / 24); + const chrome = clamp01(placed.value(a.chrome) / 12) * kept; + const tag_in = clamp01((placed.value(a.chrome) - 12) / 12) * kept; const v = u.moved(a.box.x, a.box.y); + // Nothing under the stage (y 888): rows `stack` takes past the disassembly's foot fade there, not over the caption. + v.clip(.{ .x = -a.box.x, .y = -a.box.y, .w = theme.canvas.width, .h = theme.canvas.stage.y + theme.canvas.stage.h }); + defer v.unclip(); const body = tag + pad; var counts = [2]f32{ 0, 0 }; for (built.rows) |r| counts = .{ @max(counts[0], r.at[0] + 1), @max(counts[1], r.at[1] + 1) }; @@ -200,22 +235,53 @@ pub const Aligned = struct { } if (chrome > 0) v.faded(chrome).frame(.{ .x = 0, .y = 0, .w = a.box.w, .h = h }, theme.color.rule, theme.stroke.rule); // The seam, with the columns. - if (down > 0) v.faded(down).fill(.{ .x = seam, .y = tag, .w = theme.stroke.rule, .h = h - tag }, theme.color.rule); + if (down > 0) v.faded(down * kept).fill(.{ .x = seam, .y = tag, .w = theme.stroke.rule, .h = h - tag }, theme.color.rule); + // Where `stack` takes them: the source's window and the disassembly's, as those panels have them. + const src_first: f32 = @floatFromInt(a.rec.shownFirst(@intCast(theme.layout.rowsIn(a.to.source.h)), a.rec.shown[a.at])); + const dis_room = theme.layout.rowsIn(a.to.disasm.h); + // The panels' columns right of the line numbers move by as much as the widest file's numbers need. + const widen = rows.numberRoom(a.rec.most_lines); + const dis_rows = if (st >= 0) disasm.listingAt(u, a.rec, a.at, a.rec.register(a.at, "rip"), dis_room, (dis_room -| 1) / 2).rows else &.{}; for (built.rows, 0..) |r, k| { - const y = body + pitch * std.math.lerp(r.at[0], r.at[1], down); + var y = body + pitch * std.math.lerp(r.at[0], r.at[1], down); const order: f32 = @floatFromInt(k); // At a run: rows top down, 2 f apart, 8 f each; the pc's row is the decoded one. // The pc's row is the decoded one, once it has travelled to its place (48). var shows: f32 = if (k == built.pc) @as(f32, if (placed.value(a.decode) >= 48) 1 else 0) else clamp01((rows_in - 2 * order) / 8); if (r.kind == .bare_line) shows = @min(shows, bare); + // `stack`: its row in the working frame's panel (box-relative), and whether that window shows it. + var to_x: f32 = 0; + var to_y: f32 = 0; + if (st >= 0) { + var inside = true; + if (r.kind == .insn) { + var n: ?usize = null; + for (dis_rows, 0..) |d, i| if (d.addr == r.insn.?.addr) { + n = i; + }; + // Past the window: where it would be, going on from its last row. + const at_row: f32 = if (n) |i| @floatFromInt(i) else @as(f32, @floatFromInt(dis_rows.len)) + order - @as(f32, @floatFromInt(built.pc)); + inside = n != null; + to_x = a.to.disasm.x - a.box.x; + to_y = a.to.disasm.y - a.box.y + body + pitch * at_row; + } else { + const at_row = @as(f32, @floatFromInt(r.line)) - src_first; + inside = !r.again and at_row >= 0 and at_row < @as(f32, @floatFromInt(theme.layout.rowsIn(a.to.source.h))); + to_x = a.to.source.x - a.box.x; + to_y = a.to.source.y - a.box.y + body + pitch * at_row; + } + if (!inside) shows *= 1 - (if (r.kind == .insn) then_left else going); + } if (shows <= 0) continue; const rv = v.faded(shows); + if (r.kind == .insn and st >= 0) y = std.math.lerp(y, to_y, down_first); const base = theme.baseline(y, pitch, size); switch (r.kind) { .head, .bare_line => { // Interleaved: a head across the panel; columns: the line in its cell, level with its run. - const head_y = if (r.kind == .head) y else body + pitch * r.at[1]; + var head_y = if (r.kind == .head) y else body + pitch * r.at[1]; + if (st >= 0) head_y = std.math.lerp(head_y, to_y, going); const hb = theme.baseline(head_y, pitch, size); const paper_w = std.math.lerp(a.box.w - 4, seam - 2, down); if (r.kind == .head and !r.again and chrome > 0) rv.faded(chrome).fill(.{ .x = 2, .y = head_y, .w = paper_w, .h = pitch }, theme.color.raised); @@ -223,36 +289,47 @@ pub const Aligned = struct { const faint = r.again or r.kind == .bare_line; const number = rv.print("{d}", .{r.line}); const is_pc = !r.again and built.rows[built.pc].line == r.line and r.kind == .head; - if (is_pc) rv.fill(.{ .x = col.place_end - @as(f32, @floatFromInt(number.len)) * adv - 4, .y = head_y + 1, .w = @as(f32, @floatFromInt(number.len)) * adv + 6, .h = pitch - 2 }, theme.mark(.current).solid); - rv.text(.mono, size, col.place_end - @as(f32, @floatFromInt(number.len)) * adv, hb, number, if (is_pc) t.ink else t.faint); - rv.text(.mono, size, col.text, hb, a.sourceLine(r.line), if (faint) t.faint else t.primary); - if (r.again) rv.text(.sans, theme.size.sans.micro, std.math.lerp(col.mnemonic + 4, col.text + built.longest - 140, down), hb, "again: its second run", t.dim); - if (r.kind == .bare_line and r.first) rv.text(.sans, theme.size.sans.micro, seam + col.instr, hb, "no code of their own", t.dim); + // `stack`: the number to the source's number column, the text to its text column at its indent. + const n_end = std.math.lerp(col.place_end, to_x + theme.metric.context.line_number_end + widen, going); + const t_x = std.math.lerp(col.text, to_x + theme.metric.context.line_text + widen + @as(f32, @floatFromInt(indentOf(a, r.line))) * adv, going); + if (is_pc) rv.fill(.{ .x = n_end - @as(f32, @floatFromInt(number.len)) * adv - 4, .y = head_y + 1, .w = @as(f32, @floatFromInt(number.len)) * adv + 6, .h = pitch - 2 }, theme.mark(.current).solid); + rv.text(.mono, size, n_end - @as(f32, @floatFromInt(number.len)) * adv, hb, number, if (is_pc) t.ink else t.faint); + rv.text(.mono, size, t_x, hb, a.sourceLine(r.line), if (faint) t.faint else t.primary); + if (r.again) rv.faded(kept).text(.sans, theme.size.sans.micro, std.math.lerp(mnemonic + 4, col.text + lineWidth(a, r.line) + again_gap, down), hb, again_note, t.dim); + if (r.kind == .bare_line and r.first) rv.faded(kept).text(.sans, theme.size.sans.micro, seam + col.instr, hb, "no code of their own", t.dim); }, .insn => { const insn = r.insn.?; - const ix = std.math.lerp(0, seam, across); + // `stack`: the row's left edge to the disassembly's. + const ix = std.math.lerp(std.math.lerp(0, seam, across), to_x, then_left); + const right = std.math.lerp(a.box.w, to_x + a.to.disasm.w, then_left); if (k == built.pc) { const wash = rv.faded(clamp01((placed.value(a.decode) - 48) / 12)); - wash.current(.{ .x = ix + 2, .y = y, .w = a.box.w - ix - 4, .h = pitch }, theme.metric.plaque.pc, 0); - sk.draw.polygon(f, &.{ wash.at.xf.apply(.{ ix + 20, y + pitch / 2 }), wash.at.xf.apply(.{ ix + 10, y + 6 }), wash.at.xf.apply(.{ ix + 10, y + pitch - 6 }) }, wash.at.pen(.{ .fill = ui.rgb(theme.mark(.current).on_solid) })); + wash.current(.{ .x = ix + 2, .y = y, .w = right - ix - 4, .h = pitch }, theme.metric.plaque.pc, 0); + sk.draw.polygon(f, &.{ .{ ix + 20, y + pitch / 2 }, .{ ix + 10, y + 6 }, .{ ix + 10, y + pitch - 6 } }, wash.at.pen(.{ .fill = ui.rgb(theme.mark(.current).on_solid) })); } const digits: f32 = @floatFromInt(ui.digits(insn.addr)); - _ = rv.address(ix + col.place_end - digits * adv, base, insn.addr, .{ .ink = ui.rgb(theme.color.region.code_) }); + // (`stack`: ranged right in its column to the disassembly's address column, from 40.) + _ = rv.address(std.math.lerp(std.math.lerp(0, seam, across) + col.place_end - digits * adv, to_x + theme.metric.insn.address, then_left), base, insn.addr, .{ .ink = ui.rgb(theme.color.region.code_) }); // Its bytes, as the recording read them: interleaved only. - if (across < 1) rv.faded(1 - across).text(.mono, size, col.bytes, base, hexBytes(rv, m, insn), t.dim); - disasm.bareRow(rv.moved(std.math.lerp(col.mnemonic - theme.metric.insn.mnemonic, seam + col.instr + 24 - theme.metric.insn.mnemonic, across), 0), insn, y); + if (bytes_go < 1) rv.faded(1 - bytes_go).text(.mono, size, col.bytes, base, hexBytes(rv, m, insn), t.dim); + const mx = std.math.lerp(std.math.lerp(mnemonic, seam + col.instr + 24, across), to_x + theme.metric.insn.mnemonic + widen, then_left); + disasm.bareRow(rv.moved(mx - theme.metric.insn.mnemonic, 0), insn, y); + // The pc's row: what it reads, its address and the chain from it, once decoded. + if (k == built.pc) if (a.rec.insn_touches[a.at][0]) |touch| { + _ = rows.chain(rv.faded(clamp01((placed.value(a.decode) - 48) / 12) * kept), mx + std.math.lerp(col.note, col.note_columns, across), y, m, touch.addr, a.box.w - 24, .{}); + }; }, } } - a.drawBytesRow(v, m, placed, built); + a.drawBytesRow(v, m, placed, built, mnemonic); } /// III1 and the decode (III2): the code's sixteen bytes as a dump row, /// in code's ink 2 f apart; the pc's instruction's bytes framed; then /// they gather, its text fades in beside them, and the row travels to /// its place in the panel. - fn drawBytesRow(a: *const Aligned, v: ui.Ui, m: Recording.Moment, placed: anim.Placed, built: anytype) void { + fn drawBytesRow(a: *const Aligned, v: ui.Ui, m: Recording.Moment, placed: anim.Placed, built: anytype, mnemonic: f32) void { const clock = placed.value(a.bytes); if (clock < 0) return; const d = placed.value(a.decode); @@ -300,10 +377,33 @@ pub const Aligned = struct { if (framed > 0) rv.read(.{ .x = bx(first), .y = y, .w = bx(first + insn.len - 1) - bx(first) + 2 * adv, .h = pitch }, framed); // Its text beside the bytes, at the panel's columns from them (12 f). const text_in = clamp01((d - 12) / 12); - if (text_in > 0) disasm.bareRow(rv.faded(text_in).moved(target_x - col.bytes + col.mnemonic - theme.metric.insn.mnemonic, 0), insn, y); + if (text_in > 0) disasm.bareRow(rv.faded(text_in).moved(target_x - col.bytes + mnemonic - theme.metric.insn.mnemonic, 0), insn, y); } }; +const again_note = "again: its second run"; +const again_gap = 36; + +/// How far line `n` is indented in the file (its leading spaces; a tab as four). +fn indentOf(a: *const Aligned, n: u32) usize { + var it = std.mem.splitScalar(u8, a.rec.source, '\n'); + var k: u32 = 1; + while (it.next()) |l| : (k += 1) if (k == n) { + var w: usize = 0; + for (l) |ch| switch (ch) { + ' ' => w += 1, + '\t' => w += 4, + else => break, + }; + return w; + }; + return 0; +} + +fn lineWidth(a: *const Aligned, n: u32) f32 { + return @as(f32, @floatFromInt(a.sourceLine(n).len)) * adv; +} + fn hexBytes(u: ui.Ui, m: Recording.Moment, insn: disasm.Insn) []const u8 { var bytes: [16]u8 = undefined; var known: [16]bool = undefined; |
