path: root/9proc/src/vars.zig

//! Comptime value renderers for /vars. For a type T, `vtableFor(T)` builds (at
//! comptime) a flat table of the files and directories that describe a value of
//! that type:
//!
//!     <var>/value   rendered text            <var>/type   @typeName
//!     <var>/size    @sizeOf                  <var>/addr   0x…
//!     <var>/raw     the bytes                <var>/f/<field>/...   recursively (depth <= max_depth)
//!
//! The core serves a variable by walking this table; a node index is the whole
//! state it needs. Rendering writes into a `*std.Io.Writer` and never allocates.
//! Writes to scalar `value` files are plain stores (not atomic).
const std = @import("std");
const Writer = std.Io.Writer;

/// Deepest `f/` nesting: /vars/x/f/a/f/b/f/c/f/d/value is depth 4.
pub const max_depth: u8 = 4;
/// Longest string rendered from a `[]const u8` / `[*:0]const u8` before "…".
pub const max_string: usize = 256;
/// Most array/slice elements rendered before "…".
pub const max_elems: usize = 64;

pub const Kind = enum(u8) {
    /// The directory of a value: value, type, size, addr, raw, [f].
    dir,
    /// Rendered text; writable when `set` is non-null.
    value,
    /// @typeName, static content.
    type_name,
    /// @sizeOf, static content.
    size,
    /// "0x…" of the value's address.
    addr,
    /// The bytes of the value, length = size.
    raw,
    /// The `f` directory: one `dir` per struct field.
    fields,
};

pub const RenderFn = *const fn (base: [*]const u8, w: *Writer) Writer.Error!void;
pub const SetFn = *const fn (base: [*]u8, text: []const u8) SetError!void;
pub const SetError = error{ Invalid, Unsupported };

/// One node of a type's tree. Children occupy `first..first+count`.
pub const Node = struct {
    name: []const u8,
    kind: Kind,
    parent: u32,
    first: u32 = 0,
    count: u32 = 0,
    /// Byte offset of the described value from the variable's base address.
    offset: usize,
    /// @sizeOf the described value.
    size: usize,
    /// Static text for `type_name` and `size` leaves.
    content: []const u8 = "",
    render: ?RenderFn = null,
    set: ?SetFn = null,

    pub fn isDir(n: Node) bool {
        return n.kind == .dir or n.kind == .fields;
    }

    pub fn writable(n: Node) bool {
        return n.kind == .value and n.set != null;
    }
};

pub const VTable = struct {
    nodes: []const Node,
    type_name: []const u8,
    size: usize,

    /// The child of `dir` named `name`, if any.
    pub fn child(vt: *const VTable, dir: u32, name: []const u8) ?u32 {
        const d = vt.nodes[dir];
        for (d.first..d.first + d.count) |i| {
            if (std.mem.eql(u8, vt.nodes[i].name, name)) return @intCast(i);
        }
        return null;
    }
};

/// The comptime-generated table for `T`; the same pointer for the same `T`.
pub fn vtableFor(comptime T: type) *const VTable {
    const S = struct {
        const nodes = buildTable(T);
        const vt: VTable = .{ .nodes = &nodes, .type_name = @typeName(T), .size = @sizeOf(T) };
    };
    return &S.vt;
}

/// Whether a struct's fields get an `f/` directory at this depth.
fn hasFields(comptime T: type, depth: u8) bool {
    if (depth >= max_depth) return false;
    return switch (@typeInfo(T)) {
        .@"struct" => |s| s.layout != .@"packed" and fieldCount(T) > 0,
        else => false,
    };
}

fn fieldCount(comptime T: type) usize {
    var n: usize = 0;
    for (@typeInfo(T).@"struct".fields) |f| {
        if (!f.is_comptime and @sizeOf(f.type) != 0) n += 1;
    }
    return n;
}

fn countNodes(comptime T: type, depth: u8) usize {
    var n: usize = 6; // dir + value, type, size, addr, raw
    if (hasFields(T, depth)) {
        n += 1; // f
        for (@typeInfo(T).@"struct".fields) |f| {
            if (f.is_comptime or @sizeOf(f.type) == 0) continue;
            n += countNodes(f.type, depth + 1);
        }
    }
    return n;
}

