terminal: Zig 0.15, lib-vt and test-lib-vt work

Author: mitchellh

src/datastruct/lru.zig

@@ -33,8 +33,13 @@ pub fn HashMap(
 ) type {
     return struct {
         const Self = @This();
-        const Map = std.HashMapUnmanaged(K, *Queue.Node, Context, max_load_percentage);
-        const Queue = std.DoublyLinkedList(KV);
+        const Queue = std.DoublyLinkedList;
+        const Map = std.HashMapUnmanaged(
+            K,
+            *Entry,
+            Context,
+            max_load_percentage,
+        );
 
         /// Map to maintain our entries.
         map: Map,
@@ -46,6 +51,15 @@ pub fn HashMap(
         /// misses will begin evicting entries.
         capacity: Map.Size,
 
+        const Entry = struct {
+            data: KV,
+            node: Queue.Node,
+
+            fn fromNode(node: *Queue.Node) *Entry {
+                return @fieldParentPtr("node", node);
+            }
+        };
+
         pub const KV = struct {
             key: K,
             value: V,
@@ -82,7 +96,7 @@ pub fn HashMap(
             var it = self.queue.first;
             while (it) |node| {
                 it = node.next;
-                alloc.destroy(node);
+                alloc.destroy(Entry.fromNode(node));
             }
 
             self.map.deinit(alloc);
@@ -108,8 +122,8 @@ pub fn HashMap(
             const map_gop = try self.map.getOrPutContext(alloc, key, ctx);
             if (map_gop.found_existing) {
                 // Move to end to mark as most recently used
-                self.queue.remove(map_gop.value_ptr.*);
-                self.queue.append(map_gop.value_ptr.*);
+                self.queue.remove(&map_gop.value_ptr.*.node);
+                self.queue.append(&map_gop.value_ptr.*.node);
 
                 return GetOrPutResult{
                     .found_existing = true,
@@ -122,37 +136,34 @@ pub fn HashMap(
             // We're evicting if our map insertion increased our capacity.
             const evict = self.map.count() > self.capacity;
 
-            // Get our node. If we're not evicting then we allocate a new
-            // node. If we are evicting then we avoid allocation by just
-            // reusing the node we would've evicted.
-            var node = if (!evict) try alloc.create(Queue.Node) else node: {
+            // Get our entry. If we're not evicting then we allocate a new
+            // entry. If we are evicting then we avoid allocation by just
+            // reusing the entry we would've evicted.
+            const entry: *Entry = if (!evict) try alloc.create(Entry) else entry: {
                 // Our first node is the least recently used.
-                const least_used = self.queue.first.?;
-
-                // Move our least recently used to the end to make
-                // it the most recently used.
-                self.queue.remove(least_used);
+                const least_used_node = self.queue.popFirst().?;
+                const least_used_entry: *Entry = .fromNode(least_used_node);
 
                 // Remove the least used from the map
-                _ = self.map.remove(least_used.data.key);
+                _ = self.map.remove(least_used_entry.data.key);
 
-                break :node least_used;
+                break :entry least_used_entry;
             };
-            errdefer if (!evict) alloc.destroy(node);
+            errdefer if (!evict) alloc.destroy(entry);
 
-            // Store our node in the map.
-            map_gop.value_ptr.* = node;
+            // Store our entry in the map.
+            map_gop.value_ptr.* = entry;
 
-            // Mark the node as most recently used
-            self.queue.append(node);
+            // Mark the entry as most recently used
+            self.queue.append(&entry.node);
 
             // Set our key
-            node.data.key = key;
+            entry.data.key = key;
 
-            return GetOrPutResult{
+            return .{
                 .found_existing = map_gop.found_existing,
-                .value_ptr = &node.data.value,
-                .evicted = if (!evict) null else node.data,
+                .value_ptr = &entry.data.value,
+                .evicted = if (!evict) null else entry.data,
             };
         }
 
@@ -193,11 +204,12 @@ pub fn HashMap(
 
             var i: Map.Size = 0;
             while (i < delta) : (i += 1) {
-                const node = self.queue.first.?;
-                evicted[i] = node.data.value;
+                const node = self.queue.popFirst().?;
+                const entry: *Entry = .fromNode(node);
+                evicted[i] = entry.data.value;
                 self.queue.remove(node);
-                _ = self.map.remove(node.data.key);
-                alloc.destroy(node);
+                _ = self.map.remove(entry.data.key);
+                alloc.destroy(entry);
             }
 
             self.capacity = capacity;

src/datastruct/main.zig

@@ -14,7 +14,7 @@ pub const CacheTable = cache_table.CacheTable;
 pub const CircBuf = circ_buf.CircBuf;
 pub const IntrusiveDoublyLinkedList = intrusive_linked_list.DoublyLinkedList;
 pub const SegmentedPool = segmented_pool.SegmentedPool;
-pub const SplitTree = split_tree.SplitTree;
+//pub const SplitTree = split_tree.SplitTree;
 
 test {
     @import("std").testing.refAllDecls(@This());

src/terminal/PageList.zig

@@ -56,7 +56,7 @@ const std_size = Page.layout(std_capacity).total_size;
 /// allocator because we need memory that is zero-initialized and page-aligned.
 const PagePool = std.heap.MemoryPoolAligned(
     [std_size]u8,
-    std.heap.page_size_min,
+    .fromByteUnits(std.heap.page_size_min),
 );
 
 /// List of pins, known as "tracked" pins. These are pins that are kept
@@ -388,11 +388,18 @@ pub fn reset(self: *PageList) void {
         const page_arena = &self.pool.pages.arena;
         var it = page_arena.state.buffer_list.first;
         while (it) |node| : (it = node.next) {
-            // The fully allocated buffer
-            const alloc_buf = @as([*]u8, @ptrCast(node))[0..node.data];
+            // WARN: Since HeapAllocator's BufNode is not public API,
+            // we have to hardcode its layout here. We do a comptime assert
+            // on Zig version to verify we check it on every bump.
+            const BufNode = struct {
+                data: usize,
+                node: std.SinglyLinkedList.Node,
+            };
+            const buf_node: *BufNode = @fieldParentPtr("node", node);
 
+            // The fully allocated buffer
+            const alloc_buf = @as([*]u8, @ptrCast(buf_node))[0..buf_node.data];
             // The buffer minus our header
-            const BufNode = @TypeOf(page_arena.state.buffer_list).Node;
             const data_buf = alloc_buf[@sizeOf(BufNode)..];
             @memset(data_buf, 0);
         }
@@ -2075,7 +2082,7 @@ inline fn createPageExt(
     else
         try page_alloc.alignedAlloc(
             u8,
-            std.heap.page_size_min,
+            .fromByteUnits(std.heap.page_size_min),
             layout.total_size,
         );
     errdefer if (pooled)
@@ -2676,7 +2683,7 @@ pub const EncodeUtf8Options = struct {
 /// predates this and is a thin wrapper around it so the tests all live there.
 pub fn encodeUtf8(
     self: *const PageList,
-    writer: anytype,
+    writer: *std.Io.Writer,
     opts: EncodeUtf8Options,
 ) anyerror!void {
     // We don't currently use self at all. There is an argument that this

src/terminal/Parser.zig

@@ -97,13 +97,9 @@ pub const Action = union(enum) {
         // Implement formatter for logging
         pub fn format(
             self: CSI,
-            comptime layout: []const u8,
-            opts: std.fmt.FormatOptions,
-            writer: anytype,
+            writer: *std.Io.Writer,
         ) !void {
-            _ = layout;
-            _ = opts;
-            try std.fmt.format(writer, "ESC [ {s} {any} {c}", .{
+            try writer.print("ESC [ {s} {any} {c}", .{
                 self.intermediates,
                 self.params,
                 self.final,
@@ -118,13 +114,9 @@ pub const Action = union(enum) {
         // Implement formatter for logging
         pub fn format(
             self: ESC,
-            comptime layout: []const u8,
-            opts: std.fmt.FormatOptions,
-            writer: anytype,
+            writer: *std.Io.Writer,
         ) !void {
-            _ = layout;
-            _ = opts;
-            try std.fmt.format(writer, "ESC {s} {c}", .{
+            try writer.print("ESC {s} {c}", .{
                 self.intermediates,
                 self.final,
             });
@@ -142,11 +134,8 @@ pub const Action = union(enum) {
     // print out custom formats for some of our primitives.
     pub fn format(
         self: Action,
-        comptime layout: []const u8,
-        opts: std.fmt.FormatOptions,
-        writer: anytype,
+        writer: *std.Io.Writer,
     ) !void {
-        _ = layout;
         const T = Action;
         const info = @typeInfo(T).@"union";
 
@@ -162,21 +151,20 @@ pub const Action = union(enum) {
                     const value = @field(self, u_field.name);
                     switch (@TypeOf(value)) {
                         // Unicode
-                        u21 => try std.fmt.format(writer, "'{u}' (U+{X})", .{ value, value }),
+                        u21 => try writer.print("'{u}' (U+{X})", .{ value, value }),
 
                         // Byte
-                        u8 => try std.fmt.format(writer, "0x{x}", .{value}),
+                        u8 => try writer.print("0x{x}", .{value}),
 
                         // Note: we don't do ASCII (u8) because there are a lot
                         // of invisible characters we don't want to handle right
                         // now.
 
                         // All others do the default behavior
-                        else => try std.fmt.formatType(
-                            @field(self, u_field.name),
+                        else => try writer.printValue(
                             "any",
-                            opts,
-                            writer,
+                            .{},
+                            @field(self, u_field.name),
                             3,
                         ),
                     }
@@ -391,7 +379,7 @@ inline fn doAction(self: *Parser, action: TransitionAction, c: u8) ?Action {
             // We only allow colon or mixed separators for the 'm' command.
             if (c != 'm' and self.params_sep.count() > 0) {
                 log.warn(
-                    "CSI colon or mixed separators only allowed for 'm' command, got: {}",
+                    "CSI colon or mixed separators only allowed for 'm' command, got: {f}",
                     .{result},
                 );
                 break :csi_dispatch null;