summaryrefslogtreecommitdiff
path: root/anim/src/rows.zig
diff options
context:
space:
mode:
Diffstat (limited to 'anim/src/rows.zig')
-rw-r--r--anim/src/rows.zig367
1 files changed, 367 insertions, 0 deletions
diff --git a/anim/src/rows.zig b/anim/src/rows.zig
new file mode 100644
index 0000000..063301a
--- /dev/null
+++ b/anim/src/rows.zig
@@ -0,0 +1,367 @@
+//! The catalogue's rows (design/README.md, "2. Rows"): every row is 24
+//! high and one line, made of atoms, and none wraps: what does not fit is
+//! cut at its far end and says so. A row draws what it is given, in the
+//! states it is given; the panels (`context.zig`, `disasm.zig`,
+//! `source.zig`, `hexdump.zig`) read the recording and the cursor and say
+//! which. x is from the panel's left edge, y is the row's top.
+const std = @import("std");
+const sk = @import("sketch");
+const zt = @import("ztrace");
+const ui = @import("ui.zig");
+const Recording = @import("Recording.zig");
+const theme = ui.theme;
+const Rect = ui.Rect;
+const t = theme.color.text;
+const m = theme.metric.context;
+const size = theme.size.mono.context;
+const adv = size * 3 / 5;
+const row_h = m.row;
+
+/// What an address into `region` is inked in.
+pub fn ink(region: zt.telescope.Region) u24 {
+ const c = theme.color.region;
+ return switch (region) {
+ .none => c.number,
+ .code => c.code_,
+ // Writable and executable: its region's ink (data's, here) and an underline.
+ .rwx => c.data,
+ .stack => c.stack,
+ .heap => c.heap,
+ .data => c.data,
+ .rodata => c.rodata,
+ };
+}
+
+pub fn regionOf(moment: Recording.Moment, value: u64) zt.telescope.Region {
+ return zt.telescope.region(moment, value) catch .none;
+}
+
+pub fn baseline(y: f32) f32 {
+ return theme.baseline(y, row_h, size);
+}
+
+/// The marks on a chain's hops.
+pub const Marks = struct {
+ /// The first hop: a register (or a word) written: armed, struck, held.
+ first: ui.Heat = .none,
+ /// A later hop, the memory under a pointer that did not change: its
+ /// tick sits before that hop alone.
+ changed: ?usize = null,
+ changed_heat: ui.Heat = .ember,
+ /// A hop read, and how much its frame shows.
+ read: ?usize = null,
+ read_shows: f32 = 0,
+ /// `extend`: seconds since the first hop was struck; the hops after it
+ /// are followed again 4 f apart, each fading in over 6 f.
+ extend: ?f32 = null,
+ /// The first hop's `lead` (a column of addresses).
+ lead: usize = 0,
+ /// Where the first hop's tick goes, left of its digits: 9 after a
+ /// name, 5 after an arrow.
+ tick: f32 = 9,
+};
+
+/// Where a chain's hops were drawn: x and width of each one's digits.
+pub const Hops = struct {
+ x: [6]f32 = undefined,
+ w: [6]f32 = undefined,
+ n: usize = 0,
+ end: f32 = 0,
+};
+
+/// `chain`: a telescope, `address (points address)* (holds value)?`, of
+/// `value` at `moment`, from `x` on the row at `y`, cut where `room`
+/// ends. A code address ends it with its name, a string in quotes; depth
+/// is the recording's. Cut at its far end: a string is shortened first,
+/// then the chain ends early in `more`; nothing is taken from the middle.
+pub fn chain(u: ui.Ui, x: f32, y: f32, moment: Recording.Moment, value: u64, room: f32, marks: Marks) Hops {
+ var links_buf: [6]zt.telescope.Link = undefined;
+ var text_buf: [48]u8 = undefined;
+ const links = zt.telescope.chase(moment, value, &links_buf, &text_buf) catch return .{};
+ const base = baseline(y);
+ const mid = y + row_h / 2;
+ var hops: Hops = .{};
+ var at = x;
+ for (links, 0..) |link, i| {
+ const pointer = link.region != .none;
+ const shown = ui.Value.of(link.value, pointer);
+ const w = shown.width();
+ // The hops after a struck first one are followed again, one at a time.
+ const v = if (i > 0 and marks.extend != null) u.faded(std.math.clamp((marks.extend.? - @as(f32, @floatFromInt(i - 1)) * theme.time.unroll) / (6.0 / 60.0), 0, 1)) else u;
+ if (i > 0) {
+ const named: f32 = if (link.region == .code and link.text.len > 0 and !link.string) 10 + @as(f32, @floatFromInt(link.text.len)) * adv else 0;
+ // Room for it, and for saying there is more.
+ if (pointer and at + m.arrow_w + w + named + 40 > room) {
+ _ = v.arrow(at, mid, .more);
+ break;
+ }
+ if (!pointer and at + m.arrow_w + w > room) {
+ // The value it ends on has no room: it says so.
+ if (at + 2 * adv <= room) v.text(.mono, size, at + 4, base, "\u{2026}", t.faint);
+ break;
+ }
+ at = v.arrow(at, mid, if (pointer) .points else .holds);
+ }
+ const marked: Rect = .{ .x = at, .y = y, .w = w, .h = row_h };
+ var face_ink: ui.Ink = .{ .ink = ui.rgb(if (pointer) ink(link.region) else t.primary) };
+ if (i == 0) {
+ if (v.written(marked, marks.first, marks.tick)) |struck| face_ink = struck;
+ } else if (marks.changed == i) {
+ if (v.written(marked, marks.changed_heat, 5)) |struck| face_ink = struck;
+ }
+ if (marks.read == i) v.read(marked, marks.read_shows);
+ if (pointer) {
+ _ = v.address(at, base, link.value, .{ .ink = face_ink.ink, .face = face_ink.face, .lead = if (i == 0) marks.lead else 0, .rwx = link.region == .rwx });
+ } else _ = v.value(at, base, link.value, false, face_ink);
+ if (hops.n < hops.x.len) {
+ hops.x[hops.n] = at;
+ hops.w[hops.n] = w;
+ hops.n += 1;
+ }
+ at += w;
+ if (!pointer and shown.decimal) at += 8 + @as(f32, @floatFromInt(std.fmt.count("{d}", .{link.value}))) * adv;
+ if (link.text.len == 0) {
+ // Still a pointer where the recording stopped following.
+ if (i + 1 == links.len and pointer and link.region != .code and link.region != .rwx and at + m.arrow_w + 24 <= room) at = v.arrow(at, mid, .more);
+ continue;
+ }
+ if (link.string) {
+ // What a pointer leads to, when it is text: quoted, cut to the room
+ // there is (never under six characters), with `…` and no closing quote.
+ const fits: usize = @intFromFloat(@max((room - at - m.arrow_w) / adv, 0));
+ if (fits < m.string_min + 2) break;
+ at = v.arrow(at, mid, .holds);
+ const whole = link.text.len + 2 <= fits;
+ const text = if (whole) u.print("\"{s}\"", .{link.text}) else u.print("\"{s}\u{2026}", .{link.text[0 .. fits - 2]});
+ v.text(.mono, size, at, base, text, theme.color.string);
+ at += @as(f32, @floatFromInt(std.unicode.utf8CountCodepoints(text) catch text.len)) * adv;
+ } else {
+ // A code address's name.
+ const name = ui.symbol(u, link.text);
+ const fits: usize = @intFromFloat(@max((room - at - 10) / adv, 0));
+ if (fits >= 3) {
+ v.text(.mono, size, at + 10, base, name[0..@min(name.len, fits)], t.primary);
+ at += 10 + @as(f32, @floatFromInt(@min(name.len, fits))) * adv;
+ }
+ }
+ break;
+ }
+ hops.end = at;
+ return hops;
+}
+
+/// The cell a mark goes on for `value` drawn at `x` in a row at `y`.
+pub fn cell(x: f32, y: f32, moment: Recording.Moment, value: u64) Rect {
+ return .{ .x = x, .y = y, .w = ui.Value.of(value, regionOf(moment, value) != .none).width(), .h = row_h };
+}
+
+/// `reg`: a register's name (dim) 12 in, its chain from 72, room to 12
+/// from the edge `w`.
+pub fn reg(u: ui.Ui, y: f32, w: f32, name: []const u8, moment: Recording.Moment, value: u64, marks: Marks) Hops {
+ u.text(.mono, size, m.side, baseline(y), name, t.dim);
+ return chain(u, m.chain_x, y, moment, value, w - m.side, marks);
+}
+
+/// The flags, in rip's row: their names, the value.
+pub const Flag = struct { name: []const u8, bit: u6 };
+pub const flags = [_]Flag{ .{ .name = "CF", .bit = 0 }, .{ .name = "PF", .bit = 2 }, .{ .name = "AF", .bit = 4 }, .{ .name = "ZF", .bit = 6 }, .{ .name = "SF", .bit = 7 }, .{ .name = "IF", .bit = 9 }, .{ .name = "DF", .bit = 10 }, .{ .name = "OF", .bit = 11 } };
+
+/// `reg` rip: gold plaque on the name, ember across, the address in
+/// code's ink and its name; never struck. At its right end the `flags`,
+/// eight names on a pitch of 42: set, upper case on a chip, bold, bright;
+/// clear, lower case, dim; changed, a tick (`changed`: a bit per flag, and
+/// how held). The value of eflags is not drawn: the names are the value.
+pub fn rip(u: ui.Ui, y: f32, w: f32, moment: Recording.Moment, pc: u64, eflags: u64, changed: u64, held: f32, fire: f32) void {
+ const gold = theme.mark(.current);
+ u.current(.{ .x = theme.stroke.rule, .y = y, .w = w - 2 * theme.stroke.rule, .h = row_h }, theme.metric.plaque.rip, fire);
+ u.text(.mono_bold, size, m.side, baseline(y), "rip", gold.on_solid);
+ const fl = theme.metric.flags;
+ var x = w - m.side - @as(f32, flags.len) * fl.pitch + 10;
+ _ = chain(u, m.chain_x, y, moment, pc, x - 16, .{});
+ for (flags) |flag| {
+ const set = eflags >> flag.bit & 1 != 0;
+ if (changed >> flag.bit & 1 != 0 and held > 0) u.fill(.{ .x = x - 7, .y = y + 3, .w = m.tick, .h = row_h - 6 }, ui.mix(gold.ember, theme.mark(.write).solid, held));
+ if (set) {
+ u.chip(.{ .x = x, .y = y + 2, .w = fl.chip[0], .h = fl.chip[1] });
+ u.text(.mono_bold, size, x + 4, baseline(y), flag.name, t.bright);
+ } else u.text(.mono, size, x + 4, baseline(y), u.print("{c}{c}", .{ std.ascii.toLower(flag.name[0]), std.ascii.toLower(flag.name[1]) }), ui.mix(t.dim, gold.ember, 0.2));
+ x += fl.pitch;
+ }
+}
+
+/// `slot`: a word of the stack: a lane 112 wide for `row` pins (`pins`,
+/// the registers that hold its address), then its chain from 122,
+/// beginning with the slot's own address in stack ink with `lead`, room
+/// to 136 from the right edge `w` (the `call` spans').
+pub fn slot(u: ui.Ui, y: f32, w: f32, moment: Recording.Moment, addr: u64, pins: []const []const u8, pin_shows: f32, marks: Marks) Hops {
+ const s = theme.metric.slot;
+ if (pins.len > 0 and pin_shows > 0) u.faded(pin_shows).pinRow(s.lane, y, pins, theme.color.region.stack);
+ var lead = marks;
+ lead.first = .none;
+ const base = baseline(y);
+ const end = u.address(s.chain, base, addr, .{ .ink = ui.rgb(theme.color.region.stack), .lead = marks.lead });
+ const held = (Recording.word(moment, addr, 8) catch null) orelse {
+ _ = u.arrow(end, y + row_h / 2, .points);
+ u.unknown(.{ .x = end + m.arrow_w, .y = y, .w = 24, .h = row_h });
+ return .{ .end = end + m.arrow_w + 24 };
+ };
+ // The word there: a pointer, or what the slot holds.
+ const pointer = regionOf(moment, held) != .none;
+ const at = u.arrow(end, y + row_h / 2, if (pointer) .points else .holds);
+ lead.lead = 0;
+ lead.first = marks.first;
+ lead.tick = 5;
+ return chain(u, at, y, moment, held, w - s.room, lead);
+}
+
+/// `call` `span`: one frame of the call chain on the stack, a bracket 14
+/// in from the panel's right edge `w` down the slots `y0 .. y1` that are
+/// the frame, and the function's name left of it (Go Medium 18). `newest`
+/// gold and bright; older, rule and dim. `open`: it runs past the panel.
+pub fn span(u: ui.Ui, w: f32, y0: f32, y1: f32, name: []const u8, newest: bool, open: bool) void {
+ const x = w - theme.metric.slot.span;
+ const c = if (newest) theme.mark(.current).solid else theme.color.rule;
+ u.bracket(x, y0 + 3, y1 - @as(f32, if (open) 0 else 3), c, theme.metric.bracket.quiet, -1, open);
+ const micro = theme.size.sans.micro;
+ const mid = (y0 + y1) / 2 + 6;
+ u.text(.sans_medium, micro, x - 14 - u.width(.sans_medium, micro, name), mid, name, if (newest) t.bright else t.dim);
+}
+
+/// `call` `row`: `#n` (a gold plaque on the newest), the name and offset
+/// in primary at 60, file and line in dim at 276.
+pub fn callRow(u: ui.Ui, y: f32, w: f32, n: usize, name: []const u8, where: []const u8, newest: bool) void {
+ const gold = theme.mark(.current);
+ if (newest) u.current(.{ .x = theme.stroke.rule, .y = y, .w = w - 2 * theme.stroke.rule, .h = row_h }, 44, 0);
+ u.text(if (newest) .mono_bold else .mono, size, m.side, baseline(y), u.print("#{d}", .{n}), if (newest) gold.on_solid else t.faint);
+ u.text(.mono, size, 60, baseline(y), name[0..@min(name.len, 17)], t.primary);
+ u.text(.mono, size, 276, baseline(y), where, t.dim);
+}
+
+/// `line`: a line of source, its number ranged right in three characters
+/// (faint), the text from 64 in the four code inks, 67 characters and
+/// then a faint `…`. `current`: a gold plaque 50 wide on the number (its
+/// edges out `fire`), ember across; `marked`: the number as on the plaque,
+/// which its panel draws where the mark is (it slides). `trail`: the bar
+/// (0 newest).
+pub fn line(u: ui.Ui, y: f32, w: f32, number: u32, text: []const u8, styles: []const u8, state: union(enum) { plain, current: f32, marked, trail: usize }) void {
+ const gold = theme.mark(.current);
+ switch (state) {
+ .current => |fire| u.current(.{ .x = theme.stroke.rule, .y = y, .w = w - 2 * theme.stroke.rule, .h = row_h }, theme.metric.plaque.line, fire),
+ .trail => |k| u.trail(theme.stroke.rule, y, k),
+ .plain, .marked => {},
+ }
+ const on = state == .current or state == .marked;
+ const num = u.print("{d}", .{number});
+ u.text(if (on) .mono_bold else .mono, size, m.line_number_end - @as(f32, @floatFromInt(num.len)) * adv, baseline(y), num, if (on) gold.on_solid else t.faint);
+ const limit: usize = m.source_chars;
+ const end = @min(text.len, limit);
+ var i: usize = 0;
+ while (i < end) {
+ var j = i + 1;
+ while (j < end and styles[j] == styles[i]) j += 1;
+ if (std.mem.indexOfNone(u8, text[i..j], " ") != null) {
+ const class = styles[i];
+ u.text(codeFace(class), size, m.line_text + @as(f32, @floatFromInt(i)) * adv, baseline(y), text[i..j], codeInk(class));
+ }
+ i = j;
+ }
+ if (text.len > limit) u.text(.mono, size, m.line_text + @as(f32, @floatFromInt(limit)) * adv, baseline(y), "\u{2026}", t.faint);
+}
+
+/// pardes's classes: none, keyword, string, number, comment.
+fn codeInk(class: u8) u24 {
+ const c = theme.color.code;
+ return switch (class) {
+ 1 => c.keyword,
+ 2, 3 => c.literal,
+ 4 => c.comment,
+ else => c.plain,
+ };
+}
+
+fn codeFace(class: u8) ui.Face {
+ return switch (class) {
+ 1 => .mono_bold,
+ 4 => .mono_italic,
+ else => .mono,
+ };
+}
+
+/// A run of a `bytes` row: what the bytes are, from the types of what the
+/// program's pointers reach.
+pub const Run = struct {
+ first: u8,
+ len: u8,
+ kind: enum { number, pointer, allocator, unread },
+ /// Its mark: struck (heat), read (shows), held is in the heat.
+ heat: ui.Heat = .none,
+ read: f32 = 0,
+};
+
+/// `bytes`: a hexdump row of sixteen bytes at `addr`: a bracket at 7
+/// (`bracket`: quiet on a row that holds a drawn thing), the address in
+/// region ink with `lead` at 18 (at 60% on a row that holds no drawn
+/// thing), the bytes from 132 on a pitch of 30, 12 more after the
+/// eighth; a field's bytes on raised paper in their ink (a pointer's in
+/// the region it points into), an allocator's dim with no paper, never
+/// read two dots a byte; a word's padding bytes faint. `reading` is drawn
+/// by the caller at 640.
+pub fn bytes(u: ui.Ui, y: f32, addr: u64, values: *const [16]u8, known: *const [16]bool, runs: []const Run, region: u24, lead: usize, holds_drawn: bool, moment: Recording.Moment) void {
+ const b = theme.metric.bytes;
+ const base = baseline(y);
+ _ = u.address(b.address, base, addr, .{ .ink = if (holds_drawn) ui.rgb(region) else ui.mix(region, theme.color.page, theme.metric.context.lead_alpha), .lead = lead });
+ if (holds_drawn) u.bracket(b.bracket, y + 3, y + row_h - 3, ui.mix(region, theme.color.page, theme.metric.context.lead_alpha), theme.metric.bracket.quiet, 1, false);
+ for (runs) |run| {
+ const x0 = byteX(run.first) - 4;
+ const x1 = byteX(run.first + run.len - 1) + 28;
+ const r: Rect = .{ .x = x0, .y = y + 1, .w = x1 - x0, .h = row_h - 2 };
+ const field = run.kind == .number or run.kind == .pointer;
+ if (field) u.fill(r, theme.color.raised);
+ // Marks per run, never per byte: struck (the paper solid), read (a
+ // frame 3 out), held (a tick in the gap at the run's left).
+ var face: ui.Face = .mono;
+ var struck_ink: ?ui.Color = null;
+ const h = run.heat;
+ const held = h.level * (1 - (if (h.level >= 1) h.solid * h.in else 0));
+ if (held > 0) u.fill(.{ .x = x0 - 7, .y = y + 3, .w = m.tick, .h = row_h - 6 }, ui.mix(theme.color.page, theme.mark(.write).solid, held));
+ if (h.arm > 0) u.faded(h.arm).frame(.{ .x = x0 - 3, .y = y - 1, .w = x1 - x0 + 6, .h = row_h + 2 }, theme.mark(.write).solid, 2);
+ const solid = if (h.level >= 1) h.solid * h.in else 0;
+ if (solid > 0) {
+ u.fill(.{ .x = r.x - h.out, .y = r.y - h.out, .w = r.w + 2 * h.out, .h = r.h + 2 * h.out }, ui.mix(theme.color.raised, theme.mark(.write).solid, solid));
+ if (solid >= 0.5) {
+ face = .mono_bold;
+ struck_ink = ui.rgb(theme.mark(.write).on_solid);
+ }
+ }
+ if (run.read > 0) u.faded(run.read).frame(.{ .x = x0 - 3, .y = y - 1, .w = x1 - x0 + 6, .h = row_h + 2 }, theme.mark(.read).solid, 2);
+ // A little-endian word: the bytes above its highest non-zero one are its padding.
+ var top: usize = 0;
+ for (0..run.len) |j| if (values[run.first + j] != 0) {
+ top = j;
+ };
+ const word: u64 = if (run.len == 8) std.mem.readInt(u64, values[run.first..][0..8], .little) else 0;
+ const run_ink: ui.Color = switch (run.kind) {
+ .number => ui.rgb(t.primary),
+ .pointer => ui.rgb(if (run.len == 8) ink(regionOf(moment, word)) else t.primary),
+ .allocator => ui.rgb(t.dim),
+ .unread => ui.rgb(t.faint),
+ };
+ for (0..run.len) |j| {
+ const i = run.first + j;
+ const x = byteX(@intCast(i));
+ if (run.kind == .unread or !known[i]) {
+ u.fill(.{ .x = x + 5, .y = y + 11, .w = 4, .h = 4 }, t.faint);
+ u.fill(.{ .x = x + 15, .y = y + 11, .w = 4, .h = 4 }, t.faint);
+ continue;
+ }
+ const c = struck_ink orelse if (j <= top) run_ink else ui.mix(run_ink, theme.color.page, theme.metric.context.pad_alpha);
+ u.text(face, size, x, base, u.print("{x:0>2}", .{values[i]}), c);
+ }
+ }
+}
+
+/// Where byte `i` of a `bytes` row is.
+pub fn byteX(i: u8) f32 {
+ const b = theme.metric.bytes;
+ return b.first + @as(f32, @floatFromInt(i)) * b.pitch + @as(f32, if (i >= 8) b.middle else 0);
+}