fn fill(nodes: []Node, next: *usize, idx: usize, comptime T: type, name: []const u8, offset: usize, depth: u8, parent: u32) void {
    const with_fields = hasFields(T, depth);
    const count: u32 = if (with_fields) 6 else 5;
    const first = next.*;
    next.* += count;
    nodes[idx] = .{ .name = name, .kind = .dir, .parent = parent, .first = @intCast(first), .count = count, .offset = offset, .size = @sizeOf(T) };
    const me: u32 = @intCast(idx);
    nodes[first + 0] = .{ .name = "value", .kind = .value, .parent = me, .offset = offset, .size = @sizeOf(T), .render = renderFor(T), .set = setFor(T) };
    nodes[first + 1] = .{ .name = "type", .kind = .type_name, .parent = me, .offset = offset, .size = @sizeOf(T), .content = @typeName(T) };
    nodes[first + 2] = .{ .name = "size", .kind = .size, .parent = me, .offset = offset, .size = @sizeOf(T), .content = std.fmt.comptimePrint("{d}", .{@sizeOf(T)}) };
    nodes[first + 3] = .{ .name = "addr", .kind = .addr, .parent = me, .offset = offset, .size = @sizeOf(T) };
    nodes[first + 4] = .{ .name = "raw", .kind = .raw, .parent = me, .offset = offset, .size = @sizeOf(T) };
    if (with_fields) {
        const fdir: u32 = @intCast(first + 5);
        const nf = fieldCount(T);
        const ffirst = next.*;
        next.* += nf;
        nodes[fdir] = .{ .name = "f", .kind = .fields, .parent = me, .first = @intCast(ffirst), .count = @intCast(nf), .offset = offset, .size = @sizeOf(T) };
        var i: usize = 0;
        for (@typeInfo(T).@"struct".fields) |f| {
            if (f.is_comptime or @sizeOf(f.type) == 0) continue;
            fill(nodes, next, ffirst + i, f.type, f.name, offset + @offsetOf(T, f.name), depth + 1, fdir);
            i += 1;
        }
    }
}

fn buildTable(comptime T: type) [countNodes(T, 0)]Node {
    @setEvalBranchQuota(1_000_000);
    var nodes: [countNodes(T, 0)]Node = undefined;
    var next: usize = 1;
    fill(&nodes, &next, 0, T, "", 0, 0, 0);
    std.debug.assert(next == nodes.len);
    return nodes;
}

fn renderFor(comptime T: type) RenderFn {
    return &struct {
        fn f(base: [*]const u8, w: *Writer) Writer.Error!void {
            const p: *const T = @ptrCast(@alignCast(base));
            try render(p, w, max_depth);
        }
    }.f;
}

fn setFor(comptime T: type) ?SetFn {
    if (!settable(T)) return null;
    return &struct {
        fn f(base: [*]u8, text: []const u8) SetError!void {
            const p: *T = @ptrCast(@alignCast(base));
            try set(p, text);
        }
    }.f;
}

fn settable(comptime T: type) bool {
    return switch (@typeInfo(T)) {
        .int, .float, .bool, .@"enum" => true,
        else => false,
    };
}

// ---------------------------------------------------------------------------
// Rendering
// ---------------------------------------------------------------------------

/// Renders `ptr.*`. Structs become "field: value" lines (nested structs
/// indented); everything else is a single line without a trailing newline.
/// `depth` bounds struct/union/optional nesting; deeper values print as "…".
pub fn render(ptr: anytype, w: *Writer, depth: usize) Writer.Error!void {
    const T = @TypeOf(ptr.*);
    if (comptime isPlainStruct(T)) {
        try renderStruct(T, ptr, w, depth, 0);
    } else {
        try renderValue(T, ptr, w, depth);
    }
}

fn isPlainStruct(comptime T: type) bool {
    return switch (@typeInfo(T)) {
        .@"struct" => |s| !s.is_tuple and s.fields.len > 0,
        else => false,
    };
}

/// The multi-line form: each field on its own line, nested structs indented.
fn renderStruct(comptime T: type, ptr: *const T, w: *Writer, depth: usize, indent: usize) Writer.Error!void {
    if (depth == 0) {
        try w.splatByteAll(' ', indent);
        try w.writeAll("…\n");
        return;
    }
    const packed_layout = @typeInfo(T).@"struct".layout == .@"packed";
    inline for (@typeInfo(T).@"struct".fields) |f| {
        try w.splatByteAll(' ', indent);
        try w.writeAll(f.name);
        try w.writeByte(':');
        if (comptime f.is_comptime) {
            try w.writeAll(" (comptime)\n");
        } else if (comptime packed_layout) {
            // Fields of a packed struct have no byte address: render a copy.
            const v = @field(ptr.*, f.name);
            try w.writeByte(' ');
            try renderValue(f.type, &v, w, depth - 1);
            try w.writeByte('\n');
        } else if (comptime isPlainStruct(f.type)) {
            try w.writeByte('\n');
            try renderStruct(f.type, &@field(ptr.*, f.name), w, depth - 1, indent + 2);
        } else {
            try w.writeByte(' ');
            try renderValue(f.type, &@field(ptr.*, f.name), w, depth - 1);
            try w.writeByte('\n');
        }
    }
}

