tricu

codecs.zig (7099B)

---

 const std = @import("std");
 const Arena = @import("arena.zig").Arena;
 const reduce = @import("reduce.zig");
 
 // ---------------------------------------------------------------------------
 // Number encoding/decoding
 // ---------------------------------------------------------------------------
 
 pub fn ofNumber(arena: *Arena, n: u64) !u32 {
     if (n == 0) {
         return try arena.alloc(.leaf);
     }
     const bit = if (n % 2 == 1) try arena.alloc(.{ .stem = .{ .child = try arena.alloc(.leaf) } }) else try arena.alloc(.leaf);
     const rest = try ofNumber(arena, n / 2);
     return try arena.alloc(.{ .fork = .{ .left = bit, .right = rest } });
 }
 
 pub fn toNumber(arena: *Arena, idx: u32) !?u64 {
     const node = try reduce.reduce(idx, arena, 1_000_000);
     const n = arena.get(node);
     return switch (n.*) {
         .leaf => 0,
         .stem => return null,
         .fork => |f| blk: {
             const bit_node = try reduce.reduce(f.left, arena, 1_000_000);
             const bit = arena.get(bit_node);
             const bit_val: u64 = switch (bit.*) {
                 .leaf => 0,
                 .stem => |s| if (arena.get(try reduce.reduce(s.child, arena, 1_000_000)).* == .leaf) 1 else return null,
                 else => return null,
             };
             const rest = try toNumber(arena, f.right) orelse return null;
             const doubled = std.math.mul(u64, 2, rest) catch return null;
             break :blk std.math.add(u64, bit_val, doubled) catch return null;
         },
         .app => return null,
     };
 }
 
 // ---------------------------------------------------------------------------
 // List encoding/decoding
 // ---------------------------------------------------------------------------
 
 pub fn ofList(arena: *Arena, items: []const u32) !u32 {
     var result = try arena.alloc(.leaf);
     var i: usize = items.len;
     while (i > 0) {
         i -= 1;
         result = try arena.alloc(.{ .fork = .{ .left = items[i], .right = result } });
     }
     return result;
 }
 
 pub fn toList(arena: *Arena, idx: u32) !?std.ArrayList(u32) {
     var result = std.ArrayList(u32).empty;
     errdefer result.deinit(arena.allocator);
 
     var current = idx;
     while (true) {
         const node = try reduce.reduce(current, arena, 1_000_000);
         const n = arena.get(node);
         switch (n.*) {
             .leaf => return result,
             .stem => {
                 result.deinit(arena.allocator);
                 return null;
             },
             .fork => |f| {
                 try result.append(arena.allocator, f.left);
                 current = f.right;
             },
             .app => return null,
         }
     }
 }
 
 // ---------------------------------------------------------------------------
 // String / Bytes encoding/decoding
 // Strings are lists of byte values (each character encoded as a number tree).
 // ---------------------------------------------------------------------------
 
 pub fn ofString(arena: *Arena, s: []const u8) !u32 {
     var bytes = try arena.allocator.alloc(u32, s.len);
     defer arena.allocator.free(bytes);
     for (s, 0..) |c, i| {
         bytes[i] = try ofNumber(arena, c);
     }
     return try ofList(arena, bytes);
 }
 
 pub fn toString(arena: *Arena, idx: u32) !?[]u8 {
     var list = try toList(arena, idx) orelse return null;
     defer list.deinit(arena.allocator);
     var result = try arena.allocator.alloc(u8, list.items.len);
     errdefer arena.allocator.free(result);
     for (list.items, 0..) |elem_idx, i| {
         const num = try toNumber(arena, elem_idx) orelse {
             arena.allocator.free(result);
             return null;
         };
         if (num > 255) {
             arena.allocator.free(result);
             return null;
         }
         result[i] = @intCast(num);
     }
     return result;
 }
 
 pub fn ofBytes(arena: *Arena, bytes: []const u8) !u32 {
     return try ofString(arena, bytes);
 }
 
 pub fn toBytes(arena: *Arena, idx: u32) !?[]u8 {
     return try toString(arena, idx);
 }
 
 // ---------------------------------------------------------------------------
 // Result unwrapping (ok/err protocol)
 // ok value rest = pair true (pair value rest)
 // err code rest = pair false (pair code rest)
 // ---------------------------------------------------------------------------
 
 pub const UnwrapResult = struct {
     ok: bool,
     value: u32,
     rest: u32,
 };
 
 pub fn unwrapResult(arena: *Arena, idx: u32) !?UnwrapResult {
     const node = try reduce.reduce(idx, arena, 1_000_000);
     const n = arena.get(node);
     switch (n.*) {
         .fork => |f| {
             const tag = try reduce.reduce(f.left, arena, 1_000_000);
             const rest_pair = try reduce.reduce(f.right, arena, 1_000_000);
             const rp = arena.get(rest_pair);
             switch (rp.*) {
                 .fork => |rf| {
                     const is_ok = try toBool(arena, tag) orelse return null;
                     return UnwrapResult{
                         .ok = is_ok,
                         .value = rf.left,
                         .rest = rf.right,
                     };
                 },
                 else => return null,
             }
         },
         else => return null,
     }
 }
 
 // ---------------------------------------------------------------------------
 // Host ABI value unwrapping
 // A host ABI value is: pair tag payload
 // ---------------------------------------------------------------------------
 
 pub const HostValue = struct {
     tag: u64,
     payload: u32,
 };
 
 pub fn unwrapHostValue(arena: *Arena, idx: u32) !?HostValue {
     const node = try reduce.reduce(idx, arena, 1_000_000);
     const n = arena.get(node);
     switch (n.*) {
         .fork => |f| {
             const tag_num = try toNumber(arena, f.left) orelse return null;
             return HostValue{ .tag = tag_num, .payload = f.right };
         },
         else => return null,
     }
 }
 
 /// Returns true if the tree is a valid boolean (Leaf=false, Stem Leaf=true).
 pub fn isBool(arena: *Arena, idx: u32) !bool {
     const node = try reduce.reduce(idx, arena, 1_000_000);
     const n = arena.get(node);
     return switch (n.*) {
         .leaf => true,
         .stem => |s| arena.get(try reduce.reduce(s.child, arena, 1_000_000)).* == .leaf,
         else => false,
     };
 }
 
 /// Extract the boolean value: false for Leaf, true for Stem Leaf.
 /// Returns null if the tree is not a valid boolean.
 pub fn toBool(arena: *Arena, idx: u32) !?bool {
     const node = try reduce.reduce(idx, arena, 1_000_000);
     const n = arena.get(node);
     return switch (n.*) {
         .leaf => false,
         .stem => |s| if (arena.get(try reduce.reduce(s.child, arena, 1_000_000)).* == .leaf) true else null,
         else => null,
     };
 }
 
 // ---------------------------------------------------------------------------
 // Host ABI tag constants
 // ---------------------------------------------------------------------------
 
 pub const HOST_TREE_TAG: u64 = 0;
 pub const HOST_STRING_TAG: u64 = 1;
 pub const HOST_NUMBER_TAG: u64 = 2;
 pub const HOST_BOOL_TAG: u64 = 3;
 pub const HOST_LIST_TAG: u64 = 4;
 pub const HOST_BYTES_TAG: u64 = 5;