aboutsummaryrefslogtreecommitdiff
path: root/vendor/libghostty-vt/src/terminal/c/io.zig
diff options
context:
space:
mode:
authorCan Celik <ogulcancelik@gmail.com>2026-09-10 21:51:57 +0300
committerGitHub <noreply@github.com>2026-09-10 21:51:57 +0300
commit425c86179791cd32e2d4ce0ae7f269940b4b0663 (patch)
treee52c4383a6d69216cbe2a32638bf90841d7e2189 /vendor/libghostty-vt/src/terminal/c/io.zig
parent90e947a6e26e02f10ec7f1694c4eb5b78a86406b (diff)
chore: upgrade libghostty and preserve terminal behavior (#3906)
Diffstat (limited to 'vendor/libghostty-vt/src/terminal/c/io.zig')
-rw-r--r--vendor/libghostty-vt/src/terminal/c/io.zig774
1 files changed, 774 insertions, 0 deletions
diff --git a/vendor/libghostty-vt/src/terminal/c/io.zig b/vendor/libghostty-vt/src/terminal/c/io.zig
new file mode 100644
index 00000000..76e7451d
--- /dev/null
+++ b/vendor/libghostty-vt/src/terminal/c/io.zig
@@ -0,0 +1,774 @@
+//! C byte-stream callbacks and adapters for `std.Io`.
+//!
+//! The public callbacks deliberately expose a smaller contract than Zig's I/O
+//! interfaces: reads are synchronous progress/EOF/error, and writes accept an
+//! entire slice or fail. These adapters translate that contract while keeping
+//! enough state to map failures back to distinct C result codes.
+
+const std = @import("std");
+const assert = std.debug.assert;
+const lib = @import("../lib.zig");
+
+/// C: GhosttyReaderFn
+pub const ReaderFn = *const fn (
+ userdata: ?*anyopaque,
+ buffer: [*]u8,
+ capacity: usize,
+ out_read: *usize,
+) callconv(lib.calling_conv) bool;
+
+/// C: GhosttyWriterFn
+pub const WriterFn = *const fn (
+ userdata: ?*anyopaque,
+ data: [*]const u8,
+ len: usize,
+) callconv(lib.calling_conv) bool;
+
+/// C: GhosttyReader
+pub const Reader = extern struct {
+ read: ?ReaderFn = null,
+ userdata: ?*anyopaque = null,
+
+ pub fn valid(self: Reader) bool {
+ return self.read != null;
+ }
+};
+
+/// C: GhosttyWriter
+pub const Writer = extern struct {
+ write: ?WriterFn = null,
+ userdata: ?*anyopaque = null,
+
+ pub fn valid(self: Writer) bool {
+ return self.write != null;
+ }
+};
+
+/// C: GhosttyMimeReaderFn
+pub const MimeReaderFn = *const fn (
+ userdata: ?*anyopaque,
+ mime: lib.String,
+ writer: Writer,
+) callconv(lib.calling_conv) bool;
+
+/// C: GhosttyMimeReader
+pub const MimeReader = extern struct {
+ read: ?MimeReaderFn = null,
+ userdata: ?*anyopaque = null,
+
+ pub fn valid(self: MimeReader) bool {
+ return self.read != null;
+ }
+};
+
+/// Adapts a `GhosttyReader` to `std.Io.Reader`.
+///
+/// The adapter must have a stable address while `interface` is in use. Its
+/// interface starts unbuffered so `init` can safely return it by value. A
+/// one-byte buffer is attached lazily when an operation such as `peekByte`
+/// requires buffering. This also prevents reads beyond a requested framing
+/// boundary.
+pub const ReaderAdapter = struct {
+ /// Copy of the C callback pair. The pointed-to userdata remains borrowed.
+ source: Reader,
+
+ /// Zig-facing interface. Its vtable recovers this enclosing adapter with
+ /// `@fieldParentPtr`, which is why the adapter's address must remain stable.
+ interface: std.Io.Reader,
+
+ /// Bytes successfully obtained from the callback.
+ offset: usize = 0,
+
+ /// The callback returned false. This distinguishes an I/O failure from
+ /// the callback returning true with zero bytes at end-of-file.
+ callback_failed: bool = false,
+
+ /// The callback was NULL, returned too many bytes, or overflowed offset.
+ invalid_read: bool = false,
+
+ /// The callback returned true with zero bytes. EOF is permanent.
+ eof: bool = false,
+
+ /// `std.Io.Reader` needs backing storage for `peekByte`. One byte is
+ /// intentional: it satisfies that operation without allowing the adapter
+ /// to pull a second byte across a snapshot checkpoint or FINISH boundary.
+ peek_buffer: [1]u8 = undefined,
+
+ /// Scratch space used only when the destination writer has no writable
+ /// buffer of its own. 4 KiB amortizes callback overhead for streaming
+ /// operations while keeping every adapter's fixed allocation modest. The
+ /// caller's `limit` always truncates this slice, so the size cannot cause
+ /// framing read-ahead.
+ transfer_buffer: [4096]u8 = undefined,
+
+ pub fn init(source: Reader) ReaderAdapter {
+ return .{
+ .source = source,
+ .interface = .{
+ .vtable = &.{
+ .stream = stream,
+ .rebase = rebase,
+ },
+ // `rebase` attaches peek_buffer after the adapter reaches its
+ // stable destination address.
+ .buffer = &.{},
+ .seek = 0,
+ .end = 0,
+ },
+ };
+ }
+
+ pub fn reader(self: *ReaderAdapter) *std.Io.Reader {
+ // Calling this only after the adapter reaches its final address makes
+ // the parent-pointer recovery in `stream` and `rebase` valid.
+ return &self.interface;
+ }
+
+ /// Perform exactly one C callback invocation into caller-selected storage.
+ /// This is the single place that interprets the public callback contract.
+ fn readInto(self: *ReaderAdapter, destination: []u8) std.Io.Reader.Error!usize {
+ assert(destination.len > 0);
+
+ // Failure and EOF are sticky. In particular, a callback that reports
+ // EOF is never polled again because the C API defines it as permanent.
+ if (self.callback_failed or self.invalid_read) return error.ReadFailed;
+ if (self.eof) return error.EndOfStream;
+
+ // A missing callback is an invalid C value rather than external I/O
+ // failure, so record it separately for the public result mapper.
+ const read_fn = self.source.read orelse {
+ self.invalid_read = true;
+ return error.ReadFailed;
+ };
+
+ // Initialize this ourselves: a callback returning false is not
+ // required to initialize out_read.
+ var read_len: usize = 0;
+ if (!read_fn(
+ self.source.userdata,
+ destination.ptr,
+ destination.len,
+ &read_len,
+ )) {
+ self.callback_failed = true;
+ return error.ReadFailed;
+ }
+
+ // Treat a callback that violates the capacity contract as an invalid
+ // reader without constructing an out-of-bounds slice.
+ if (read_len > destination.len) {
+ self.invalid_read = true;
+ return error.ReadFailed;
+ }
+ // Successful zero-length reads are the C representation of EOF.
+ if (read_len == 0) {
+ self.eof = true;
+ return error.EndOfStream;
+ }
+
+ // Offset counts only bytes actually supplied by successful callbacks.
+ // Saturating or wrapping would make SOURCE_OFFSET untrustworthy.
+ self.offset = std.math.add(usize, self.offset, read_len) catch {
+ self.invalid_read = true;
+ return error.ReadFailed;
+ };
+ return read_len;
+ }
+
+ /// `stream` is the fundamental read primitive in `std.Io.Reader`'s
+ /// vtable. It moves at most `limit` bytes from the C source to the Zig
+ /// writer and reports the number transferred. Higher-level operations
+ /// such as `readSliceAll` and `peekByte` are implemented in terms of it.
+ fn stream(
+ reader_: *std.Io.Reader,
+ writer: *std.Io.Writer,
+ limit: std.Io.Limit,
+ ) std.Io.Reader.StreamError!usize {
+ // A zero limit is a successful no-op and must not invoke user code.
+ if (limit == .nothing) return 0;
+
+ // The std.Io callback receives only the embedded interface pointer.
+ // Recover the adapter to reach the C callback and accounting flags.
+ const self: *ReaderAdapter = @alignCast(@fieldParentPtr(
+ "interface",
+ reader_,
+ ));
+
+ // Use the destination's storage directly when possible. This is the
+ // normal path for readSlice operations and for filling peek_buffer.
+ const direct = limit.slice(writer.unusedCapacitySlice());
+ if (direct.len > 0) {
+ const read_len = try self.readInto(direct);
+ // `readInto` initialized these bytes outside the Writer API, so
+ // explicitly publish them to the destination.
+ writer.advance(read_len);
+ return read_len;
+ }
+
+ // An unbuffered Writer has no direct destination storage. Read into
+ // bounded adapter storage and then let its drain implementation take
+ // ownership of the complete slice.
+ const transfer = limit.slice(&self.transfer_buffer);
+ assert(transfer.len > 0);
+ const read_len = try self.readInto(transfer);
+ // writeAll either transfers this complete callback result or reports
+ // failure; returning a partial count would violate stream's contract.
+ try writer.writeAll(transfer[0..read_len]);
+ return read_len;
+ }
+
+ /// Give buffered reader operations contiguous storage on first demand.
+ /// Initialization cannot point at `peek_buffer` because `init` returns the
+ /// adapter by value and its final address is not known until afterward.
+ fn rebase(
+ reader_: *std.Io.Reader,
+ capacity: usize,
+ ) std.Io.Reader.RebaseError!void {
+ const self: *ReaderAdapter = @alignCast(@fieldParentPtr(
+ "interface",
+ reader_,
+ ));
+
+ if (reader_.buffer.len == 0) {
+ // No operation could have buffered bytes before storage existed.
+ assert(reader_.seek == 0);
+ assert(reader_.end == 0);
+ reader_.buffer = &self.peek_buffer;
+ }
+
+ // Like other std.Io.Reader implementations, contiguous peek capacity
+ // is limited by the reader's declared buffer capacity.
+ assert(capacity <= reader_.buffer.len);
+ // Avoid the default memmove when the unread tail already has room.
+ if (reader_.buffer.len - reader_.seek >= capacity) return;
+ return std.Io.Reader.defaultRebase(reader_, capacity);
+ }
+};
+
+/// Adapts a `GhosttyWriter` to a `std.Io.Writer`.
+///
+/// The adapter may be given a buffer via `initBuffered` so that the many
+/// small writes typical of streaming producers (e.g. the formatter) are
+/// batched into far fewer C callback invocations. A buffered adapter's owner
+/// must call `flush` on the interface before reporting success so that the
+/// public contract holds: success means the C callback has already accepted
+/// every byte.
+pub const WriterAdapter = struct {
+ /// Copy of the C callback pair. The pointed-to userdata remains borrowed.
+ destination: Writer,
+
+ /// Zig-facing interface whose drain vtable points back to this adapter.
+ interface: std.Io.Writer,
+
+ /// Bytes accepted by successful callback invocations. Buffered bytes are
+ /// counted only once a drain or flush hands them to the callback.
+ offset: usize = 0,
+
+ /// The callback returned false.
+ callback_failed: bool = false,
+
+ /// The callback was NULL or offset accounting overflowed.
+ invalid_write: bool = false,
+
+ /// The buffer length used by the C API entry points that stream through
+ /// a callback. 4 KiB amortizes callback overhead while keeping every
+ /// adapter's stack footprint modest, mirroring ReaderAdapter's
+ /// transfer_buffer sizing.
+ pub const recommended_buffer_len = 4096;
+
+ /// An unbuffered adapter: every Zig write reaches the callback
+ /// immediately and no flush is required before returning.
+ pub fn init(destination: Writer) WriterAdapter {
+ return initBuffered(destination, &.{});
+ }
+
+ /// A buffered adapter. The buffer must outlive the adapter and remain
+ /// at a stable address (it is referenced, not copied). The owner must
+ /// flush the interface before treating the operation as successful.
+ pub fn initBuffered(destination: Writer, buffer: []u8) WriterAdapter {
+ return .{
+ .destination = destination,
+ .interface = .{
+ .vtable = &.{ .drain = drain },
+ .buffer = buffer,
+ .end = 0,
+ },
+ };
+ }
+
+ pub fn writer(self: *WriterAdapter) *std.Io.Writer {
+ // As with ReaderAdapter, the returned interface borrows this stable
+ // enclosing address for parent-pointer recovery in the vtable.
+ return &self.interface;
+ }
+
+ /// Submit one ordinary slice through the all-or-nothing C write callback.
+ fn writeAll(self: *WriterAdapter, data: []const u8) std.Io.Writer.Error!void {
+ // Empty writes carry no information and should not call foreign code.
+ if (data.len == 0) return;
+
+ // Make failures sticky so a higher-level Zig retry cannot produce a
+ // misleading second callback after the output is already partial.
+ if (self.callback_failed or self.invalid_write) return error.WriteFailed;
+
+ // Missing callbacks are invalid arguments; false callback returns are
+ // external I/O errors. Preserve that distinction for the C wrapper.
+ const write_fn = self.destination.write orelse {
+ self.invalid_write = true;
+ return error.WriteFailed;
+ };
+ if (!write_fn(self.destination.userdata, data.ptr, data.len)) {
+ self.callback_failed = true;
+ return error.WriteFailed;
+ }
+
+ // Count bytes only after the callback accepts the complete slice.
+ self.offset = std.math.add(usize, self.offset, data.len) catch {
+ self.invalid_write = true;
+ return error.WriteFailed;
+ };
+ }
+
+ /// Write one slice, batching through the interface buffer when one is
+ /// attached. Slices that fit are parked in the buffer (a later drain or
+ /// flush hands them to the callback); anything larger goes to the
+ /// callback directly after the buffer is emptied to preserve ordering.
+ fn writeSlice(
+ self: *WriterAdapter,
+ writer_: *std.Io.Writer,
+ slice: []const u8,
+ ) std.Io.Writer.Error!void {
+ const buffer = writer_.buffer;
+ if (slice.len <= buffer.len - writer_.end) {
+ @memcpy(buffer[writer_.end..][0..slice.len], slice);
+ writer_.end += slice.len;
+ return;
+ }
+
+ if (writer_.end > 0) {
+ try self.writeAll(buffer[0..writer_.end]);
+ writer_.end = 0;
+ }
+
+ if (slice.len <= buffer.len) {
+ @memcpy(buffer[0..slice.len], slice);
+ writer_.end = slice.len;
+ } else {
+ try self.writeAll(slice);
+ }
+ }
+
+ /// Implement the sole primitive required by a std.Io.Writer.
+ ///
+ /// Zig represents a vector write as ordinary slices followed by the last
+ /// slice repeated `splat` times. The C callback has no vector form, so
+ /// this method expands that representation, batching through the
+ /// interface buffer when one is attached, and returns the total logical
+ /// byte count consumed from `data`. Bytes parked in the buffer count as
+ /// consumed; `std.Io.Writer.flush` drains them via this same method.
+ fn drain(
+ writer_: *std.Io.Writer,
+ data: []const []const u8,
+ splat: usize,
+ ) std.Io.Writer.Error!usize {
+ assert(data.len > 0); // The final element is always the splat pattern.
+
+ // The vtable receives the embedded Writer rather than our adapter.
+ const self: *WriterAdapter = @alignCast(@fieldParentPtr(
+ "interface",
+ writer_,
+ ));
+
+ // Buffered bytes must reach the destination before any of `data`.
+ if (writer_.end > 0) {
+ try self.writeAll(writer_.buffer[0..writer_.end]);
+ writer_.end = 0;
+ }
+
+ var consumed: usize = 0;
+ // Every element except the last is written exactly once.
+ for (data[0 .. data.len - 1]) |slice| {
+ try self.writeSlice(writer_, slice);
+ consumed = std.math.add(usize, consumed, slice.len) catch {
+ self.invalid_write = true;
+ return error.WriteFailed;
+ };
+ }
+
+ // std.Io uses the final element as a compact repeated pattern. A
+ // splat of zero means the final element is not part of this write.
+ const pattern = data[data.len - 1];
+ if (pattern.len == 1 and writer_.buffer.len > 0) {
+ // Single-byte splats (e.g. runs of blank cells) are memset
+ // into the buffer in bulk rather than repeated one write at
+ // a time.
+ const buffer = writer_.buffer;
+ var remaining = splat;
+ while (remaining > 0) {
+ if (writer_.end == buffer.len) {
+ try self.writeAll(buffer);
+ writer_.end = 0;
+ }
+ const n = @min(remaining, buffer.len - writer_.end);
+ @memset(buffer[writer_.end..][0..n], pattern[0]);
+ writer_.end += n;
+ remaining -= n;
+ }
+ consumed = std.math.add(usize, consumed, splat) catch {
+ self.invalid_write = true;
+ return error.WriteFailed;
+ };
+ } else for (0..splat) |_| {
+ try self.writeSlice(writer_, pattern);
+ consumed = std.math.add(usize, consumed, pattern.len) catch {
+ self.invalid_write = true;
+ return error.WriteFailed;
+ };
+ }
+ return consumed;
+ }
+};
+
+test "C reader and writer layouts keep callback first" {
+ try std.testing.expectEqual(@as(usize, 0), @offsetOf(Reader, "read"));
+ try std.testing.expectEqual(@sizeOf(?ReaderFn), @offsetOf(Reader, "userdata"));
+ try std.testing.expectEqual(@sizeOf(?ReaderFn) + @sizeOf(?*anyopaque), @sizeOf(Reader));
+
+ try std.testing.expectEqual(@as(usize, 0), @offsetOf(Writer, "write"));
+ try std.testing.expectEqual(@as(usize, 0), @offsetOf(MimeReader, "read"));
+ try std.testing.expectEqual(@sizeOf(?MimeReaderFn), @offsetOf(MimeReader, "userdata"));
+ try std.testing.expectEqual(@sizeOf(?WriterFn), @offsetOf(Writer, "userdata"));
+ try std.testing.expectEqual(@sizeOf(?WriterFn) + @sizeOf(?*anyopaque), @sizeOf(Writer));
+}
+
+test "ReaderAdapter supports short reads and permanent EOF" {
+ const Context = struct {
+ data: []const u8,
+ offset: usize = 0,
+ calls: usize = 0,
+
+ fn read(
+ userdata: ?*anyopaque,
+ buffer: [*]u8,
+ capacity: usize,
+ out_read: *usize,
+ ) callconv(lib.calling_conv) bool {
+ const self: *@This() = @ptrCast(@alignCast(userdata.?));
+ self.calls += 1;
+ const remaining = self.data[self.offset..];
+ const len = @min(remaining.len, capacity, 2);
+ @memcpy(buffer[0..len], remaining[0..len]);
+ self.offset += len;
+ out_read.* = len;
+ return true;
+ }
+ };
+
+ var context: Context = .{ .data = "abcdef" };
+ var adapter: ReaderAdapter = .init(.{
+ .read = &Context.read,
+ .userdata = &context,
+ });
+
+ var actual: [6]u8 = undefined;
+ try adapter.interface.readSliceAll(&actual);
+ try std.testing.expectEqualStrings("abcdef", &actual);
+ try std.testing.expectEqual(@as(usize, 6), adapter.offset);
+ try std.testing.expect(!adapter.eof);
+
+ try std.testing.expectError(error.EndOfStream, adapter.interface.takeByte());
+ try std.testing.expect(adapter.eof);
+ try std.testing.expect(!adapter.callback_failed);
+
+ const calls_at_eof = context.calls;
+ try std.testing.expectError(error.EndOfStream, adapter.interface.takeByte());
+ try std.testing.expectEqual(calls_at_eof, context.calls);
+}
+
+test "ReaderAdapter peek reads only the requested byte" {
+ const Context = struct {
+ data: []const u8,
+ offset: usize = 0,
+ last_capacity: usize = 0,
+
+ fn read(
+ userdata: ?*anyopaque,
+ buffer: [*]u8,
+ capacity: usize,
+ out_read: *usize,
+ ) callconv(lib.calling_conv) bool {
+ const self: *@This() = @ptrCast(@alignCast(userdata.?));
+ self.last_capacity = capacity;
+ const remaining = self.data[self.offset..];
+ const len = @min(remaining.len, capacity);
+ @memcpy(buffer[0..len], remaining[0..len]);
+ self.offset += len;
+ out_read.* = len;
+ return true;
+ }
+ };
+
+ var context: Context = .{ .data = "ab" };
+ var adapter: ReaderAdapter = .init(.{
+ .read = &Context.read,
+ .userdata = &context,
+ });
+
+ try std.testing.expectEqual(@as(u8, 'a'), try adapter.interface.peekByte());
+ try std.testing.expectEqual(@as(usize, 1), context.last_capacity);
+ try std.testing.expectEqual(@as(usize, 1), adapter.offset);
+ try std.testing.expectEqual(@as(u8, 'a'), try adapter.interface.takeByte());
+ try std.testing.expectEqual(@as(usize, 1), adapter.offset);
+}
+
+test "ReaderAdapter distinguishes callback failure and invalid length" {
+ const Failing = struct {
+ fn read(
+ _: ?*anyopaque,
+ _: [*]u8,
+ _: usize,
+ _: *usize,
+ ) callconv(lib.calling_conv) bool {
+ return false;
+ }
+ };
+ var failing: ReaderAdapter = .init(.{ .read = &Failing.read });
+ try std.testing.expectError(error.ReadFailed, failing.interface.takeByte());
+ try std.testing.expect(failing.callback_failed);
+ try std.testing.expect(!failing.eof);
+ try std.testing.expect(!failing.invalid_read);
+
+ const Oversized = struct {
+ fn read(
+ _: ?*anyopaque,
+ _: [*]u8,
+ capacity: usize,
+ out_read: *usize,
+ ) callconv(lib.calling_conv) bool {
+ out_read.* = capacity + 1;
+ return true;
+ }
+ };
+ var oversized: ReaderAdapter = .init(.{ .read = &Oversized.read });
+ try std.testing.expectError(error.ReadFailed, oversized.interface.takeByte());
+ try std.testing.expect(!oversized.callback_failed);
+ try std.testing.expect(!oversized.eof);
+ try std.testing.expect(oversized.invalid_read);
+}
+
+test "ReaderAdapter rejects a null callback" {
+ var adapter: ReaderAdapter = .init(.{});
+ try std.testing.expectError(error.ReadFailed, adapter.interface.takeByte());
+ try std.testing.expect(adapter.invalid_read);
+ try std.testing.expect(!adapter.callback_failed);
+}
+
+test "WriterAdapter writes vectors and splats" {
+ const Context = struct {
+ data: [32]u8 = undefined,
+ len: usize = 0,
+
+ fn write(
+ userdata: ?*anyopaque,
+ data: [*]const u8,
+ len: usize,
+ ) callconv(lib.calling_conv) bool {
+ const self: *@This() = @ptrCast(@alignCast(userdata.?));
+ @memcpy(self.data[self.len..][0..len], data[0..len]);
+ self.len += len;
+ return true;
+ }
+ };
+
+ var context: Context = .{};
+ var adapter: WriterAdapter = .init(.{
+ .write = &Context.write,
+ .userdata = &context,
+ });
+
+ var vectors: [2][]const u8 = .{ "ab", "cd" };
+ try adapter.interface.writeVecAll(&vectors);
+ var repeated: [1][]const u8 = .{"!"};
+ try adapter.interface.writeSplatAll(&repeated, 2);
+
+ try std.testing.expectEqualStrings("abcd!!", context.data[0..context.len]);
+ try std.testing.expectEqual(@as(usize, 6), adapter.offset);
+ try std.testing.expect(!adapter.callback_failed);
+}
+
+test "WriterAdapter buffered batches small writes" {
+ const Context = struct {
+ data: [256]u8 = undefined,
+ len: usize = 0,
+ calls: usize = 0,
+
+ fn write(
+ userdata: ?*anyopaque,
+ data: [*]const u8,
+ len: usize,
+ ) callconv(lib.calling_conv) bool {
+ const self: *@This() = @ptrCast(@alignCast(userdata.?));
+ @memcpy(self.data[self.len..][0..len], data[0..len]);
+ self.len += len;
+ self.calls += 1;
+ return true;
+ }
+ };
+
+ var context: Context = .{};
+ var buffer: [64]u8 = undefined;
+ var adapter: WriterAdapter = .initBuffered(.{
+ .write = &Context.write,
+ .userdata = &context,
+ }, &buffer);
+
+ // Many small writes fit in the buffer: no callback yet.
+ for (0..16) |_| try adapter.interface.writeAll("ab");
+ try std.testing.expectEqual(@as(usize, 0), context.calls);
+
+ // Flush delivers everything in a single call.
+ try adapter.interface.flush();
+ try std.testing.expectEqual(@as(usize, 1), context.calls);
+ try std.testing.expectEqualStrings(
+ "ab" ** 16,
+ context.data[0..context.len],
+ );
+ try std.testing.expectEqual(@as(usize, 32), adapter.offset);
+}
+
+test "WriterAdapter buffered splats and large writes" {
+ const Context = struct {
+ data: [256]u8 = undefined,
+ len: usize = 0,
+ calls: usize = 0,
+
+ fn write(
+ userdata: ?*anyopaque,
+ data: [*]const u8,
+ len: usize,
+ ) callconv(lib.calling_conv) bool {
+ const self: *@This() = @ptrCast(@alignCast(userdata.?));
+ @memcpy(self.data[self.len..][0..len], data[0..len]);
+ self.len += len;
+ self.calls += 1;
+ return true;
+ }
+ };
+
+ var context: Context = .{};
+ var buffer: [16]u8 = undefined;
+ var adapter: WriterAdapter = .initBuffered(.{
+ .write = &Context.write,
+ .userdata = &context,
+ }, &buffer);
+
+ // A splat larger than the buffer is chunked, not one call per byte.
+ try adapter.interface.splatByteAll(' ', 40);
+ // A write larger than the buffer flushes and goes to the callback
+ // directly.
+ try adapter.interface.writeAll("0123456789abcdef0"); // 17 > 16
+ try adapter.interface.writeAll("xy");
+ try adapter.interface.flush();
+
+ try std.testing.expectEqualStrings(
+ " " ** 40 ++ "0123456789abcdef0" ++ "xy",
+ context.data[0..context.len],
+ );
+ try std.testing.expectEqual(
+ @as(usize, context.len),
+ adapter.offset,
+ );
+ // Chunked delivery: far fewer calls than bytes.
+ try std.testing.expect(context.calls <= 6);
+}
+
+test "WriterAdapter makes callback failure sticky" {
+ const Context = struct {
+ calls: usize = 0,
+
+ fn write(
+ userdata: ?*anyopaque,
+ _: [*]const u8,
+ _: usize,
+ ) callconv(lib.calling_conv) bool {
+ const self: *@This() = @ptrCast(@alignCast(userdata.?));
+ self.calls += 1;
+ return false;
+ }
+ };
+
+ var context: Context = .{};
+ var adapter: WriterAdapter = .init(.{
+ .write = &Context.write,
+ .userdata = &context,
+ });
+ try std.testing.expectError(error.WriteFailed, adapter.interface.writeAll("x"));
+ try std.testing.expect(adapter.callback_failed);
+ try std.testing.expectEqual(@as(usize, 0), adapter.offset);
+
+ try std.testing.expectError(error.WriteFailed, adapter.interface.writeAll("y"));
+ try std.testing.expectEqual(@as(usize, 1), context.calls);
+}
+
+test "WriterAdapter rejects a null callback" {
+ var adapter: WriterAdapter = .init(.{});
+ try std.testing.expectError(error.WriteFailed, adapter.interface.writeAll("x"));
+ try std.testing.expect(adapter.invalid_write);
+ try std.testing.expect(!adapter.callback_failed);
+}
+
+test "ReaderAdapter streams into an unbuffered WriterAdapter" {
+ const ReadContext = struct {
+ data: []const u8,
+ offset: usize = 0,
+
+ fn read(
+ userdata: ?*anyopaque,
+ buffer: [*]u8,
+ capacity: usize,
+ out_read: *usize,
+ ) callconv(lib.calling_conv) bool {
+ const self: *@This() = @ptrCast(@alignCast(userdata.?));
+ const remaining = self.data[self.offset..];
+ const len = @min(remaining.len, capacity);
+ @memcpy(buffer[0..len], remaining[0..len]);
+ self.offset += len;
+ out_read.* = len;
+ return true;
+ }
+ };
+ const WriteContext = struct {
+ data: [8]u8 = undefined,
+ len: usize = 0,
+
+ fn write(
+ userdata: ?*anyopaque,
+ data: [*]const u8,
+ len: usize,
+ ) callconv(lib.calling_conv) bool {
+ const self: *@This() = @ptrCast(@alignCast(userdata.?));
+ @memcpy(self.data[self.len..][0..len], data[0..len]);
+ self.len += len;
+ return true;
+ }
+ };
+
+ var read_context: ReadContext = .{ .data = "stream" };
+ var reader: ReaderAdapter = .init(.{
+ .read = &ReadContext.read,
+ .userdata = &read_context,
+ });
+ var write_context: WriteContext = .{};
+ var writer: WriterAdapter = .init(.{
+ .write = &WriteContext.write,
+ .userdata = &write_context,
+ });
+
+ try reader.interface.streamExact(&writer.interface, "stream".len);
+ try std.testing.expectEqualStrings(
+ "stream",
+ write_context.data[0..write_context.len],
+ );
+ try std.testing.expectEqual(@as(usize, "stream".len), reader.offset);
+ try std.testing.expectEqual(@as(usize, "stream".len), writer.offset);
+}