/// The single-line form of any value.
fn renderValue(comptime T: type, ptr: *const T, w: *Writer, depth: usize) Writer.Error!void {
    switch (@typeInfo(T)) {
        .int, .comptime_int => try w.print("{d}", .{ptr.*}),
        .float, .comptime_float => try w.print("{d}", .{ptr.*}),
        .bool => {
            // The variable is live memory that anything (a debugger's /mem write,
            // a torn update) may have corrupted: judge the byte, not the bool.
            const b = @as(*const u8, @ptrCast(ptr)).*;
            switch (b) {
                0 => try w.writeAll("false"),
                1 => try w.writeAll("true"),
                else => try w.print("{d}", .{b}),
            }
        },
        .void => try w.writeAll("{}"),
        .@"enum" => |e| {
            // Read the storage bytes as one integer: @tagName/switch on a corrupt
            // value is a safety panic, and the value is caller memory we do not
            // control. A load through the tag type would truncate to its bit
            // width (a u2 tag in a byte), so the full storage width is read.
            if (@sizeOf(T) == 0) return w.writeAll(e.fields[0].name);
            const Raw = std.meta.Int(.unsigned, @sizeOf(T) * 8);
            const raw = @as(*align(@alignOf(T)) const Raw, @ptrCast(ptr)).*;
            const TagU = std.meta.Int(.unsigned, @bitSizeOf(e.tag_type));
            const padding: Raw = if (@bitSizeOf(TagU) == @bitSizeOf(Raw)) 0 else ~@as(Raw, std.math.maxInt(TagU));
            if (raw & padding == 0) {
                const low: TagU = @truncate(raw);
                inline for (e.fields) |f| {
                    if (low == @as(TagU, @bitCast(@as(e.tag_type, f.value)))) return w.writeAll(f.name);
                }
            }
            try w.print("{d}", .{raw});
        },
        .error_set => try w.print("error.{s}", .{@errorName(ptr.*)}),
        .error_union => |eu| if (ptr.*) |v| {
            try renderValue(eu.payload, &v, w, depth);
        } else |e| {
            try w.print("error.{s}", .{@errorName(e)});
        },
        .optional => |o| if (ptr.*) |v| {
            try renderValue(o.child, &v, w, depth);
        } else {
            try w.writeAll("null");
        },
        .pointer => |p| switch (p.size) {
            .slice => if (p.child == u8) {
                try renderString(ptr.*, w);
            } else {
                try renderElems(p.child, ptr.*, w, depth);
            },
            .many => if (p.child == u8 and p.sentinel() == 0) {
                try renderCString(ptr.*, w);
            } else {
                try w.print("0x{x}", .{@intFromPtr(ptr.*)});
            },
            .one, .c => try w.print("0x{x}", .{@intFromPtr(ptr.*)}),
        },
        .array => |a| if (a.child == u8) {
            try renderString(ptr.*[0..], w);
        } else {
            try renderElems(a.child, ptr.*[0..], w, depth);
        },
        .vector => |v| {
            const arr: [v.len]v.child = ptr.*;
            try renderElems(v.child, &arr, w, depth);
        },
        .@"struct" => |s| {
            if (depth == 0) {
                try w.writeAll("…");
                return;
            }
            if (s.fields.len == 0) {
                try w.writeAll("{}");
                return;
            }
            try w.writeAll("{ ");
            inline for (s.fields, 0..) |f, i| {
                if (i != 0) try w.writeAll(", ");
                if (!s.is_tuple) {
                    try w.writeAll(f.name);
                    try w.writeAll(": ");
                }
                if (comptime f.is_comptime) {
                    try w.writeAll("(comptime)");
                } else if (comptime s.layout == .@"packed") {
                    const v = @field(ptr.*, f.name);
                    try renderValue(f.type, &v, w, depth - 1);
                } else {
                    try renderValue(f.type, &@field(ptr.*, f.name), w, depth - 1);
                }
            }
            try w.writeAll(" }");
        },
        .@"union" => |u| {
            const Tag = u.tag_type orelse {
                try w.print("(untagged union, {d} bytes)", .{@sizeOf(T)});
                return;
            };
            if (depth == 0) {
                try w.writeAll("…");
                return;
            }
            // A switch on a corrupt tag is a safety panic: match the integer first.
            const raw = @intFromEnum(@as(Tag, ptr.*));
            inline for (u.fields) |f| {
                if (raw == @intFromEnum(@field(Tag, f.name))) {
                    try w.writeAll(f.name);
                    if (f.type != void) {
                        try w.writeAll(": ");
                        try renderValue(f.type, &@field(ptr.*, f.name), w, depth - 1);
                    }
                    return;
                }
            }
            try w.print("(invalid tag {d})", .{raw});
        },
        .@"fn" => try w.print("0x{x}", .{@intFromPtr(ptr)}),
        else => try w.print("<{s}>", .{@typeName(T)}),
    }
}

fn renderElems(comptime E: type, items: []const E, w: *Writer, depth: usize) Writer.Error!void {
    try w.writeByte('[');
    for (items, 0..) |*item, i| {
        if (i == max_elems) {
            try w.writeAll(", …");
            break;
        }
        if (i != 0) try w.writeAll(", ");
        try renderValue(E, item, w, depth);
    }
    try w.writeByte(']');
}

/// A NUL-terminated string, scanning at most `max_string` + 1 bytes for the
/// terminator so that a missing one cannot walk off the end of the mapping.
fn renderCString(s: [*:0]const u8, w: *Writer) Writer.Error!void {
    var n: usize = 0;
    while (n <= max_string and s[n] != 0) n += 1;
    try renderString(s[0..n], w);
}

