summaryrefslogtreecommitdiff
path: root/anim/src/hexdump.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-10 22:02:01 -0300
committerGabriel Schneider <[email protected]>2026-11-10 22:06:03 -0300
commit8b5d0340c9f9b3168c67f04e57cfa03712ac992c (patch)
tree66891f03e905731b8afa2689e86fe612675f4f35 /anim/src/hexdump.zig
parent36bb1c332a124cb4d437dd8386b267ee58310a5d (diff)
downloadcomputeranim-8b5d0340c9f9b3168c67f04e57cfa03712ac992c.tar.gz
computeranim-8b5d0340c9f9b3168c67f04e57cfa03712ac992c.zip
canim: a continue is a wave; what arrives after a fade is plain; a pin only where its register points
From the designer's review of the SQLite scene. Between far stops the changed registers strike two frames apart in pwndbg's order, and links and pins set off with memory. A stack window or a dump that fades in carries no marks of changes the viewer did not see. At rest a moved register kept a pin at its old place as well, in every scene: gone. The kernel's answer is filled before the return arrow leaves, and rax strikes as it lands. Every dump has one reading, by type (a char quoted, a bool by name); line numbers are as wide as the program's largest; pins' names keep the side they came to. Names and measures follow the catalogue (.loose, theme.metric.calls, time.pin, time.continue_wave). Co-Authored-By: Claude Fable 5.2 <[email protected]>
Diffstat (limited to 'anim/src/hexdump.zig')
-rw-r--r--anim/src/hexdump.zig251
1 files changed, 155 insertions, 96 deletions
diff --git a/anim/src/hexdump.zig b/anim/src/hexdump.zig
index b98d9bd..fba212d 100644
--- a/anim/src/hexdump.zig
+++ b/anim/src/hexdump.zig
@@ -1,11 +1,12 @@
//! `hexdump` (design/README.md, "3. Panels"): memory as `bytes` rows,
//! sixteen a row, the right half of a lens: the pane its drawing is a view
//! of. A window of the region kept round the rows the step touches (five
-//! beside, nine as the subject), in address order; a gap in the addresses
+//! beside, seven as the subject), in address order; a gap in the addresses
//! is one row of `more`'s dots and the count left out. Each row's runs
//! come from the types of what the program's pointers reach: a field's
-//! bytes on raised paper in its ink, the allocator's dim, never read two
-//! dots; and its reading at 640: what the runs read as, little-endian.
+//! bytes on raised paper in its ink, `loose` ones (the allocator's, a
+//! struct's padding) dim, never read two dots; and its reading at 640:
+//! what the runs read as, a list a character apart.
//! Bytes a step wrote are struck here before the drawing reacts.
//! Reads `Moment.read`, `Moment.allocation`, and the recording's types.
const std = @import("std");
@@ -23,22 +24,23 @@ const b = theme.metric.bytes;
const adv = theme.size.mono.context * 3 / 5;
/// What a word of the region is.
-pub const Kind = enum { number, pointer, allocator, unread };
+pub const Kind = enum { number, pointer, loose, unread };
-/// The kind of the word at `addr`: a field of a struct the program's
-/// pointers reach (by its type), other allocated bytes, the allocator's
-/// own between allocations, or never observed.
-pub fn kindOf(things: []const objects.Object, moment: Recording.Moment, addr: u64) Kind {
+/// The kind of the word at `addr`, and its type where a field's is known:
+/// a field of a struct the program's pointers reach (by its type), other
+/// allocated bytes, `loose` (the allocator's own between allocations), or
+/// never observed.
+pub fn kindOf(things: []const objects.Object, moment: Recording.Moment, addr: u64) struct { Kind, ?Recording.types.Type } {
for (things) |o| {
if (!o.holds(addr)) continue;
- for (o.type.record.fields) |field| if (o.addr + field.offset == addr) return if (field.type == .pointer) .pointer else .number;
- return .number;
+ for (o.type.record.fields) |field| if (o.addr + field.offset == addr) return .{ if (field.type == .pointer) .pointer else .number, field.type };
+ return .{ .number, null };
}
var bytes: [8]u8 = undefined;
var known: [8]bool = undefined;
- moment.read(addr, &bytes, &known) catch return .unread;
- if (std.mem.indexOfScalar(bool, &known, true) == null) return .unread;
- return if ((moment.allocation(addr) catch null) != null) .number else .allocator;
+ moment.read(addr, &bytes, &known) catch return .{ .unread, null };
+ if (std.mem.indexOfScalar(bool, &known, true) == null) return .{ .unread, null };
+ return .{ if ((moment.allocation(addr) catch null) != null) .number else .loose, null };
}
/// The rows of a region (`lo .. hi`, sixteen-aligned) a dump of `count`
@@ -57,10 +59,11 @@ pub fn window(now: cursors.Now, lo: u64, hi: u64, count: usize) u64 {
}
/// What a dump is of: the structs a drawing beside it draws, or an array
-/// of numbers (an element a run), and the ink of the memory it is in.
+/// of numbers (an element a run, read as its type), and the ink of the
+/// memory it is in.
pub const Of = struct {
things: []const objects.Object = &.{},
- array: ?struct { addr: u64, len: u64, elem: u8 } = null,
+ array: ?struct { addr: u64, len: u64, elem: u8, type: ?Recording.types.Type = null } = null,
region: u24 = theme.color.region.heap,
};
@@ -93,6 +96,9 @@ pub const Dump = struct {
legend: []const ui.Legend = &.{},
of: Fields,
marks: []const @import("anim").Value = &.{},
+ /// The stop it comes in at: what changed before then, the viewer did
+ /// not see change, and it is plain.
+ since: u64 = 0,
pub fn draw(d: *const Dump, f: *@import("sketch").Frame, placed: @import("anim").Placed) void {
const v = panel(f, placed, d.stage, d.about, d.legend);
@@ -100,6 +106,8 @@ pub const Dump = struct {
if (v.rows == 0) return;
const now = d.cursor.now(placed);
var of = d.of;
+ of.watched = 0;
+ while (of.watched + 1 < now.stops.len and now.stops[of.watched + 1] >= d.since) of.watched += 1;
var shows: [8]f32 = @splat(0);
const marked = @min(d.marks.len, shows.len);
for (d.marks[0..marked], shows[0..marked]) |mark, *value| value.* = placed.value(mark);
@@ -144,6 +152,8 @@ pub fn draw(u: ui.Ui, now: cursors.Now, x: f32, y: f32, first: u64, count: usize
const v = u.moved(x, 0);
const moment = now.shown(.memory);
const lead = ui.shared(&.{ first, first + 16 * @as(u64, count -| 1) });
+ // Room for the addresses, once for the dump: by its widest.
+ const shift = rows.addressRoom(first + 16 * @as(u64, count -| 1));
for (0..count) |i| {
const addr = first + 16 * i;
const ry = y + @as(f32, @floatFromInt(i)) * m.row;
@@ -151,15 +161,18 @@ pub fn draw(u: ui.Ui, now: cursors.Now, x: f32, y: f32, first: u64, count: usize
var known: [16]bool = undefined;
moment.read(addr, &values, &known) catch return;
var runs: [16]rows.Run = undefined;
+ var readings: [16]Field = undefined;
var n: usize = 0;
var holds_drawn = false;
var at: u64 = 0;
while (at < 16) {
const here = addr + at;
var run: rows.Run = .{ .first = @intCast(at), .len = 8, .kind = .unread };
+ var kind: ?Recording.types.Type = null;
if (of.array) |arr| if (here >= arr.addr and here < arr.addr + arr.len) {
run.len = arr.elem;
run.kind = .number;
+ kind = arr.type;
holds_drawn = true;
};
if (run.kind == .unread) {
@@ -168,10 +181,11 @@ pub fn draw(u: ui.Ui, now: cursors.Now, x: f32, y: f32, first: u64, count: usize
if (of.array) |arr| if (here < arr.addr and arr.addr < here + run.len) {
run.len = @intCast(arr.addr - here);
};
- run.kind = switch (kindOf(of.things, moment, here)) {
+ const word, kind = kindOf(of.things, moment, here);
+ run.kind = switch (word) {
.number => .number,
.pointer => .pointer,
- .allocator => .allocator,
+ .loose => .loose,
.unread => .unread,
};
for (of.things) |o| if (o.holds(here)) {
@@ -180,51 +194,23 @@ pub fn draw(u: ui.Ui, now: cursors.Now, x: f32, y: f32, first: u64, count: usize
}
run.heat = now.written(here, run.len, .memory, 0);
if (now.wasRead(here, run.len) and now.writeAge(here, run.len) != 0) run.read = now.reading(.memory, 0);
- if (run.kind == .number or run.kind == .pointer) ties.anchor(v, .{ .dump_run = here }, .{ .x = rows.byteX(run.first) - 4, .y = ry, .w = rows.byteX(run.first + run.len - 1) + 28 - rows.byteX(run.first) + 4, .h = m.row });
+ if (run.kind == .number or run.kind == .pointer) ties.anchor(v, .{ .dump_run = here }, .{ .x = shift + rows.byteX(run.first) - 4, .y = ry, .w = rows.byteX(run.first + run.len - 1) + 28 - rows.byteX(run.first) + 4, .h = m.row });
+ readings[n] = .{ .at = run.first, .len = run.len, .reads = switch (run.kind) {
+ .number => .number,
+ .pointer => .pointer,
+ else => .bytes,
+ }, .type = kind };
runs[n] = run;
n += 1;
at += run.len;
}
- rows.bytes(v, ry, addr, &values, &known, runs[0..n], of.region, lead, holds_drawn, moment);
- reading(v, ry, addr, moment, &values, &known, runs[0..n]);
- }
-}
-
-/// The reading: what the runs read as, little-endian. A number ranged
-/// right in three characters; a pointer as `points` and its address;
-/// `NULL` dim; an allocator's run as a note, faint.
-fn reading(u: ui.Ui, y: f32, addr: u64, moment: Recording.Moment, values: *const [16]u8, known: *const [16]bool, runs: []const rows.Run) void {
- const size = theme.size.mono.context;
- const base = rows.baseline(y);
- var x: f32 = b.reading;
- for (runs) |run| {
- var bytes: [8]u8 = @splat(0);
- @memcpy(bytes[0..run.len], values[run.first..][0..run.len]);
- const word = std.mem.readInt(u64, &bytes, .little);
- const whole = std.mem.indexOfScalar(bool, known[run.first..][0..run.len], false) == null;
- if (!whole) continue;
- switch (run.kind) {
- .number => {
- // A field typed a number reads as its decimal.
- const shift: u6 = @intCast(64 - 8 * @as(u32, @min(run.len, 8)));
- const digits = u.print("{d}", .{@as(i64, @bitCast(word << shift)) >> shift});
- const w = @as(f32, @floatFromInt(digits.len)) * adv;
- u.text(.mono, size, x + @max(3 * adv - w, 0), base, digits, t.primary);
- x += @max(3 * adv, w) + 8;
- },
- .pointer => if (word == 0) {
- u.text(.mono, size, x + theme.metric.context.arrow_w, base, "NULL", t.dim);
- x += theme.metric.context.arrow_w + 4 * adv + 8;
- } else {
- x = u.arrow(x, y + m.row / 2, .points);
- x = u.address(x, base, word, .{ .ink = ui.rgb(rows.ink(rows.regionOf(moment, word))) }) + 8;
- },
- .allocator => if (run.first == 8 and run.len == 8 and chunkAfter(moment, addr + 8)) {
- // The size word of the chunk after: malloc's.
- u.text(.sans, theme.size.sans.micro, x, base - 1, u.print("malloc's: a chunk of {d}", .{word & ~@as(u64, 7)}), t.faint);
- return;
- },
- .text, .unread => {},
+ rows.bytesAt(v, ry, addr, &values, &known, runs[0..n], of.region, lead, holds_drawn, moment, shift);
+ const end = reading(v, ry, shift, moment, &values, &known, readings[0..n]);
+ // The size word of the chunk after: malloc's, a note after the reading.
+ const last = runs[n - 1];
+ if (last.kind == .loose and last.first == 8 and last.len == 8 and std.mem.indexOfScalar(bool, known[8..], false) == null and chunkAfter(moment, addr + 8)) {
+ const size = std.mem.readInt(u64, values[8..16], .little) & ~@as(u64, 7);
+ v.text(.sans, theme.size.sans.micro, end, rows.baseline(ry) - 1, v.print("malloc's: a chunk of {d}", .{size}), t.faint);
}
}
}
@@ -251,6 +237,9 @@ pub const Field = struct {
big: bool = false,
/// Which of the view's marks frames it as read (`Fields.marks`).
mark: ?u8 = null,
+ /// A number's type, where the debug info gives it: read as the lens's
+ /// values are (`objects.reading`: a `char` quoted, a `bool` by name).
+ type: ?Recording.types.Type = null,
};
/// What a dump of fields is of, and how it is marked now.
@@ -272,46 +261,108 @@ pub const Fields = struct {
/// pointer leads, 32 bytes at a stop; elsewhere its last seen bytes may
/// be long out of date, and are drawn as not seen.
seen: ?Recording.Span = null,
+ /// How many of the newest steps it has been on screen through: only
+ /// their changes are marked.
+ watched: usize = std.math.maxInt(usize),
};
/// The region's rows in view `v`, from `y`, sixteen bytes a row from its
/// first byte: those that hold a field (all of them, where they fit), and
/// for a stretch left out one row of `more`'s dots and how many rows it
-/// stands for. A field is a run, cut where a row ends; a byte that is no
-/// field is drawn as the allocator's (dim, no paper) and reads as nothing.
+/// stands for. More rows of fields than the window: it is kept round the
+/// first row a mark or the step is on, and the others are `more` rows too.
+/// A field is a run, cut where a row ends; a byte that is no field is
+/// `loose` (dim, no paper) and reads as nothing.
pub fn fielded(v: View, now: cursors.Now, y: f32, of: Fields) void {
const u = v.u;
const moment = now.shown(.memory);
const total = (of.len + 15) / 16;
- var shown: [16]u64 = undefined;
- var n: usize = 0;
- for (0..total) |r| {
- const lo = of.base + 16 * r;
- const holds = for (of.fields) |field| {
- if (of.base + field.at < lo + 16 and of.base + field.at + field.len > lo) break true;
- } else false;
- if ((holds or total <= v.rows) and n < shown.len) {
- shown[n] = r;
- n += 1;
- }
- }
+ var held: std.ArrayList(u64) = .empty;
+ for (0..total) |r| if (total <= v.rows or holdsField(of, r)) held.append(u.f.scratch, r) catch return;
+ const all = held.items;
+ if (all.len == 0) return;
+ const range = keep(all, focus(now, of, all), v.rows, total - 1);
+ const shown = all[range[0]..range[1]];
const lead = ui.shared(&.{ of.base, of.base + 16 * (total -| 1) });
+ // Room for the addresses, once for the dump: by the widest it shows.
+ const shift = rows.addressRoom(of.base + 16 * shown[shown.len - 1]);
+ const more = struct {
+ fn row(at: ui.Ui, ry: f32, count: u64) void {
+ const after = at.arrow(b.address, ry + m.row / 2, .more);
+ at.text(.mono, theme.size.mono.context, after + adv, rows.baseline(ry), at.print("{d} rows", .{count}), t.faint);
+ }
+ }.row;
var ry = y;
var last: ?u64 = null;
- for (shown[0..n]) |r| {
- if (last) |l| if (r > l + 1) {
- // A stretch left out: one row, three dots and a count.
- const after = u.arrow(b.address, ry + m.row / 2, .more);
- u.text(.mono, theme.size.mono.context, after + adv, rows.baseline(ry), u.print("{d} rows", .{r - l - 1}), t.faint);
+ for (shown) |r| {
+ // A stretch left out: one row, three dots and a count.
+ const gap = if (last) |l| r - l - 1 else r;
+ if (gap > 0) {
+ more(u, ry, gap);
ry += m.row;
- };
+ }
last = r;
- fieldRow(u, now, ry, of.base + 16 * r, moment, of, lead);
+ fieldRow(u, now, ry, of.base + 16 * r, moment, of, lead, shift);
ry += m.row;
}
+ if (shown[shown.len - 1] < total - 1) more(u, ry, total - 1 - shown[shown.len - 1]);
+}
+
+/// Which of `rs` (rows of fields, the region's last row `last`) a window
+/// of `room` rows shows: as many as fit round `rs[focus_at]`, each row a
+/// line and each stretch left out (before, between, after) a `more` line.
+fn keep(rs: []const u64, focus_at: usize, room: usize, last: u64) [2]usize {
+ const lines = struct {
+ fn count(all: []const u64, lo: usize, hi: usize, end: u64) usize {
+ var n = hi - lo + @intFromBool(all[lo] > 0) + @intFromBool(all[hi - 1] < end);
+ for (all[lo .. hi - 1], all[lo + 1 .. hi]) |a, b2| n += @intFromBool(b2 > a + 1);
+ return n;
+ }
+ }.count;
+ var lo = focus_at;
+ var hi = lo + 1;
+ while (true) {
+ const before = hi - lo;
+ if (hi < rs.len and lines(rs, lo, hi + 1, last) <= room) hi += 1;
+ if (lo > 0 and lines(rs, lo - 1, hi, last) <= room) lo -= 1;
+ if (hi - lo == before) break;
+ }
+ return .{ lo, hi };
+}
+
+test "a dump of more rows of fields than its window keeps those round its focus" {
+ // A page's header row, then two cells at its end: all fit in seven.
+ try std.testing.expectEqual([2]usize{ 0, 3 }, keep(&.{ 0, 254, 255 }, 0, 7, 255));
+ // Ten rows with gaps, a window of five round the sixth: two rows, a `more` before, between and after.
+ const spread = [_]u64{ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18 };
+ try std.testing.expectEqual([2]usize{ 5, 7 }, keep(&spread, 5, 5, 18));
+ // Rows next to each other, the window of five round the last: four rows and a `more` before.
+ const run = [_]u64{ 0, 1, 2, 3, 4, 5, 6, 7 };
+ try std.testing.expectEqual([2]usize{ 4, 8 }, keep(&run, 7, 5, 7));
}
-fn fieldRow(u: ui.Ui, now: cursors.Now, y: f32, addr: u64, moment: Recording.Moment, of: Fields, lead: usize) void {
+/// Whether row `r` of the region holds a field.
+fn holdsField(of: Fields, r: u64) bool {
+ const lo = of.base + 16 * r;
+ for (of.fields) |field| if (of.base + field.at < lo + 16 and of.base + field.at + field.len > lo) return true;
+ return false;
+}
+
+/// Which of `rs` (rows of fields) the window is kept round: the first a
+/// mark shows on, else the first the step wrote or read, else the first.
+fn focus(now: cursors.Now, of: Fields, rs: []const u64) usize {
+ for (rs, 0..) |r, k| for (of.fields) |field| {
+ if (field.at >= 16 * r + 16 or field.at + field.len <= 16 * r) continue;
+ if (field.mark) |i| if (i < of.marks.len and of.marks[i] > 0) return k;
+ };
+ for (rs, 0..) |r, k| {
+ const span: Recording.Span = .{ .addr = of.base + 16 * r, .len = 16 };
+ if (Recording.touches(now.rec.written(now.stops[1], now.stops[0]), span.addr, span.len) or Recording.touches(now.rec.read(now.stops[1], now.stops[0]), span.addr, span.len)) return k;
+ }
+ return 0;
+}
+
+fn fieldRow(u: ui.Ui, now: cursors.Now, y: f32, addr: u64, moment: Recording.Moment, of: Fields, lead: usize, shift: f32) void {
var values: [16]u8 = undefined;
var known: [16]bool = undefined;
moment.read(addr, &values, &known) catch return;
@@ -336,7 +387,6 @@ fn fieldRow(u: ui.Ui, now: cursors.Now, y: f32, addr: u64, moment: Recording.Mom
given_from = @min(given_from, @as(u8, @intCast(i)));
given_to = @max(given_to, @as(u8, @intCast(i)));
};
- const shift = rows.addressRoom(addr);
var runs: [16]rows.Run = undefined;
var readings: [16]Field = undefined;
var n: usize = 0;
@@ -346,7 +396,7 @@ fn fieldRow(u: ui.Ui, now: cursors.Now, y: f32, addr: u64, moment: Recording.Mom
const field = for (of.fields) |field| {
if (of.base + field.at <= here and here < of.base + field.at + field.len) break field;
} else null;
- var run: rows.Run = .{ .first = at, .len = 1, .kind = .allocator };
+ var run: rows.Run = .{ .first = at, .len = 1, .kind = .loose };
if (field) |fl| {
run.len = @intCast(@min(of.base + fl.at + fl.len - here, 16 - @as(u64, at)));
run.kind = switch (fl.reads) {
@@ -354,14 +404,14 @@ fn fieldRow(u: ui.Ui, now: cursors.Now, y: f32, addr: u64, moment: Recording.Mom
.pointer => .pointer,
.text => .text,
};
- run.heat = now.written(here, run.len, .memory, 0);
+ run.heat = now.writtenWatched(here, run.len, .memory, 0, 0, of.watched);
var framed: f32 = 0;
if (fl.mark) |k| if (k < of.marks.len) {
framed = of.marks[k];
};
- if (now.wasRead(here, run.len) and now.writeAge(here, run.len) != 0) framed = @max(framed, now.reading(.memory, 0));
+ if (of.watched > 0 and now.wasRead(here, run.len) and now.writeAge(here, run.len) != 0) framed = @max(framed, now.reading(.memory, 0));
run.read = framed;
- readings[n] = .{ .at = at, .len = run.len, .reads = fl.reads, .big = fl.big };
+ readings[n] = .{ .at = at, .len = run.len, .reads = fl.reads, .big = fl.big, .type = fl.type };
ties.anchor(u, .{ .dump_run = here }, .{ .x = shift + rows.byteX(run.first) - 4, .y = y, .w = rows.byteX(run.first + run.len - 1) + 28 - rows.byteX(run.first) + 4, .h = m.row });
} else {
// Up to the next field, or the row's end.
@@ -382,33 +432,41 @@ fn fieldRow(u: ui.Ui, now: cursors.Now, y: f32, addr: u64, moment: Recording.Mom
if (gives and shows > 0) {
if (shows < 1) rows.bytesAt(u.faded(1 - shows), y, addr, &values, &known, runs[0..n], of.region, lead, true, moment, shift);
rows.bytesAt(u.faded(shows), y, addr, &given_values, &given_known, runs[0..n], of.region, lead, true, moment, shift);
- fieldReading(u.faded(shows), y, shift, moment, &given_values, &given_known, readings[0..n]);
+ _ = reading(u.faded(shows), y, shift, moment, &given_values, &given_known, readings[0..n]);
} else {
rows.bytesAt(u, y, addr, &values, &known, runs[0..n], of.region, lead, true, moment, shift);
- fieldReading(u, y, shift, moment, &values, &known, readings[0..n]);
+ _ = reading(u, y, shift, moment, &values, &known, readings[0..n]);
}
}
-/// The reading of a row of fields, left to right, a character apart: a
-/// number in decimal, a pointer as `points` and its address, text in
-/// quotes; bytes left to the eye read as nothing. Cut where the panel
-/// ends, with `…`.
-fn fieldReading(u: ui.Ui, y: f32, shift: f32, moment: Recording.Moment, values: *const [16]u8, known: *const [16]bool, fields: []const Field) void {
+/// `bytes`'s reading, for every dump: what a row's runs (`fields`, from
+/// the row's first byte) read as, left to right, a character apart, from
+/// 508 after the first byte (`shift` right of 640): a number in decimal,
+/// in its byte order, or as its type says (`objects.reading`: a `char`
+/// quoted, a `bool` by name); a pointer as `points` and its address,
+/// `NULL` dim; text in quotes, C's escapes; bytes left to the eye, or
+/// `loose`, as nothing. Cut where the panel ends, with `…`. Returns where
+/// it ends.
+pub fn reading(u: ui.Ui, y: f32, shift: f32, moment: Recording.Moment, values: *const [16]u8, known: *const [16]bool, fields: []const Field) f32 {
const size = theme.size.mono.context;
const base = rows.baseline(y);
const room = theme.layout.state.w - theme.metric.context.side;
var x: f32 = b.reading + shift;
for (fields) |fl| {
const first: usize = @intCast(fl.at);
- const len: usize = @intCast(fl.len);
- if (fl.reads == .bytes) continue;
+ // A typed number is as wide as its type (an `int` in a word: 4 bytes).
+ const len: usize = @intCast(if (fl.type) |ty| @min(fl.len, ty.size() orelse fl.len) else fl.len);
+ if (fl.reads == .bytes or len == 0) continue;
if (std.mem.indexOfScalar(bool, known[first..][0..len], false) != null) continue;
const bytes = values[first..][0..len];
const words: []const u8 = switch (fl.reads) {
.number => blk: {
var word: u64 = 0;
for (0..@min(len, 8)) |k| word |= @as(u64, bytes[if (fl.big) len - 1 - k else k]) << @intCast(8 * k);
- break :blk u.print("{d}", .{word});
+ const ty = fl.type orelse break :blk u.print("{d}", .{word});
+ const shift_bits: u6 = @intCast(64 - 8 * @as(u64, @min(len, 8)));
+ const signed = ty == .scalar and ty.scalar.kind == .int;
+ break :blk objects.reading(u.f.scratch, if (signed) @as(i64, @bitCast(word << shift_bits)) >> shift_bits else @bitCast(word), ty);
},
.pointer => blk: {
var word: u64 = 0;
@@ -427,9 +485,10 @@ fn fieldReading(u: ui.Ui, y: f32, shift: f32, moment: Recording.Moment, values:
const shown = if (fits) words else rows.fitted(u, words, room - x);
const ink = if (fl.reads == .text) theme.color.string else if (std.mem.eql(u8, words, "NULL")) t.dim else t.primary;
u.text(.mono, size, x, base, shown, ink);
- if (!fits) return;
+ if (!fits) return room;
x += w + adv;
}
+ return x;
}
/// Bytes as C text, in quotes: the printable as they are, the rest by C's