summaryrefslogtreecommitdiff
path: root/anim/src/disasm.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/disasm.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/disasm.zig')
-rw-r--r--anim/src/disasm.zig310
1 files changed, 231 insertions, 79 deletions
diff --git a/anim/src/disasm.zig b/anim/src/disasm.zig
index e429643..efdb80e 100644
--- a/anim/src/disasm.zig
+++ b/anim/src/disasm.zig
@@ -109,10 +109,12 @@ pub const Disasm = struct {
// Which moment the current mark stands for, and the three steps before it.
const base: usize = if (going >= 0.5) 0 else 1;
const current_line = rec.own[now.marks[if (going >= 0.5) 1 else 0]];
+ // The addresses' shared digits, of the window the mark is in: they
+ // change with the advance, not before it.
const lead = blk: {
var addrs: [24]u64 = undefined;
var n: usize = 0;
- for (shown.rows) |row| if (!row.outside and n < addrs.len) {
+ for ((if (going >= 0.5) to else from).rows) |row| if (!row.outside and n < addrs.len) {
addrs[n] = row.addr;
n += 1;
};
@@ -129,45 +131,66 @@ pub const Disasm = struct {
ties.anchor(u, .pc, .{ .x = 0, .y = mark_y, .w = theme.metric.plaque.pc, .h = m.row });
}
+ // `ran`: what the last three steps ran (every instruction, where the
+ // recording is by instruction), the newest step's mark on each row,
+ // and the moment it last ran at for its annotation.
+ const ran = u.f.scratch.alloc(?Ran, merged.len) catch return;
+ @memset(ran, null);
+ for (0..3) |k| {
+ const first = now.stops[@min(base + 1 + k, now.stops.len - 1)];
+ const last = now.stops[base + k];
+ var at = last;
+ // shortcut: a step through more than 4096 moments marks its last 4096.
+ while (at > first and last - at < 4096) {
+ at -= 1;
+ const j = rowOf(merged, rec.register(at, "rip")) orelse continue;
+ if (ran[j] == null) ran[j] = .{ .k = k, .at = at };
+ }
+ }
+ // The jump that brought control here: the instruction just before
+ // the pc's moment, a jump taken to it.
+ const jumped: ?u64 = blk: {
+ const at = now.stops[base];
+ if (at == 0 or at <= now.stops[base + 1]) break :blk null;
+ const b = rec.insn_branches[at - 1] orelse break :blk null;
+ if (b.kind != .jump or !b.taken or b.to != rec.register(at, "rip")) break :blk null;
+ break :blk rec.register(at - 1, "rip");
+ };
+
var last_line: ?u32 = null;
- var run: usize = 0;
- var run_start: ?f32 = null;
+ // The thread's runs: of the line the mark leaves and of the one it
+ // goes to, each a span of rows; published sliding from the one to
+ // the other with the advance (`threadRuns`).
+ var runs: [2]Runs = .{ .{}, .{} };
+ const lines_of = [2]u32{ rec.own[now.marks[0]], rec.own[now.marks[1]] };
var lanes: [2]?f32 = .{ null, null };
+ // A call's arguments hang in the annotation column of the rows under it.
+ var covered: usize = 0;
for (merged, 0..) |row, j| {
const y = top + (@as(f32, @floatFromInt(j)) - scroll) * m.row;
const line = if (row.outside) null else row.line;
// The thread: the current line's runs of instructions.
- const on_line = line != null and line.? == current_line and mark_shows >= 1;
- if (on_line and run_start == null) run_start = @max(y, top);
- if (!on_line and run_start != null) {
- ties.anchor(u, .{ .run = run }, .{ .x = 0, .y = run_start.?, .w = box.w, .h = @min(y, box.h - m.pad) - run_start.? });
- run += 1;
- run_start = null;
- }
+ for (&runs, lines_of) |*r, of| r.add(line != null and line.? == of and mark_shows >= 1, @max(y, top), @min(y, box.h - m.pad));
+ // A row wholly above the body (the window it scrolls from or to)
+ // does not take the line number from the first row shown.
+ const above_body = y + m.row <= top + 0.5;
if (y + m.row < m.tag or y > box.h) {
- last_line = line;
+ last_line = if (above_body) null else line;
+ covered -|= 1;
continue;
}
- // `ran`: it ran in one of the last three steps.
- var ran: ?usize = null;
- for (0..3) |k| {
- const at_k = now.stops[@min(base + 1 + k, now.stops.len - 1)];
- if (at_k != now.stops[base] and rec.register(at_k, "rip") == row.addr) {
- ran = k;
- break;
- }
- }
const is_pc = row.addr == pc[if (going >= 0.5) 1 else 0];
- if (ran != null and !is_pc) lit.trail(c.mark, y, ran.?);
- d.insn(lit, now, row, y, box.w, line, line != last_line, current_line, lead, if (is_pc) .current else if (ran) |k| .{ .ran = k } else .ahead, base);
- last_line = line;
- // The jump that brought control here: from its row, up or down the lane.
- if (ran == 0 and !is_pc) if (rec.insn_branches[now.stops[base + 1]]) |b| if (b.kind == .jump and b.taken) {
- lanes[0] = y;
- };
+ const was = if (is_pc) null else ran[j];
+ if (was) |r| lit.trail(c.mark, y, r.k);
+ const hangs = d.insn(lit, now, row, y, box.w, line, line != last_line, current_line, lead, if (is_pc) .current else if (was) |r| .{ .ran = r } else .ahead, base, covered > 0);
+ covered = @max(covered -| 1, hangs);
+ last_line = if (above_body) null else line;
+ if (jumped == row.addr and !is_pc) lanes[0] = y;
if (is_pc) lanes[1] = y;
}
- if (run_start) |y0| ties.anchor(u, .{ .run = run }, .{ .x = 0, .y = y0, .w = box.w, .h = @min(top + (@as(f32, @floatFromInt(merged.len)) - scroll) * m.row, box.h - m.pad) - y0 });
+ const end_y = @min(top + (@as(f32, @floatFromInt(merged.len)) - scroll) * m.row, box.h - m.pad);
+ for (&runs) |*r| r.add(false, end_y, end_y);
+ threadRuns(u, box.w, runs, if (lines_of[0] == lines_of[1]) 1 else cursors.standard(going));
if (lanes[0] != null and lanes[1] != null and lanes[0].? != lanes[1].?) {
const ya = lanes[0].? + m.row / 2;
const yb = lanes[1].? + m.row / 2;
@@ -176,23 +199,32 @@ pub const Disasm = struct {
context.veiled(u, box, now.veil);
}
- const State = union(enum) { current, ran: usize, ahead };
+ const State = union(enum) { current, ran: Ran, ahead };
+ /// A row that ran `k` steps ago (0 newest), last at moment `at`.
+ const Ran = struct { k: usize, at: u64 };
- /// `insn`: an instruction and its annotation, pwndbg's way.
- fn insn(d: *const Disasm, u: ui.Ui, now: cursors.Now, row: Insn, y: f32, w: f32, line: ?u32, first_of_line: bool, current_line: u32, lead: usize, state: State, base: usize) void {
+ /// `insn`: an instruction and its annotation, pwndbg's way. Nothing is
+ /// cut that has room: the operands run on to where the annotation must
+ /// begin to fit (never left of its column), and are cut only there,
+ /// where the annotation carries the address they name. `covered`: a
+ /// call's arguments above hang in this row's annotation column. Returns
+ /// how many rows under it its own arguments hang in.
+ fn insn(d: *const Disasm, u: ui.Ui, now: cursors.Now, row: Insn, y: f32, w: f32, line: ?u32, first_of_line: bool, current_line: u32, lead: usize, state: State, base: usize, covered: bool) usize {
const rec = d.cursor.rec;
const base_y = rows.baseline(y);
const code_ink = theme.color.region.code_;
+ const room = w - m.side;
if (row.outside) {
// The function ends: a rule, and the next one's name.
u.fill(.{ .x = theme.stroke.rule, .y = y, .w = w - 2 * theme.stroke.rule, .h = theme.stroke.rule }, theme.color.rule);
_ = u.address(c.address, base_y, row.addr, .{ .ink = ui.mix(code_ink, theme.color.page, theme.metric.context.lead_alpha) });
u.text(.mono, size, c.mnemonic, base_y, row.mnemonic(), t.faint);
- u.text(.mono, size, c.operands, base_y, clipText(u, row.operands(), c.operand_chars), t.faint);
- if (rec.strings.get(row.addr)) |name| u.text(.mono, size, c.annotation, base_y, name[0 .. std.mem.lastIndexOfScalar(u8, name, '+') orelse name.len], t.faint);
- return;
+ const name = if (rec.strings.get(row.addr)) |n| n[0 .. std.mem.lastIndexOfScalar(u8, n, '+') orelse n.len] else "";
+ const x = if (name.len > 0) annotationX(operandsWidth(row, row.operands()), room, @as(f32, @floatFromInt(name.len)) * adv) else room + gap;
+ u.text(.mono, size, c.operands, base_y, rows.fitted(u, row.operands(), (if (covered) c.annotation else x) - gap - c.operands), t.faint);
+ u.text(.mono, size, x, base_y, name, t.faint);
+ return 0;
}
- const on = state == .current;
_ = u.address(c.address, base_y, row.addr, .{ .ink = ui.rgb(code_ink), .lead = lead });
if (first_of_line) if (line) |l| {
const num = u.print("{d}", .{l});
@@ -200,31 +232,58 @@ pub const Disasm = struct {
u.text(if (now_line) .mono_bold else .mono, size, c.line + 3 * adv - @as(f32, @floatFromInt(num.len)) * adv, base_y, num, if (now_line) theme.mark(.current).solid else t.faint);
};
u.text(.mono_bold, size, c.mnemonic, base_y, row.mnemonic(), theme.color.code.keyword);
- operands(u, row, base_y);
+ // How wide the annotation is, drawn where nothing shows; then where it goes.
+ const need = d.annotation(u.faded(0), now, row, y, c.annotation, std.math.inf(f32), state, base);
+ // When the operands and the annotation do not both fit: the
+ // annotation moves left (never past its column), then a size word
+ // a register already gives goes, then the operands give way.
+ var ops = row.operands();
+ var x = room + gap;
+ if (need.drawn) {
+ const wide = need.end - c.annotation;
+ x = annotationX(operandsWidth(row, ops), room, wide);
+ if (c.operands + operandsWidth(row, ops) + gap > x) if (lean(u, row)) |shorter| {
+ ops = shorter;
+ x = annotationX(operandsWidth(row, ops), room, wide);
+ };
+ }
+ operands(u, row, ops, base_y, (if (covered) @min(x, c.annotation) else x) - gap - c.operands);
+ return if (need.drawn) d.annotation(u, now, row, y, x, room, state, base).hangs else 0;
+ }
+
+ const Note = struct { drawn: bool = false, end: f32 = 0, hangs: usize = 0 };
- // The annotation: what it does, now. What it left behind is shown
- // only where the step ran this instruction alone: a step by line
- // runs others after it, and the state after them is not its doing.
+ /// The annotation: what it does, now, from `x`, cut where `room` ends.
+ /// What it left behind is shown only where the step ran this
+ /// instruction alone: a step by line runs others after it, and the
+ /// state after them is not its doing.
+ fn annotation(d: *const Disasm, u: ui.Ui, now: cursors.Now, row: Insn, y: f32, x: f32, room: f32, state: State, base: usize) Note {
+ const rec = d.cursor.rec;
+ const base_y = rows.baseline(y);
+ const code_ink = theme.color.region.code_;
const moment, var after = switch (state) {
- .current => .{ now.stops[base], if (base == 1) now.stops[0] else null },
- .ran => |k| .{ now.stops[base + 1 + k], now.stops[base + k] },
+ // The moment the mark stands for (at a sprint it waits at a
+ // phrase's end while the steps go on): the pc's row is its.
+ .current => blk: {
+ const marked = now.marks[if (base == 0) 1 else 0];
+ break :blk .{ marked, if (base == 1 and marked == now.stops[1]) now.stops[0] else null };
+ },
+ .ran => |r| .{ r.at, r.at + 1 },
.ahead => .{ now.stops[base], null },
};
if (after) |a| if (!alone(rec, moment, a, row)) {
after = null;
};
- const room = w - m.side;
- const x: f32 = c.annotation;
const branch = if (state == .ahead) null else rec.insn_branches[moment];
const touches = if (state == .ahead) [2]?Recording.Touch{ null, null } else rec.insn_touches[moment];
- _ = on;
if (branch) |b| switch (b.kind) {
.call => {
const callee = rec.strings.get(b.to) orelse "";
- u.text(.mono, size, x, base_y, callee[0 .. std.mem.lastIndexOfScalar(u8, callee, '+') orelse callee.len], t.bright);
+ const callee_name = callee[0 .. std.mem.lastIndexOfScalar(u8, callee, '+') orelse callee.len];
+ u.text(.mono, size, x, base_y, callee_name, t.bright);
+ var note: Note = .{ .drawn = true, .end = x + @as(f32, @floatFromInt(callee_name.len)) * adv };
// Its arguments hang under it, a small `reg` a row, as many as the prototype has.
if (state == .current) {
- const callee_name = callee[0 .. std.mem.lastIndexOfScalar(u8, callee, '+') orelse callee.len];
// As many as the callee's prototype has (the debug info's, else the source's), three when neither says.
const count: usize = row.params orelse for (rec.functions) |fun| {
if (std.mem.eql(u8, fun.name, callee_name)) break fun.params;
@@ -236,34 +295,41 @@ pub const Disasm = struct {
u.text(.mono, size, x, rows.baseline(ry), reg, t.dim);
_ = rows.chain(u, x + 4 * adv, ry, shown_moment, rec.register(moment, reg), room, .{});
}
+ note.hangs = @min(count, 6);
}
- return;
+ return note;
},
.ret => {
u.text(.mono, size, x, base_y, "\u{2192}", t.faint);
- _ = u.address(x + 2 * adv, base_y, b.to, .{ .ink = ui.rgb(code_ink), .name = rec.strings.get(b.to) orelse "" });
- return;
+ return .{ .drawn = true, .end = u.address(x + 2 * adv, base_y, b.to, .{ .ink = ui.rgb(code_ink), .name = rec.strings.get(b.to) orelse "" }) };
},
.jump => {
// A jump always taken says nothing; a conditional one, which way.
- if (std.mem.eql(u8, row.mnemonic(), "jmp")) return;
- if (!b.taken) return u.text(.mono, size, x, base_y, "not taken", t.dim);
- u.text(.mono, size, x, base_y, "taken", t.primary);
- return;
+ if (std.mem.eql(u8, row.mnemonic(), "jmp")) return .{};
+ const said = if (b.taken) "taken" else "not taken";
+ u.text(.mono, size, x, base_y, said, if (b.taken) t.primary else t.dim);
+ return .{ .drawn = true, .end = x + @as(f32, @floatFromInt(said.len)) * adv };
},
.none => {},
};
if (std.mem.eql(u8, row.mnemonic(), "syscall") and state != .ahead) {
const nr = rec.register(moment, "rax");
- u.text(.mono, size, x, base_y, zt.syscalls.name(nr) orelse "syscall", t.bright);
+ const name = zt.syscalls.name(nr) orelse "syscall";
+ u.text(.mono, size, x, base_y, name, t.bright);
const names = zt.syscalls.names(nr);
const carriers = [_][]const u8{ "rdi", "rsi", "rdx" };
- if (state == .current) for (names[0..@min(names.len, 3)], carriers[0..@min(names.len, 3)], 1..) |arg, reg, k| {
+ const n = @min(names.len, 3);
+ if (state == .current) for (names[0..n], carriers[0..n], 1..) |arg, reg, k| {
const ry = y + @as(f32, @floatFromInt(k)) * m.row;
u.text(.mono, size, x, rows.baseline(ry), arg, t.dim);
- _ = rows.chain(u, x + @as(f32, @floatFromInt(arg.len + 1)) * adv, ry, rec.moment(moment), rec.register(moment, reg), room, .{});
+ const ax = x + @as(f32, @floatFromInt(arg.len + 1)) * adv;
+ const value = rec.register(moment, reg);
+ // A descriptor is the `value` class `fd`: what it is open on.
+ if (std.mem.endsWith(u8, arg, "fd")) {
+ _ = u.typed(ax, rows.baseline(ry), value, .{ .fd = rec.openOn(u.f.scratch, value, moment) }, .{});
+ } else _ = rows.chain(u, ax, ry, rec.moment(moment), value, room, .{});
};
- return;
+ return .{ .drawn = true, .end = x + @as(f32, @floatFromInt(name.len)) * adv, .hangs = if (state == .current) n else 0 };
}
// Memory: a chain from the address it computes. Before the step,
// where it will look; in the step its first hop is read (with the
@@ -287,22 +353,79 @@ pub const Disasm = struct {
marks.changed_heat = now.written(touch.addr, touch.len, .memory, 0);
}
};
- _ = rows.chain(u, x, y, shown, touch.addr, room, marks);
- return;
+ return .{ .drawn = true, .end = rows.chain(u, x, y, shown, touch.addr, room, marks).end };
}
// Only a register: a small `reg` of what it left there.
- const reg = written(row) orelse return;
+ const reg = written(row) orelse return .{};
const value_at = switch (state) {
- .ran => after orelse return,
- .current => if (after != null and now.landed(.cpu, 0)) after.? else return,
- .ahead => return,
+ .ran => after orelse return .{},
+ .current => if (after != null and now.landed(.cpu, 0)) after.? else return .{},
+ .ahead => return .{},
};
const value = rec.register(value_at, reg);
u.text(.mono, size, x, base_y, reg, t.dim);
- _ = rows.chain(u, x + @as(f32, @floatFromInt(reg.len + 1)) * adv, y, rec.moment(value_at), value, room, .{});
+ return .{ .drawn = true, .end = rows.chain(u, x + @as(f32, @floatFromInt(reg.len + 1)) * adv, y, rec.moment(value_at), value, room, .{}).end };
}
};
+/// The gap between the operands and the annotation: a character.
+const gap = adv;
+
+/// The runs of rows of one line, top and bottom of each, as the rows go by.
+const Runs = struct {
+ spans: [8][2]f32 = undefined,
+ n: usize = 0,
+ open: ?f32 = null,
+
+ fn add(r: *Runs, on: bool, y: f32, end: f32) void {
+ if (on and r.open == null) r.open = y;
+ if (!on) if (r.open) |y0| {
+ if (r.n < r.spans.len and end > y0) {
+ r.spans[r.n] = .{ y0, end };
+ r.n += 1;
+ }
+ r.open = null;
+ };
+ }
+};
+
+/// The thread's runs, `p` of the way from the line the mark leaves to the
+/// one it goes to: each slides to its partner (by order, the last of the
+/// fewer standing in for the rest), as the source's bracket slides.
+fn threadRuns(u: ui.Ui, w: f32, runs: [2]Runs, p: f32) void {
+ const from = runs[0];
+ const to = runs[1];
+ if (to.n == 0 or p >= 1 or from.n == 0) {
+ const shown = if (p >= 0.5 or from.n == 0) to else from;
+ for (shown.spans[0..shown.n], 0..) |span, k| ties.anchor(u, .{ .run = k }, .{ .x = 0, .y = span[0], .w = w, .h = span[1] - span[0] });
+ return;
+ }
+ for (0..@max(from.n, to.n)) |k| {
+ const a = from.spans[@min(k, from.n - 1)];
+ const b = to.spans[@min(k, to.n - 1)];
+ const y0 = std.math.lerp(a[0], b[0], p);
+ ties.anchor(u, .{ .run = k }, .{ .x = 0, .y = y0, .w = w, .h = std.math.lerp(a[1], b[1], p) - y0 });
+ }
+}
+
+/// Where an annotation `need` wide goes in a row that ends at `room`,
+/// after operands `width` wide: at its column, or a character after the
+/// operands, or (when both do not fit) where it just fits.
+fn annotationX(width: f32, room: f32, need: f32) f32 {
+ return @max(c.annotation, @min(c.operands + width + gap, room - need));
+}
+
+/// The row in `rows` (in address order) of the instruction at `addr`.
+fn rowOf(list: []const Insn, addr: u64) ?usize {
+ var lo: usize = 0;
+ var hi: usize = list.len;
+ while (lo < hi) {
+ const mid = (lo + hi) / 2;
+ if (list[mid].addr < addr) lo = mid + 1 else hi = mid;
+ }
+ return if (lo < list.len and list[lo].addr == addr) lo else null;
+}
+
/// Whether the step from moment `i` to `after` ran the instruction `row`
/// alone: the moment after it is at the next instruction, or where it jumped.
fn alone(rec: *const Recording, i: u64, after: u64, row: Insn) bool {
@@ -313,25 +436,54 @@ fn alone(rec: *const Recording, i: u64, after: u64, row: Insn) bool {
return false;
}
-/// `text` in `chars` characters: cut at its far end, and saying so.
-fn clipText(u: ui.Ui, text: []const u8, chars: usize) []const u8 {
- if (text.len <= chars) return text;
- return u.print("{s}\u{2026}", .{text[0 .. chars - 1]});
+/// A jump's or a call's target, when the disassembler wrote it as one.
+fn target(row: Insn) ?u64 {
+ const ops = row.operands();
+ const mn = row.mnemonic();
+ if (!(mn[0] == 'j' or std.mem.eql(u8, mn, "call")) or !std.mem.startsWith(u8, ops, "0x")) return null;
+ return std.fmt.parseInt(u64, ops[2..], 16) catch null;
}
-/// The operands, as the disassembler writes them, 24 characters; a jump's
-/// or a call's target is an `address` in code's ink.
-fn operands(u: ui.Ui, row: Insn, base_y: f32) void {
- const ops = row.operands();
+/// How wide operands `ops` of `row` are, whole.
+fn operandsWidth(row: Insn, ops: []const u8) f32 {
+ if (target(row)) |to| return @as(f32, @floatFromInt(ui.digits(to))) * adv;
+ return @as(f32, @floatFromInt(ops.len)) * adv;
+}
+
+/// The operands without the size word of a memory operand whose size a
+/// register operand gives (`mov rax, [rbp - 0x28]`): nothing is lost.
+/// Null where there is none to drop.
+fn lean(u: ui.Ui, row: Insn) ?[]const u8 {
const mn = row.mnemonic();
- const branches = mn[0] == 'j' or std.mem.eql(u8, mn, "call");
- if (branches and std.mem.startsWith(u8, ops, "0x")) {
- if (std.fmt.parseInt(u64, ops[2..], 16)) |target| {
- _ = u.address(c.operands, base_y, target, .{ .ink = ui.rgb(theme.color.region.code_) });
- return;
- } else |_| {}
+ // These widen or convert: the register does not give the memory's size.
+ for ([_][]const u8{ "movzx", "movsx", "movsxd", "cvt" }) |w| if (std.mem.startsWith(u8, mn, w)) return null;
+ const ops = row.operands();
+ const ptr = std.mem.indexOf(u8, ops, " ptr ") orelse return null;
+ var word = ptr;
+ while (word > 0 and ops[word - 1] != ' ' and ops[word - 1] != ',') word -= 1;
+ const comma = std.mem.indexOfScalar(u8, ops, ',') orelse return null;
+ const other = std.mem.trim(u8, if (comma < word) ops[0..comma] else ops[comma + 1 ..], " ");
+ if (full(other) == null) return null;
+ return u.print("{s}{s}", .{ ops[0..word], ops[ptr + 5 ..] });
+}
+
+/// The operands `ops`, in `width` units; a jump's or a call's target is
+/// an `address` in code's ink. Cut only at their far end, saying so, and
+/// never inside `[]`: a cut that would fall there falls before the `[`.
+fn operands(u: ui.Ui, row: Insn, ops: []const u8, base_y: f32, width: f32) void {
+ if (target(row)) |to| {
+ _ = u.address(c.operands, base_y, to, .{ .ink = ui.rgb(theme.color.region.code_) });
+ return;
+ }
+ const chars: usize = @intFromFloat(@max(width / adv, 1));
+ if (ops.len <= chars) return u.text(.mono, size, c.operands, base_y, ops, theme.color.code.plain);
+ var cut = chars - 1;
+ if (std.mem.lastIndexOfScalar(u8, ops[0..cut], '[')) |open| {
+ if (std.mem.indexOfScalarPos(u8, ops, open, ']') orelse ops.len >= cut) cut = open;
}
- u.text(.mono, size, c.operands, base_y, clipText(u, ops, c.operand_chars), theme.color.code.plain);
+ while (cut > 0 and ops[cut - 1] == ' ') cut -= 1;
+ u.text(.mono, size, c.operands, base_y, ops[0..cut], theme.color.code.plain);
+ u.text(.mono, size, c.operands + @as(f32, @floatFromInt(cut)) * adv, base_y, "\u{2026}", t.faint);
}
/// The register an instruction leaves a value in, if that is all it does