/// A double-quoted string with C-style escapes, truncated to `max_string` bytes.
fn renderString(s: []const u8, w: *Writer) Writer.Error!void {
    try w.writeByte('"');
    for (s[0..@min(s.len, max_string)]) |b| switch (b) {
        '\n' => try w.writeAll("\\n"),
        '\r' => try w.writeAll("\\r"),
        '\t' => try w.writeAll("\\t"),
        '\\' => try w.writeAll("\\\\"),
        '"' => try w.writeAll("\\\""),
        ' '...'!', '#'...'[', ']'...'~' => try w.writeByte(b),
        else => {
            const hex = "0123456789abcdef";
            try w.writeAll("\\x");
            try w.writeByte(hex[b >> 4]);
            try w.writeByte(hex[b & 15]);
        },
    };
    try w.writeByte('"');
    if (s.len > max_string) try w.writeAll("…");
}

// ---------------------------------------------------------------------------
// Setting
// ---------------------------------------------------------------------------

/// Parses `text` and stores it into `ptr.*`: ints in decimal or 0x/0o/0b,
/// floats, bools (true/false/1/0), enums by tag name (or by integer value for
/// non-exhaustive enums). Other types are `error.Unsupported`.
pub fn set(ptr: anytype, text: []const u8) SetError!void {
    const T = @TypeOf(ptr.*);
    const s = std.mem.trim(u8, text, " \t\r\n\x00");
    switch (@typeInfo(T)) {
        .int => ptr.* = std.fmt.parseInt(T, s, 0) catch return error.Invalid,
        .float => ptr.* = std.fmt.parseFloat(T, s) catch return error.Invalid,
        .bool => {
            if (std.mem.eql(u8, s, "true") or std.mem.eql(u8, s, "1")) {
                ptr.* = true;
            } else if (std.mem.eql(u8, s, "false") or std.mem.eql(u8, s, "0")) {
                ptr.* = false;
            } else return error.Invalid;
        },
        .@"enum" => |e| {
            if (std.meta.stringToEnum(T, s)) |v| {
                ptr.* = v;
            } else if (!e.is_exhaustive) {
                const raw = std.fmt.parseInt(e.tag_type, s, 0) catch return error.Invalid;
                ptr.* = @enumFromInt(raw);
            } else return error.Invalid;
        },
        else => return error.Unsupported,
    }
}

// ---------------------------------------------------------------------------
// Tests
// ---------------------------------------------------------------------------

const testing = std.testing;

fn renderToBuf(buf: []u8, ptr: anytype) ![]const u8 {
    var w: Writer = .fixed(buf);
    try render(ptr, &w, max_depth);
    return w.buffered();
}

test "render scalars, strings, pointers, optionals, enums, arrays" {
    var buf: [512]u8 = undefined;
    const i: i32 = -42;
    try testing.expectEqualStrings("-42", try renderToBuf(&buf, &i));
    const f: f32 = 1.5;
    try testing.expectEqualStrings("1.5", try renderToBuf(&buf, &f));
    const b: bool = true;
    try testing.expectEqualStrings("true", try renderToBuf(&buf, &b));
    const s: []const u8 = "hi \"there\"\n";
    try testing.expectEqualStrings("\"hi \\\"there\\\"\\n\"", try renderToBuf(&buf, &s));
    const z: [*:0]const u8 = "zed";
    try testing.expectEqualStrings("\"zed\"", try renderToBuf(&buf, &z));
    const p: *const i32 = &i;
    var expect_buf: [32]u8 = undefined;
    const expect = try std.fmt.bufPrint(&expect_buf, "0x{x}", .{@intFromPtr(&i)});
    try testing.expectEqualStrings(expect, try renderToBuf(&buf, &p));
    const o: ?u8 = null;
    try testing.expectEqualStrings("null", try renderToBuf(&buf, &o));
    const o2: ?u8 = 7;
    try testing.expectEqualStrings("7", try renderToBuf(&buf, &o2));
    const E = enum { red, green };
    const e: E = .green;
    try testing.expectEqualStrings("green", try renderToBuf(&buf, &e));
    const NE = enum(u8) { a, _ };
    const ne: NE = @enumFromInt(9);
    try testing.expectEqualStrings("9", try renderToBuf(&buf, &ne));
    const arr = [_]u16{ 1, 2, 3 };
    try testing.expectEqualStrings("[1, 2, 3]", try renderToBuf(&buf, &arr));
    const bytes = [_]u8{ 0, 'a', 0xff };
    try testing.expectEqualStrings("\"\\x00a\\xff\"", try renderToBuf(&buf, &bytes));
    const U = union(enum) { none, some: u32 };
    const u: U = .{ .some = 5 };
    try testing.expectEqualStrings("some: 5", try renderToBuf(&buf, &u));
    const un: U = .none;
    try testing.expectEqualStrings("none", try renderToBuf(&buf, &un));
}

