diff options
Diffstat (limited to 'anim/src/rows.zig')
| -rw-r--r-- | anim/src/rows.zig | 367 |
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); +} |
