summaryrefslogtreecommitdiff
path: root/src/terminal.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-10-23 17:10:58 -0300
committerGabriel Schneider <[email protected]>2026-10-23 17:10:58 -0300
commit0073d05329335dbb0eb85f5c3044e42805d144e5 (patch)
tree744edfc317719b2018b1c3a8657c223aec058d47 /src/terminal.zig
parenta8b457a306a4442975210bcac3f04b56513c61c3 (diff)
downloadpardes-0073d05329335dbb0eb85f5c3044e42805d144e5.tar.gz
pardes-0073d05329335dbb0eb85f5c3044e42805d144e5.zip
Callstack lists every caller and pages a tree too big for one query; memory bounds and resident-size fixes
Callstack walks while the server answers, counts on the message row past a second, puts test callers last at each level, and ends a tree past one query's memory (memory.limits.arena.lsp_query, a 256 MiB region taken and given back per query) in a row whose Callstack shows the next page. Grep reads whole files. New hard limits: undo text per file, image decode pixels, the LSP snapshot of other open files, one paste. Safe builds no longer fill worst-case buffers with 0xAA (memory.unfilled), big regions are kept off transparent huge pages, and malloc_trim runs after big results. Also: Look's git show pages into a +Diff, and dropped marks in File. Co-Authored-By: Claude Opus 5.5 <[email protected]>
Diffstat (limited to 'src/terminal.zig')
-rw-r--r--src/terminal.zig86
1 files changed, 8 insertions, 78 deletions
diff --git a/src/terminal.zig b/src/terminal.zig
index 33ad22e6..05054521 100644
--- a/src/terminal.zig
+++ b/src/terminal.zig
@@ -1,4 +1,4 @@
-//! A terminal pane: its VT emulator and replay, prompt rows, the edit overlay
+//! A terminal pane: its VT emulator, prompt rows, the edit overlay
//! typed over shell rows, and the Filter that recolours output to the theme.
const panes = @import("panes.zig");
const std = @import("std");
@@ -141,16 +141,9 @@ pub const MarkedHandler = if (enabled) struct {
}
} else void;
-pub const Replay = struct {
- bytes: [1024 * 1024]u8 = undefined,
- head: usize = 0,
- len: usize = 0,
-};
-
pub const State = struct {
vt: VtSlot,
stream: StreamSlot,
- replay: Replay,
reply: [256]u8 = undefined,
reply_len: u16 = 0,
/// The grid cell the program last heard the mouse at, so motion is
@@ -613,8 +606,6 @@ pub fn create(gpa: std.mem.Allocator, cols: u16, rows: u16) !*Pane {
.kitty_image_storage_limit = if (images_enabled) TerminalImages.storage_limit else 0,
});
state.stream = .init(.{ .handler = .{ .inner = state.vt.vtHandler() }, .allocator = gpa });
- state.replay.head = 0;
- state.replay.len = 0;
state.reply_len = 0;
state.mouse_cell = null;
state.images = if (images_enabled) .{} else {};
@@ -678,43 +669,12 @@ pub fn restore(p: *Pardes, src: dump.Pane, live: bool) !*Pane {
return pane;
}
-/// Feed the emulator and retain the bounded suffix a dump can replay. Live
-/// output and restoration share this byte path, then apply different views.
+/// Feed the emulator. Live output and restoration share this byte path,
+/// then apply different views.
fn ingest(pane: *Pane, bytes: []const u8) void {
- const state = pane.terminal.?;
- const replay = &state.replay;
- if (bytes.len >= replay.bytes.len) {
- const kept = bytes[bytes.len - replay.bytes.len ..];
- @memcpy(&replay.bytes, kept);
- replay.head = 0;
- replay.len = replay.bytes.len;
- } else {
- const overflow = bytes.len -| (replay.bytes.len - replay.len);
- replay.head = (replay.head + overflow) % replay.bytes.len;
- replay.len -= overflow;
- const tail = (replay.head + replay.len) % replay.bytes.len;
- const first = @min(bytes.len, replay.bytes.len - tail);
- @memcpy(replay.bytes[tail..][0..first], bytes[0..first]);
- @memcpy(replay.bytes[0 .. bytes.len - first], bytes[first..]);
- replay.len += bytes.len;
- }
- state.stream.nextSlice(bytes);
+ pane.terminal.?.stream.nextSlice(bytes);
}
-/// Return the replay ring in chronological order. Wrapped records are copied
-/// into `allocator`; contiguous records remain a borrowed slice of the pane.
-fn replayBytes(pane: *const Pane, allocator: std.mem.Allocator) ![]const u8 {
- const state = pane.terminal orelse return &.{};
- const replay = &state.replay;
- if (replay.len == 0) return &.{};
- if (replay.head + replay.len <= replay.bytes.len)
- return replay.bytes[replay.head..][0..replay.len];
- const out = try allocator.alloc(u8, replay.len);
- const first = replay.bytes.len - replay.head;
- @memcpy(out[0..first], replay.bytes[replay.head..]);
- @memcpy(out[first..], replay.bytes[0 .. replay.len - first]);
- return out;
-}
test "replay ownership is terminal-only and construction rolls back on allocation failure" {
const Case = struct {
@@ -753,7 +713,6 @@ test "document construction allocates only the pane and has inert terminal defau
try std.testing.expectEqual(GridCursor{}, gridCursor(pane));
try std.testing.expectEqual(Scrollbar{}, scrollbar(pane));
try std.testing.expectEqualStrings("", try screenTextAlloc(pane, allocator));
- try std.testing.expectEqualStrings("", try replayBytes(pane, allocator));
try std.testing.expect(!failing.has_induced_failure);
}
@@ -779,46 +738,18 @@ test "terminal state keeps parser fragments and sends emulator replies through i
}
try std.testing.expectEqual(@as(usize, 1), replies);
try std.testing.expectEqual(@as(u16, 0), state.reply_len);
- try std.testing.expectEqualStrings("\x1b[6n", try replayBytes(pane, std.testing.allocator));
-}
-
-test "replay keeps a bounded chronological suffix across large writes and wrapping" {
- if (comptime !enabled) return error.SkipZigTest;
- const gpa = std.testing.allocator;
- const pane = try create(gpa, 40, 12);
- defer gpa.destroy(pane);
- defer deinitEmulator(pane, gpa);
- try std.testing.expectEqualStrings("", try replayBytes(pane, gpa));
- ingest(pane, "hello");
- const small = try replayBytes(pane, gpa);
- try std.testing.expectEqualStrings("hello", small);
- try std.testing.expectEqual(@intFromPtr(&pane.terminal.?.replay.bytes), @intFromPtr(small.ptr));
-
- const capacity = pane.terminal.?.replay.bytes.len;
- const input = try gpa.alloc(u8, capacity + 7);
- defer gpa.free(input);
- @memset(input, 0);
- const ending = "\x1b[31mred\x1b[0m\r\n";
- @memcpy(input[input.len - ending.len ..], ending);
- ingest(pane, input);
- try std.testing.expectEqualSlices(u8, input[7..], try replayBytes(pane, gpa));
- ingest(pane, "next\r\n");
- const wrapped = try replayBytes(pane, gpa);
- defer gpa.free(wrapped);
- try std.testing.expectEqual(capacity, wrapped.len);
- try std.testing.expectEqualSlices(u8, input[7 + "next\r\n".len ..], wrapped[0 .. capacity - "next\r\n".len]);
- try std.testing.expectEqualStrings("next\r\n", wrapped[capacity - "next\r\n".len ..]);
}
-test "replay restores terminal cells from the retained stream" {
+test "a terminal stream restores the cells it drew" {
if (comptime !enabled) return error.SkipZigTest;
const gpa = std.testing.allocator;
const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 40, .rows = 12 });
defer p.deinit();
while (p.nextEffect()) |_| {}
const pane = p.panes[0].?;
- feedOutput(p, pane, "\x1b[31mred\x1b[0m\r\ncafé\r\n");
- const encoded = try dump.encodeBytes(gpa, try replayBytes(pane, gpa));
+ const drawn = "\x1b[31mred\x1b[0m\r\ncafé\r\n";
+ feedOutput(p, pane, drawn);
+ const encoded = try dump.encodeBytes(gpa, drawn);
defer gpa.free(encoded);
const restored = try restore(p, .{
.kind = .terminal,
@@ -835,7 +766,6 @@ test "replay restores terminal cells from the retained stream" {
const after = try screenTextAlloc(restored, gpa);
defer gpa.free(after);
try std.testing.expectEqualStrings(before, after);
- try std.testing.expectEqualSlices(u8, try replayBytes(pane, gpa), try replayBytes(restored, gpa));
}
test "a restored command pane comes back finished, its command not run again" {