test "render structs multi-line with nested indentation and depth limit" {
    const Inner = struct { x: f32, flags: [2]bool };
    const Outer = struct { a: u32, b: bool, name: []const u8, inner: Inner, items: []const Inner };
    const v: Outer = .{ .a = 1, .b = false, .name = "n", .inner = .{ .x = 2.5, .flags = .{ true, false } }, .items = &.{.{ .x = 0, .flags = .{ false, false } }} };
    var buf: [512]u8 = undefined;
    try testing.expectEqualStrings(
        \\a: 1
        \\b: false
        \\name: "n"
        \\inner:
        \\  x: 2.5
        \\  flags: [true, false]
        \\items: [{ x: 0, flags: [false, false] }]
        \\
    , try renderToBuf(&buf, &v));
    var w: Writer = .fixed(&buf);
    try render(&v, &w, 1);
    try testing.expectEqualStrings(
        \\a: 1
        \\b: false
        \\name: "n"
        \\inner:
        \\  …
        \\items: […]
        \\
    , w.buffered());
}

test "long strings and arrays are truncated" {
    const long = [_]u8{'x'} ** 300;
    var buf: [1024]u8 = undefined;
    const s: []const u8 = &long;
    const out = try renderToBuf(&buf, &s);
    try testing.expectEqual(@as(usize, 1 + max_string + 1 + "…".len), out.len);
    try testing.expect(std.mem.endsWith(u8, out, "\"…"));
    const nums: [100]u32 = @splat(1);
    const out2 = try renderToBuf(&buf, &nums);
    try testing.expect(std.mem.endsWith(u8, out2, ", …]"));
    try testing.expectEqual(@as(usize, max_elems), std.mem.count(u8, out2, "1"));
}

test "set parses ints, floats, bools and enums" {
    var i: u32 = 0;
    try set(&i, "42\n");
    try testing.expectEqual(@as(u32, 42), i);
    try set(&i, "0x10");
    try testing.expectEqual(@as(u32, 16), i);
    try testing.expectError(error.Invalid, set(&i, "-1"));
    try testing.expectError(error.Invalid, set(&i, "abc"));
    var si: i8 = 0;
    try set(&si, " -7 ");
    try testing.expectEqual(@as(i8, -7), si);
    try testing.expectError(error.Invalid, set(&si, "200"));
    var f: f64 = 0;
    try set(&f, "2.25");
    try testing.expectEqual(@as(f64, 2.25), f);
    var b: bool = false;
    try set(&b, "true");
    try testing.expect(b);
    try set(&b, "0");
    try testing.expect(!b);
    try testing.expectError(error.Invalid, set(&b, "maybe"));
    const E = enum { off, on };
    var e: E = .off;
    try set(&e, "on");
    try testing.expectEqual(E.on, e);
    try testing.expectError(error.Invalid, set(&e, "blue"));
    var s: []const u8 = "x";
    try testing.expectError(error.Unsupported, set(&s, "y"));
}

test "vtable table layout for a nested struct" {
    const Inner = struct { x: f32 };
    const T = struct { a: u32, b: bool, name: []const u8, inner: Inner };
    const vt = vtableFor(T);
    try testing.expectEqual(vt, vtableFor(T));
    try testing.expectEqualStrings(@typeName(T), vt.type_name);
    const root = vt.nodes[0];
    try testing.expect(root.isDir());
    try testing.expectEqual(@as(u32, 6), root.count);
    const value = vt.child(0, "value").?;
    try testing.expect(!vt.nodes[value].writable()); // a struct is not settable
    try testing.expectEqualStrings(std.fmt.comptimePrint("{d}", .{@sizeOf(T)}), vt.nodes[vt.child(0, "size").?].content);
    const f = vt.child(0, "f").?;
    try testing.expectEqual(Kind.fields, vt.nodes[f].kind);
    try testing.expectEqual(@as(u32, 4), vt.nodes[f].count);
    const a = vt.child(f, "a").?;
    try testing.expectEqual(@offsetOf(T, "a"), vt.nodes[a].offset);
    const a_value = vt.child(a, "value").?;
    try testing.expect(vt.nodes[a_value].writable());
    try testing.expectEqual(@as(usize, 4), vt.nodes[a_value].size);
    try testing.expectEqual(a, vt.nodes[a_value].parent);
    const inner = vt.child(f, "inner").?;
    const inner_f = vt.child(inner, "f").?;
    const x = vt.child(inner_f, "x").?;
    try testing.expectEqual(@offsetOf(T, "inner") + @offsetOf(Inner, "x"), vt.nodes[x].offset);
    try testing.expectEqualStrings("f32", vt.nodes[vt.child(x, "type").?].content);
    try testing.expect(vt.child(f, "nope") == null);
    // rendering and setting through the table
    var v: T = .{ .a = 1, .b = true, .name = "n", .inner = .{ .x = 0.5 } };
    const base: [*]u8 = @ptrCast(&v);
    var buf: [256]u8 = undefined;
    var w: Writer = .fixed(&buf);
    const x_value = vt.child(x, "value").?;
    try vt.nodes[x_value].render.?(base + vt.nodes[x_value].offset, &w);
    try testing.expectEqualStrings("0.5", w.buffered());
    try vt.nodes[a_value].set.?(base + vt.nodes[a_value].offset, "42");
    try testing.expectEqual(@as(u32, 42), v.a);
    w = .fixed(&buf);
    try vt.nodes[value].render.?(base, &w);
    try testing.expect(std.mem.startsWith(u8, w.buffered(), "a: 42\nb: true\n"));
}

test "depth limit stops the f/ tree at max_depth" {
    const L4 = struct { v: u8 };
    const L3 = struct { l4: L4 };
    const L2 = struct { l3: L3 };
    const L1 = struct { l2: L2 };
    const L0 = struct { l1: L1 };
    const vt = vtableFor(L0);
    var node: u32 = 0;
    var depth: usize = 0;
    while (vt.child(node, "f")) |f| : (depth += 1) {
        node = vt.nodes[f].first; // the single field
    }
    try testing.expectEqual(@as(usize, max_depth), depth);
    try testing.expect(vt.child(node, "value") != null);
}

test "every @typeInfo category renders without dereferencing anything unbounded" {
    var buf: [2048]u8 = undefined;
    // packed and extern structs (packed fields have no address: rendered by copy)
    const Packed = packed struct { a: u3, b: bool, c: u12, e: enum(u2) { p, q, r } };
    const pk: Packed = .{ .a = 5, .b = true, .c = 300, .e = .r };
    try testing.expectEqualStrings("a: 5\nb: true\nc: 300\ne: r\n", try renderToBuf(&buf, &pk));
    const Ext = extern struct { x: u16, y: f32, inner: extern struct { z: u8 } };
    const ex: Ext = .{ .x = 1, .y = 0.5, .inner = .{ .z = 9 } };
    try testing.expectEqualStrings("x: 1\ny: 0.5\ninner:\n  z: 9\n", try renderToBuf(&buf, &ex));
    const Holder = struct { p: Packed, list: [2]Packed };
    const ho: Holder = .{ .p = pk, .list = .{ pk, pk } };
    try testing.expect(std.mem.startsWith(u8, try renderToBuf(&buf, &ho), "p:\n  a: 5\n"));
    // the f/ tree has no entries for a packed struct and works through a table
    const vt = vtableFor(Packed);
    try testing.expect(vt.child(0, "f") == null);
    var w: Writer = .fixed(&buf);
    try vt.nodes[vt.child(0, "value").?].render.?(@ptrCast(&pk), &w);
    try testing.expect(std.mem.startsWith(u8, w.buffered(), "a: 5\n"));
    // optionals of pointers are printed, never followed
    var target: u32 = 7;
    const op: ?*u32 = &target;
    var expect_buf: [32]u8 = undefined;
    try testing.expectEqualStrings(try std.fmt.bufPrint(&expect_buf, "0x{x}", .{@intFromPtr(&target)}), try renderToBuf(&buf, &op));
    const np: ?*u32 = null;
    try testing.expectEqualStrings("null", try renderToBuf(&buf, &np));
    const dangling: *const u32 = @ptrFromInt(0x1000);
    try testing.expectEqualStrings("0x1000", try renderToBuf(&buf, &dangling));
    const cptr: [*c]const u8 = @ptrFromInt(0x2000);
    try testing.expectEqualStrings("0x2000", try renderToBuf(&buf, &cptr));
    const manyp: [*]const u32 = @ptrFromInt(0x3000);
    try testing.expectEqualStrings("0x3000", try renderToBuf(&buf, &manyp));
    // untagged and tagged unions, error unions, error sets
    const Untagged = union { a: u32, b: f32 };
    const un: Untagged = .{ .a = 1 };
    try testing.expectEqualStrings(std.fmt.comptimePrint("(untagged union, {d} bytes)", .{@sizeOf(Untagged)}), try renderToBuf(&buf, &un));
    const Tagged = union(enum(u8)) { none, some: u32, pair: struct { l: u8, r: u8 } };
    const tg: Tagged = .{ .pair = .{ .l = 1, .r = 2 } };
    try testing.expectEqualStrings("pair: { l: 1, r: 2 }", try renderToBuf(&buf, &tg));
    const eu: anyerror!u8 = error.Boom;
    try testing.expectEqualStrings("error.Boom", try renderToBuf(&buf, &eu));
    const eu2: error{X}!u8 = 4;
    try testing.expectEqualStrings("4", try renderToBuf(&buf, &eu2));
    const es: anyerror = error.Zap;
    try testing.expectEqualStrings("error.Zap", try renderToBuf(&buf, &es));
    // wide ints and floats, vectors, sentinel arrays, slices of slices, void, comptime fields
    const big: u128 = std.math.maxInt(u128);
    try testing.expectEqualStrings("340282366920938463463374607431768211455", try renderToBuf(&buf, &big));
    const neg: i128 = std.math.minInt(i128);
    try testing.expectEqualStrings("-170141183460469231731687303715884105728", try renderToBuf(&buf, &neg));
    const h: f16 = 1.5;
    try testing.expectEqualStrings("1.5", try renderToBuf(&buf, &h));
    const ld: f80 = 2.25;
    try testing.expectEqualStrings("2.25", try renderToBuf(&buf, &ld));
    const quad: f128 = 3.125;
    try testing.expectEqualStrings("3.125", try renderToBuf(&buf, &quad));
    const vec: @Vector(4, i16) = .{ 1, -2, 3, -4 };
    try testing.expectEqualStrings("[1, -2, 3, -4]", try renderToBuf(&buf, &vec));
    const sarr: [3:0]u8 = .{ 'a', 'b', 'c' };
    try testing.expectEqualStrings("\"abc\"", try renderToBuf(&buf, &sarr));
    const rows: []const []const u8 = &.{ "ab", "cd" };
    try testing.expectEqualStrings("[\"ab\", \"cd\"]", try renderToBuf(&buf, &rows));
    const Odd = struct { v: void, comptime k: u8 = 3, n: u8 };
    const odd: Odd = .{ .v = {}, .n = 1 };
    try testing.expectEqualStrings("v: {}\nk: (comptime)\nn: 1\n", try renderToBuf(&buf, &odd));
    try testing.expectEqual(@as(u32, 1), vtableFor(Odd).nodes[vtableFor(Odd).child(0, "f").?].count);
    // self-referential through a pointer: rendered as an address, table stays finite
    const Link = struct { next: ?*const @This(), v: u8 };
    var a: Link = .{ .next = null, .v = 1 };
    const b: Link = .{ .next = &a, .v = 2 };
    a.next = &b;
    try testing.expectEqualStrings(try std.fmt.bufPrint(&expect_buf, "next: 0x{x}\nv: 2\n", .{@intFromPtr(&a)}), try renderToBuf(&buf, &b));
    try testing.expect(vtableFor(Link).nodes.len < 32);
    // tuples
    const tup: struct { u8, []const u8 } = .{ 1, "x" };
    try testing.expectEqualStrings("{ 1, \"x\" }", try renderToBuf(&buf, &tup));
}

test "corrupt live memory renders instead of trapping: enums, unions, bools" {
    var buf: [128]u8 = undefined;
    const E = enum(u8) { a, b };
    var raw_e: u8 = 7;
    try testing.expectEqualStrings("7", try renderToBuf(&buf, @as(*const E, @ptrCast(&raw_e))));
    raw_e = 1;
    try testing.expectEqualStrings("b", try renderToBuf(&buf, @as(*const E, @ptrCast(&raw_e))));
    // a u2 tag in a byte: the whole byte is judged, not the truncated tag (ReleaseSafe would say "c")
    const E3 = enum { a, b, c };
    var raw3: u8 = 0xEE;
    try testing.expectEqualStrings("238", try renderToBuf(&buf, @as(*const E3, @ptrCast(&raw3))));
    raw3 = 3;
    try testing.expectEqualStrings("3", try renderToBuf(&buf, @as(*const E3, @ptrCast(&raw3))));
    raw3 = 2;
    try testing.expectEqualStrings("c", try renderToBuf(&buf, @as(*const E3, @ptrCast(&raw3))));
    const E12 = enum(u12) { p = 5, q = 4095 };
    var raw12: u16 = 0xF005;
    try testing.expectEqualStrings("61445", try renderToBuf(&buf, @as(*const E12, @ptrCast(&raw12))));
    raw12 = 4095;
    try testing.expectEqualStrings("q", try renderToBuf(&buf, @as(*const E12, @ptrCast(&raw12))));
    const ES = enum(i8) { neg = -3, pos = 7 };
    var raws: u8 = 0xFD;
    try testing.expectEqualStrings("neg", try renderToBuf(&buf, @as(*const ES, @ptrCast(&raws))));
    raws = 0x80;
    try testing.expectEqualStrings("128", try renderToBuf(&buf, @as(*const ES, @ptrCast(&raws))));
    const E1 = enum { only };
    const e1: E1 = .only;
    try testing.expectEqualStrings("only", try renderToBuf(&buf, &e1));
    const NE = enum(u16) { x = 5, _ };
    var raw_ne: u16 = 5;
    try testing.expectEqualStrings("x", try renderToBuf(&buf, @as(*const NE, @ptrCast(&raw_ne))));
    raw_ne = 6;
    try testing.expectEqualStrings("6", try renderToBuf(&buf, @as(*const NE, @ptrCast(&raw_ne))));
    var raw_b: u8 = 2;
    try testing.expectEqualStrings("2", try renderToBuf(&buf, @as(*const bool, @ptrCast(&raw_b))));
    const U = union(enum(u8)) { x: u32, y: bool };
    var raw_u: [@sizeOf(U)]u8 align(@alignOf(U)) = @splat(0x55);
    const out = try renderToBuf(&buf, @as(*const U, @ptrCast(&raw_u)));
    try testing.expectEqualStrings("(invalid tag 85)", out);
    const S = struct { e: E, u: U, b: bool };
    var raw_s: [@sizeOf(S)]u8 align(@alignOf(S)) = @splat(0xEE);
    const ps: *const S = @ptrCast(&raw_s);
    _ = try renderToBuf(&buf, ps); // no trap
    try testing.expect(std.mem.indexOf(u8, try renderToBuf(&buf, ps), "238") != null);
}

test "a [*:0]const u8 without a terminator is read at most max_string + 1 bytes" {
    // Only the first max_string + 1 bytes exist; anything beyond is the
    // testing allocator's guard, which a wider scan would touch.
    const mem = try testing.allocator.alloc(u8, max_string + 1);
    defer testing.allocator.free(mem);
    @memset(mem, 'x');
    const z: [*:0]const u8 = @ptrCast(mem.ptr);
    var buf: [1024]u8 = undefined;
    const out = try renderToBuf(&buf, &z);
    try testing.expectEqual(@as(usize, 1 + max_string + 1 + "…".len), out.len);
    try testing.expect(std.mem.endsWith(u8, out, "\"…"));
    // exactly max_string bytes then NUL: no ellipsis
    const mem2 = try testing.allocator.alloc(u8, max_string + 1);
    defer testing.allocator.free(mem2);
    @memset(mem2, 'y');
    mem2[max_string] = 0;
    const z2: [*:0]const u8 = @ptrCast(mem2.ptr);
    const out2 = try renderToBuf(&buf, &z2);
    try testing.expectEqual(@as(usize, 1 + max_string + 1), out2.len);
    // a garbage-length []const u8 still reads at most max_string bytes
    const garbage: []const u8 = mem[0..max_string];
    _ = try renderToBuf(&buf, &garbage);
}

test "set rejects hostile input without partial writes" {
    var u: u8 = 200;
    for ([_][]const u8{ "-1", "256", "1e3", "0x", "", "   ", "1.5", "+", "0b2", "١", "12abc", "0x100", "\x00", "1 2" }) |bad| {
        try testing.expectError(error.Invalid, set(&u, bad));
        try testing.expectEqual(@as(u8, 200), u);
    }
    try set(&u, "0b1111_1111");
    try testing.expectEqual(@as(u8, 255), u);
    try set(&u, "+0o17");
    try testing.expectEqual(@as(u8, 15), u);
    var i: i64 = 1;
    try set(&i, "-9223372036854775808");
    try testing.expectEqual(std.math.minInt(i64), i);
    try testing.expectError(error.Invalid, set(&i, "9223372036854775808"));
    var w: u128 = 0;
    try set(&w, "340282366920938463463374607431768211455");
    try testing.expectEqual(std.math.maxInt(u128), w);
    try testing.expectError(error.Invalid, set(&w, "340282366920938463463374607431768211456"));
    // floats: exponents, hex floats, inf/nan spellings, and junk
    var f: f32 = 1;
    try set(&f, "1.5e3");
    try testing.expectEqual(@as(f32, 1500), f);
    try set(&f, "-0x1p-2");
    try testing.expectEqual(@as(f32, -0.25), f);
    try set(&f, "1e999");
    try testing.expect(std.math.isInf(f));
    try testing.expectError(error.Invalid, set(&f, "1.5.5"));
    try testing.expectError(error.Invalid, set(&f, "e5"));
    try testing.expectError(error.Invalid, set(&f, ""));
    var h: f16 = 0;
    try set(&h, "65504");
    try testing.expectEqual(@as(f16, 65504), h);
    var q: f128 = 0;
    try set(&q, "2.5");
    try testing.expectEqual(@as(f128, 2.5), q);
    // enums: NULs inside the tag, case, trailing junk; non-exhaustive by integer only when out of names
    const E = enum(u8) { off, on };
    var e: E = .off;
    for ([_][]const u8{ "on\x00x", "On", "on x", "1", "0x1", "" }) |bad| {
        try testing.expectError(error.Invalid, set(&e, bad));
        try testing.expectEqual(E.off, e);
    }
    try set(&e, "\x00on\n");
    try testing.expectEqual(E.on, e);
    const NE = enum(u8) { a, _ };
    var ne: NE = .a;
    try set(&ne, "200");
    try testing.expectEqual(@as(u8, 200), @intFromEnum(ne));
    try testing.expectError(error.Invalid, set(&ne, "256"));
    try testing.expectError(error.Invalid, set(&ne, "-1"));
    try set(&ne, "a");
    try testing.expectEqual(NE.a, ne);
    // bools
    var b: bool = true;
    for ([_][]const u8{ "yes", "TRUE", "2", "", "01" }) |bad| {
        try testing.expectError(error.Invalid, set(&b, bad));
        try testing.expect(b);
    }
    // unsupported types are refused without touching memory
    var opt: ?u8 = 3;
    try testing.expectError(error.Unsupported, set(&opt, "4"));
    try testing.expectEqual(@as(?u8, 3), opt);
    var arr: [2]u8 = .{ 1, 2 };
    try testing.expectError(error.Unsupported, set(&arr, "x"));
    var un: union(enum) { a: u8 } = .{ .a = 1 };
    try testing.expectError(error.Unsupported, set(&un, "a"));
}