summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--build.zig.zon4
-rw-r--r--docs/typ/guide.typ14
-rw-r--r--docs/typ/reference.typ9
-rw-r--r--src/9p.zig24
-rw-r--r--src/9p_io.zig121
-rw-r--r--src/File.zig141
-rw-r--r--src/Registers.zig13
-rw-r--r--src/ShaderBuild.zig23
-rw-r--r--src/builtins.zig3
-rw-r--r--src/colors.zig2
-rw-r--r--src/config.zig66
-rw-r--r--src/crash.zig6
-rw-r--r--src/detached/server.zig29
-rw-r--r--src/dump.zig11
-rw-r--r--src/edit.zig190
-rw-r--r--src/exec.zig6
-rw-r--r--src/fs.zig82
-rw-r--r--src/gui/gui.zig329
-rw-r--r--src/gui/pet.zig29
-rw-r--r--src/host_io.zig103
-rw-r--r--src/hunks.zig19
-rw-r--r--src/image.zig8
-rw-r--r--src/locations.zig135
-rw-r--r--src/look.zig61
-rw-r--r--src/lsp/lsp.zig17
-rw-r--r--src/lsp/lsp_client.zig761
-rw-r--r--src/macos.zig17
-rw-r--r--src/main.zig12
-rw-r--r--src/memory.zig98
-rw-r--r--src/mini.zig16
-rw-r--r--src/modal.zig139
-rw-r--r--src/mouse.zig11
-rw-r--r--src/ninep/addr.zig42
-rw-r--r--src/ninep/ctl.zig4
-rw-r--r--src/panes.zig3
-rw-r--r--src/pardes.zig42
-rw-r--r--src/regexp.zig11
-rw-r--r--src/sam_edit.zig15
-rw-r--r--src/selection_pipe.zig11
-rw-r--r--src/surface.zig5
-rw-r--r--src/terminal.zig86
-rw-r--r--src/tty/tty.zig51
-rw-r--r--test/lspbench.zig22
-rw-r--r--test/panes.zig3
-rw-r--r--test/perf-baseline-gui-debug.json2
-rw-r--r--test/perf-baseline-tty-debug.json2
-rw-r--r--test/perf-baseline-tty-fast.json2
-rw-r--r--test/perf.zig21
48 files changed, 1843 insertions, 978 deletions
diff --git a/build.zig.zon b/build.zig.zon
index 292bd479..7885fd4e 100644
--- a/build.zig.zon
+++ b/build.zig.zon
@@ -9,8 +9,8 @@
// read-only HTTPS URL is what a manifest can carry. Re-pin with
// `zig fetch --save=cloud9 git+https://git.sr.ht/~gbrls/cloud9#<commit>`.
.cloud9 = .{
- .url = "git+https://git.sr.ht/~gbrls/cloud9#d5c37d9122240fe95d308fbe15874e14dd786c5a",
- .hash = "cloud9-0.1.0-yt86qnAvHgB1dEWGakukcJ54GZ7J3mv_lm_kApzAuEOY",
+ .url = "git+https://git.sr.ht/~gbrls/cloud9#0702e33bcfadf0abd9ccbaa8b681a19a84c332fe",
+ .hash = "cloud9-0.1.0-yt86qkExHgCRI7_eJsztRECamioWguBj2mTFsJ5N-AOn",
},
// Pinned to the exact libvaxis commit ghostty is built against, so it
// is compatible with ghostty's uucode configuration (the one we share
diff --git a/docs/typ/guide.typ b/docs/typ/guide.typ
index a5327a44..e60b4231 100644
--- a/docs/typ/guide.typ
+++ b/docs/typ/guide.typ
@@ -240,11 +240,19 @@ wrapping. Cross-directory Look paths are shortened when possible.
pane. #word("LookNext") / #word("LookPrev") (#keys("SPC j n", "SPC j p"))
select locations without opening them. The view follows the language
server's static call hierarchy; recursive paths are marked `↻`, and a
-large hierarchy invites continuing from another function.
+hierarchy deeper than the limit invites continuing from another function.
+Every caller is listed: the walk runs as long as the server keeps answering,
+says how many callers it has found on the message row once it takes more
+than a second, and shows what it found if the server stops answering.
+Asking anything else stops it. A tree too big for one page (about 100,000
+rows, the memory one query may use) ends in a row saying so: running
+#word("Callstack") in `+Callstack` shows the next page, from where this
+one stopped, with that caller's own callers above it again.
+At each level, callers whose function or file name contains "test" come
+after the rest.
#word("CallstackDepth") reports the current caller depth;
`CallstackDepth 16` changes it for subsequent queries. The default is 8
-levels, and the accepted range is 1–64. The view also caps collection at
-64 callers.
+levels, and the accepted range is 1–64.
`CallstackLayout stacked` (the default) puts each signature and call snippet below its
location, aligned with the location text; `CallstackLayout inline` puts it
diff --git a/docs/typ/reference.typ b/docs/typ/reference.typ
index bb13b011..c14ad659 100644
--- a/docs/typ/reference.typ
+++ b/docs/typ/reference.typ
@@ -264,7 +264,9 @@ A line written to #file("exec") is #word("Exec"):
a declaration; from a use it reaches every file);
#word("Callstack") (#key("g c") or #key("SPC l b")) opens and focuses `+Callstack`,
with static caller ancestry, tree-sitter signatures and Look locations
- for callers and call sites. #word("CallstackDepth") reports or sets the
+ for callers and call sites, test callers after the rest at each level; run
+ in `+Callstack` itself, it shows the next page of a tree too big for one.
+ #word("CallstackDepth") reports or sets the
runtime depth (1–64, default 8) for subsequent queries.
`CallstackLayout stacked` (the default) aligns snippets below their locations;
`CallstackLayout inline` places the snippets beside them.
@@ -971,12 +973,11 @@ one a #file("exec") open still holds is never reused. In a command pane, #key("n
= Find and Grep <find-grep>
#word("Find") matches file names, #word("Grep") the text of lines, both literally and
-ignoring ASCII case. #word("Grep") reads at most 256 KiB of a file and stops at 512
+ignoring ASCII case. #word("Grep") reads whole files and stops at 512
hits, #word("Find") at 512 names. The walk stops at 20000 files or 100000 entries,
16 deep, and passes over `.git`, `.jj`, `target`, `node_modules`,
`.venv`, `__pycache__`, `.zig-cache` and `zig-out`. A cap hit, or a
-directory it could not open, is said at the end: `cut at 512 hits`, `N
-files read only in part (first 256 KiB)`, `walk cut at N entries`, `N
+directory it could not open, is said at the end: `cut at 512 hits`, `walk cut at N entries`, `N
directories skipped: permission denied`. A search that finds nothing and
skipped nothing fails, `Grep: text not found`, and leaves the `+Search` as
it was.
diff --git a/src/9p.zig b/src/9p.zig
index 67b3b39a..0979b66a 100644
--- a/src/9p.zig
+++ b/src/9p.zig
@@ -5,16 +5,10 @@
const cloud9 = @import("cloud9");
pub const fs = cloud9.fs;
pub const Server = cloud9.fs.Server;
-pub const Error = cloud9.Error;
-pub const Type = cloud9.Type;
-pub const isT = cloud9.isT;
pub const header_len = cloud9.header_len;
-pub const qid_len = cloud9.qid_len;
-pub const stat_fixed = cloud9.stat_fixed;
pub const notag = cloud9.notag;
pub const nofid = cloud9.nofid;
pub const max_welem = cloud9.max_welem;
-pub const iohdrsz = cloud9.iohdrsz;
pub const Qid = cloud9.Qid;
pub const Stat = cloud9.Stat;
pub const Msg = cloud9.Msg;
@@ -23,29 +17,11 @@ pub const frameLen = cloud9.frameLen;
pub const encode = cloud9.encode;
pub const decode = cloud9.decode;
pub const qtdir = cloud9.qtdir;
-pub const qtappend = cloud9.qtappend;
-pub const qtexcl = cloud9.qtexcl;
-pub const qtmount = cloud9.qtmount;
-pub const qtauth = cloud9.qtauth;
-pub const qttmp = cloud9.qttmp;
-pub const qtfile = cloud9.qtfile;
-pub const dmdir = cloud9.dmdir;
-pub const dmappend = cloud9.dmappend;
-pub const dmexcl = cloud9.dmexcl;
-pub const dmmount = cloud9.dmmount;
-pub const dmauth = cloud9.dmauth;
-pub const dmtmp = cloud9.dmtmp;
-pub const dmperm = cloud9.dmperm;
pub const Client = cloud9.Client;
-pub const ClientError = cloud9.ClientError;
-pub const max_tags = cloud9.max_tags;
pub const oread = cloud9.oread;
pub const owrite = cloud9.owrite;
pub const ordwr = cloud9.ordwr;
-pub const oexec = cloud9.oexec;
pub const otrunc = cloud9.otrunc;
-pub const ocexec = cloud9.ocexec;
-pub const orclose = cloud9.orclose;
pub const errmax = cloud9.fs.errmax;
pub const errString = cloud9.fs.errString;
pub const msize_min = cloud9.fs.msize_min;
diff --git a/src/9p_io.zig b/src/9p_io.zig
index 446c24de..87972b43 100644
--- a/src/9p_io.zig
+++ b/src/9p_io.zig
@@ -174,8 +174,15 @@ pub const Listener = struct {
io: std.Io,
/// The core that answers; `reset` puts a replacement in.
core: *pardes.Pardes,
- runner: Runner = undefined,
+ /// cloud9's runner, sized for every connection's buffers and parks (some
+ /// 136 MiB): pages of its own (`allocRunner`), written only as clients
+ /// take slots, so an idle session does not hold them resident.
+ runner: *Runner = undefined,
stopping: std.atomic.Value(bool) = .init(false),
+ /// The watchers of held Edit writes (watchEdit): canceled and awaited
+ /// by `deinit`, once the turn lets a waiting one through, so none wakes
+ /// into a freed Listener.
+ edit_watchers: std.Io.Group = .init,
/// A connection wrote the Restore and has yet to answer it.
restore_writer: std.atomic.Value(bool) = .init(false),
/// Clients turned away with every slot taken, since the log last said so.
@@ -354,8 +361,7 @@ pub const Listener = struct {
const later: pardes.ctlfs.Reply = .{ .tag = req.tag, .status = .again };
const ticket = conn.hold(&later) orelse return;
core.fs.edit_hold = .{ .asker = conn, .slot = ticket.slot, .seq = ticket.seq, .tag = req.tag, .node = req.node, .handle = req.handle, .written = reply.written };
- const watcher = std.Thread.spawn(.{}, watchEdit, .{ l, conn, ticket }) catch return;
- watcher.detach();
+ l.edit_watchers.concurrent(l.io, watchEdit, .{ l, conn, ticket }) catch {};
return;
}
const restoring = core.restore_req != null;
@@ -457,13 +463,13 @@ pub const Listener = struct {
/// flush, so it is looked for, every 100 ms; a park out for a retry is
/// not waiting either, so only three looks in a row with no write being
/// served count.
- fn watchEdit(l: *Listener, conn: *Runner.Conn, ticket: cloud9.fs.Ticket) void {
- const io = pardes.turn.io orelse return;
+ fn watchEdit(l: *Listener, conn: *Runner.Conn, ticket: cloud9.fs.Ticket) error{Canceled}!void {
var misses: u8 = 0;
while (!l.stopping.load(.acquire)) {
- io.sleep(.fromMilliseconds(100), .awake) catch return;
+ try l.io.sleep(.fromMilliseconds(100), .awake);
_ = pardes.turn.take();
defer pardes.turn.give();
+ if (l.stopping.load(.acquire)) return;
const core = l.core;
const h = core.fs.edit_hold orelse return;
if (h.slot != ticket.slot or h.seq != ticket.seq or h.asker != @as(*anyopaque, conn)) return;
@@ -914,6 +920,7 @@ pub const Listener = struct {
// A connection task may be waiting for the turn; it answers
// nothing more once stopping, but the wait itself must end.
pardes.turn.rest();
+ l.edit_watchers.cancel(l.io);
// An answer given as the editor quit (a Kill written to /ctl)
// may still be on its way out: let it go before the cut.
const deadline = nowMs() +| 200;
@@ -942,10 +949,26 @@ pub const Listener = struct {
z[l.path_len] = 0;
_ = libc.unlink(z[0..l.path_len :0]);
}
+ freeRunner(l.runner);
gpa.destroy(l);
}
};
+/// The runner's memory, from the page allocator with no fill: an Allocator's
+/// `create` writes `undefined` over all of it in a safe build, which would make
+/// every page resident at startup.
+fn allocRunner() ?*Runner {
+ if (comptime !supported) return @constCast(&@as(Runner, {}));
+ const bytes = std.heap.page_allocator.rawAlloc(@sizeOf(Runner), .of(Runner), @returnAddress()) orelse return null;
+ @import("memory.zig").sparse(bytes[0..@sizeOf(Runner)]);
+ return @ptrCast(@alignCast(bytes));
+}
+
+fn freeRunner(runner: *Runner) void {
+ if (comptime !supported) return;
+ std.heap.page_allocator.rawFree(@as([*]u8, @ptrCast(runner))[0..@sizeOf(Runner)], .of(Runner), @returnAddress());
+}
+
/// The socket this process listens on, kept where a fatal signal's handler
/// can reach it without allocating (unlinkOwnSocket); empty when none.
var own_socket: [sun_path_len:0]u8 = undefined;
@@ -1065,6 +1088,10 @@ pub fn listen(io: std.Io, gpa: std.mem.Allocator, core: *pardes.Pardes, named: [
}
const l = gpa.create(Listener) catch return null;
l.* = .{ .io = io, .core = core };
+ l.runner = allocRunner() orelse {
+ gpa.destroy(l);
+ return null;
+ };
pardes.turn.start(io);
pardes.turn.wake_parked = Listener.wakeParked;
pardes.turn.answer_held = Listener.answerHeld;
@@ -1551,7 +1578,7 @@ test "a socket path too long for sun_path is no listener, and leaves the editor'
defer if (old_copy) |o| {
_ = setenv("XDG_RUNTIME_DIR", o, 1);
} else {
- _ = unsetenv("XDG_RUNTIME_DIR");
+ _ = @import("host_io.zig").testUnsetenv("XDG_RUNTIME_DIR");
};
const long = &@as([120]u8, @splat('n'));
try testing.expect(listen(testing.io, testing.allocator, p, long, "", null, null) == null);
@@ -1572,7 +1599,7 @@ test "a listening editor posts itself into the 9P registry and unposts on stop"
if (old_runtime) |v| {
_ = setenv("XDG_RUNTIME_DIR", v, 1);
gpa.free(v);
- } else _ = unsetenv("XDG_RUNTIME_DIR");
+ } else _ = @import("host_io.zig").testUnsetenv("XDG_RUNTIME_DIR");
}
try testing.expectEqual(@as(c_int, 0), setenv("XDG_RUNTIME_DIR", &directory, 1));
@@ -1633,7 +1660,7 @@ test "Unix TCP and QUIC share one listener through reads writes reconnects and r
if (old_runtime) |v| {
_ = setenv("XDG_RUNTIME_DIR", v, 1);
gpa.free(v);
- } else _ = unsetenv("XDG_RUNTIME_DIR");
+ } else _ = @import("host_io.zig").testUnsetenv("XDG_RUNTIME_DIR");
}
try testing.expectEqual(@as(c_int, 0), setenv("XDG_RUNTIME_DIR", &directory, 1));
const replacement = try gpa.alloc(u8, 3 * msize + 27);
@@ -1754,7 +1781,7 @@ test "a change waits while the editor is out mid-step, a read does not, and the
if (old_runtime) |v| {
_ = setenv("XDG_RUNTIME_DIR", v, 1);
gpa.free(v);
- } else _ = unsetenv("XDG_RUNTIME_DIR");
+ } else _ = @import("host_io.zig").testUnsetenv("XDG_RUNTIME_DIR");
}
try testing.expectEqual(@as(c_int, 0), setenv("XDG_RUNTIME_DIR", &directory, 1));
@@ -1829,7 +1856,7 @@ test "a held read is answered when the log has news, and a flushed one spends no
if (old_runtime) |v| {
_ = setenv("XDG_RUNTIME_DIR", v, 1);
gpa.free(v);
- } else _ = unsetenv("XDG_RUNTIME_DIR");
+ } else _ = @import("host_io.zig").testUnsetenv("XDG_RUNTIME_DIR");
}
try testing.expectEqual(@as(c_int, 0), setenv("XDG_RUNTIME_DIR", &directory, 1));
@@ -2001,28 +2028,22 @@ pub fn exportSessionEnv(serial: u32, adopts: bool) void {
exportEnv(if (own_socket_len > 0) own_socket[0..own_socket_len] else null, serial, adopts);
}
+/// Told to children through host_io.ChildEnv, never set into this process's
+/// own environment (see ChildEnv.exportVar for why).
fn exportEnv(socket: ?[]const u8, serial: u32, adopts: bool) void {
- var announced = false;
- if (adopts) announcing: {
- var buf: [16]u8 = undefined;
- const text = std.fmt.bufPrintSentinel(&buf, "{d}", .{@as(u32, @intCast(libc.getpid()))}, 0) catch
- break :announcing;
- announced = setenv("PARDES_PID", text, 1) == 0;
- }
- if (!announced) _ = unsetenv("PARDES_PID");
-
- if (socket) |own| exporting: {
- var sock: [sun_path_len]u8 = undefined;
- const path = std.fmt.bufPrintSentinel(&sock, "{s}", .{own}, 0) catch break :exporting;
+ const ChildEnv = @import("host_io.zig").ChildEnv;
+ var pid_buf: [16]u8 = undefined;
+ ChildEnv.exportVar("PARDES_PID", if (adopts) std.fmt.bufPrint(&pid_buf, "{d}", .{@as(u32, @intCast(libc.getpid()))}) catch null else null);
+ if (socket) |own| {
var buf: [16]u8 = undefined;
- const id = std.fmt.bufPrintSentinel(&buf, "{d}", .{serial}, 0) catch break :exporting;
- if (setenv("PARDES_9P", path, 1) != 0) break :exporting;
+ ChildEnv.exportVar("PARDES_9P", own);
exportMount(own);
- if (setenv("PARDES_PANE", id, 1) == 0) return;
+ ChildEnv.exportVar("PARDES_PANE", std.fmt.bufPrint(&buf, "{d}", .{serial}) catch unreachable);
+ return;
}
- _ = unsetenv("PARDES_9P");
- _ = unsetenv("PARDES_PANE");
- _ = unsetenv("PARDES_MOUNT");
+ ChildEnv.exportVar("PARDES_9P", null);
+ ChildEnv.exportVar("PARDES_PANE", null);
+ ChildEnv.exportVar("PARDES_MOUNT", null);
}
/// $PARDES_MOUNT, the session's own directory, when the environment says
@@ -2040,11 +2061,11 @@ fn exportMount(sock_path: []const u8) void {
const suffix = ".sock";
if (mntgen and root.len > 0 and std.mem.startsWith(u8, base, sock_prefix) and std.mem.endsWith(u8, base, suffix) and base.len > sock_prefix.len + suffix.len) {
var buf: [4096]u8 = undefined;
- if (std.fmt.bufPrintSentinel(&buf, "{s}/pardes/{s}", .{ std.mem.trimEnd(u8, root, "/"), base[sock_prefix.len .. base.len - suffix.len] }, 0)) |mount| {
- if (setenv("PARDES_MOUNT", mount, 1) == 0) return;
+ if (std.fmt.bufPrint(&buf, "{s}/pardes/{s}", .{ std.mem.trimEnd(u8, root, "/"), base[sock_prefix.len .. base.len - suffix.len] })) |mount| {
+ return @import("host_io.zig").ChildEnv.exportVar("PARDES_MOUNT", mount);
} else |_| {}
}
- _ = unsetenv("PARDES_MOUNT");
+ @import("host_io.zig").ChildEnv.exportVar("PARDES_MOUNT", null);
}
test "a pane's PARDES_MOUNT is the session's directory under 9ns --mntgen, and unset when not known" {
@@ -2057,16 +2078,16 @@ test "a pane's PARDES_MOUNT is the session's directory under 9ns --mntgen, and u
if (value) |old| {
_ = setenv(name, old, 1);
testing.allocator.free(old);
- } else _ = unsetenv(name);
+ } else _ = @import("host_io.zig").testUnsetenv(name);
};
_ = setenv("NINE_MOUNT", "/mnt/9p", 1);
_ = setenv("NINE_MNTGEN", "1", 1);
exportMount("/run/user/1000/pardes-9p-work.sock");
- try testing.expectEqualStrings("/mnt/9p/pardes/work", std.mem.span(libc.getenv("PARDES_MOUNT").?));
+ try testing.expectEqualStrings("/mnt/9p/pardes/work", @import("host_io.zig").ChildEnv.exported("PARDES_MOUNT").?);
// A mount of another server (9ns --unix): not this session's.
- _ = unsetenv("NINE_MNTGEN");
+ _ = @import("host_io.zig").testUnsetenv("NINE_MNTGEN");
exportMount("/run/user/1000/pardes-9p-work.sock");
- try testing.expect(libc.getenv("PARDES_MOUNT") == null);
+ try testing.expect(@import("host_io.zig").ChildEnv.exported("PARDES_MOUNT") == null);
}
test "9P shell environment states being inside pardes apart from how to reach it" {
@@ -2079,16 +2100,16 @@ test "9P shell environment states being inside pardes apart from how to reach it
if (value) |old| {
_ = setenv(name, old, 1);
testing.allocator.free(old);
- } else _ = unsetenv(name);
+ } else _ = @import("host_io.zig").testUnsetenv(name);
};
var dir: [sun_path_len:0]u8 = undefined;
_ = setenv("XDG_RUNTIME_DIR", "/run/user/1000", 1);
try testing.expectEqualStrings("/run/user/1000", socketDir(&dir).?);
- _ = unsetenv("XDG_RUNTIME_DIR");
+ _ = @import("host_io.zig").testUnsetenv("XDG_RUNTIME_DIR");
_ = setenv("HOME", "/home/example", 1);
try testing.expectEqualStrings("/home/example/.local/state/pardes", socketDir(&dir).?);
- _ = unsetenv("HOME");
+ _ = @import("host_io.zig").testUnsetenv("HOME");
try testing.expect(socketDir(&dir) == null);
const listener = try testing.allocator.create(Listener);
@@ -2104,25 +2125,25 @@ test "9P shell environment states being inside pardes apart from how to reach it
// parent, so a pardes started in one of its shells runs a session of
// its own instead of handing its argument over.
exportPaneEnv(listener, 7, false);
- try testing.expectEqualStrings(path, std.mem.span(libc.getenv("PARDES_9P").?));
- try testing.expectEqualStrings("7", std.mem.span(libc.getenv("PARDES_PANE").?));
- try testing.expect(libc.getenv("PARDES_PID") == null);
+ try testing.expectEqualStrings(path, @import("host_io.zig").ChildEnv.exported("PARDES_9P").?);
+ try testing.expectEqualStrings("7", @import("host_io.zig").ChildEnv.exported("PARDES_PANE").?);
+ try testing.expect(@import("host_io.zig").ChildEnv.exported("PARDES_PID") == null);
exportPaneEnv(listener, 8, true);
- try testing.expectEqualStrings("8", std.mem.span(libc.getenv("PARDES_PANE").?));
- try testing.expectEqualStrings(own_pid, std.mem.span(libc.getenv("PARDES_PID").?));
+ try testing.expectEqualStrings("8", @import("host_io.zig").ChildEnv.exported("PARDES_PANE").?);
+ try testing.expectEqualStrings(own_pid, @import("host_io.zig").ChildEnv.exported("PARDES_PID").?);
// A session whose listener never came up is still the session this shell
// is inside: the pid stands on its own, and only the address is missing.
exportPaneEnv(null, 0, true);
- try testing.expect(libc.getenv("PARDES_9P") == null);
- try testing.expect(libc.getenv("PARDES_PANE") == null);
- try testing.expectEqualStrings(own_pid, std.mem.span(libc.getenv("PARDES_PID").?));
+ try testing.expect(@import("host_io.zig").ChildEnv.exported("PARDES_9P") == null);
+ try testing.expect(@import("host_io.zig").ChildEnv.exported("PARDES_PANE") == null);
+ try testing.expectEqualStrings(own_pid, @import("host_io.zig").ChildEnv.exported("PARDES_PID").?);
exportPaneEnv(null, 0, false);
- try testing.expect(libc.getenv("PARDES_9P") == null);
- try testing.expect(libc.getenv("PARDES_PANE") == null);
- try testing.expect(libc.getenv("PARDES_PID") == null);
+ try testing.expect(@import("host_io.zig").ChildEnv.exported("PARDES_9P") == null);
+ try testing.expect(@import("host_io.zig").ChildEnv.exported("PARDES_PANE") == null);
+ try testing.expect(@import("host_io.zig").ChildEnv.exported("PARDES_PID") == null);
}
pub const Client = struct {
diff --git a/src/File.zig b/src/File.zig
index 59b04e3f..7e05ac9f 100644
--- a/src/File.zig
+++ b/src/File.zig
@@ -43,14 +43,14 @@ pub const Snapshot = struct {
saved_len: ?usize = null,
fn deinit(s: Snapshot, gpa: std.mem.Allocator) void {
- gpa.free(s.content);
+ pardes.memory.freeUnfilled(gpa, s.content);
}
};
/// The pane's text, place and name now, for an undo or redo step.
fn snapshotOf(gpa: std.mem.Allocator, pane: *const Pane, f: *const State) ?Snapshot {
return .{
- .content = gpa.dupe(u8, f.content) catch return null,
+ .content = pardes.memory.dupeUnfilled(gpa, f.content) catch return null,
.cur_row = pane.body.cur_row,
.cur_col = pane.body.cur_col,
.vsel = pane.body.vsel,
@@ -105,6 +105,8 @@ pub const History = struct {
undo_len: usize = 0,
redo: [limits.undo_max]Snapshot = undefined,
redo_len: usize = 0,
+ /// The text `undo` and `redo` hold, kept near limits.undo_bytes.
+ bytes: usize = 0,
/// The names the file had, each with the rename generation it ended
/// (Snapshot.gen), and the generation now.
@@ -115,6 +117,7 @@ pub const History = struct {
const history = try gpa.create(History);
history.undo_len = 0;
history.redo_len = 0;
+ history.bytes = 0;
history.names = .empty;
history.gen = 0;
return history;
@@ -165,6 +168,9 @@ pub const State = struct {
/// edit drops them (setContentSpan); shifting them through the splice,
/// as pane.zig's shiftOne moves dot, would keep them.
pager_spans: []pardes.pager.Span = &.{},
+ /// The rows and spans an edit dropped, with the text they were for: an
+ /// edit (an undo) back to that very text takes them again.
+ dropped_marks: ?DroppedMarks = null,
/// Seconds of the last content change, for the filesystem's stat; zero until edited.
mtime: u32 = 0,
/// Non-null for a generated output buffer rather than an on-disk file.
@@ -457,10 +463,6 @@ test "an invalid byte in a grapheme is one cell, and never reaches vaxis's width
try std.testing.expectEqual(@as(usize, 4), fitEnd(text, 0, 10));
}
-pub fn byteDisplayWidth(byte: u8) usize {
- return if (byte == '\t') config.tab_now else 1;
-}
-
pub fn displayWidth(text: []const u8) usize {
var width: usize = 0;
var at: usize = 0;
@@ -787,18 +789,9 @@ pub fn lineIndex(gpa: std.mem.Allocator, f: *State) ![]const usize {
pub const Span = struct { head: usize, tail: usize };
fn editedLineStarts(gpa: std.mem.Allocator, starts: []const usize, old: []const u8, new: []const u8, known: ?Span) ![]usize {
- const n = @min(old.len, new.len);
- var head: usize = 0;
- var tail: usize = 0;
- if (known) |span| {
- head = span.head;
- tail = span.tail;
- } else {
- while (head + 64 <= n and std.mem.eql(u8, old[head..][0..64], new[head..][0..64])) head += 64;
- while (head < n and old[head] == new[head]) head += 1;
- while (tail + 64 <= n - head and std.mem.eql(u8, old[old.len - tail - 64 ..][0..64], new[new.len - tail - 64 ..][0..64])) tail += 64;
- while (tail < n - head and old[old.len - tail - 1] == new[new.len - tail - 1]) tail += 1;
- }
+ const span = known orelse spanOf(old, new);
+ const head = span.head;
+ const tail = span.tail;
// A start s follows the newline at s-1: kept while that newline is in
// the common head, shifted while it is in the common tail.
const kept = std.sort.upperBound(usize, starts, head, struct {
@@ -1123,6 +1116,7 @@ pub fn deinit(p: *Pardes, pane: *Pane, file: *State) void {
if (file.highlights.len > 0) p.tree_sitter_gpa.free(file.highlights);
p.gpa.free(file.pager_spans);
locations.freeRows(p.gpa, file.location_rows);
+ if (file.dropped_marks) |m| m.deinit(p.gpa);
if (file.context_declarations.len > 0) p.tree_sitter_gpa.free(file.context_declarations);
if (file.node_tree) |tree| syntax.freeTree(tree);
for (file.node_history.items) |step| p.gpa.free(step.ranges);
@@ -1140,6 +1134,18 @@ fn reportEdit(p: *Pardes, f: *State, new: []const u8) void {
pardes.ctlfs.events.noteReplace(p, id, false, f.content, new);
}
+pub const DroppedMarks = struct {
+ len: usize,
+ hash: u64,
+ rows: []locations.Row,
+ spans: []pardes.pager.Span,
+
+ fn deinit(m: DroppedMarks, gpa: std.mem.Allocator) void {
+ locations.freeRows(gpa, m.rows);
+ gpa.free(m.spans);
+ }
+};
+
pub fn setContent(p: *Pardes, f: *State, new: []u8) void {
setContentSpan(p, f, new, null);
}
@@ -1160,10 +1166,16 @@ pub fn setContentSpan(p: *Pardes, f: *State, new: []u8, span_in: ?Span) void {
moved[i] = .{ .cursor = spliced(@min(at, f.content.len), f.content.len, new.len, span.?), .scroll = spliced(lineStart(p.gpa, tf, tf.scroll), f.content.len, new.len, span.?) };
}
const old_starts = f.line_starts.ptr;
- locations.freeRows(p.gpa, f.location_rows);
- f.location_rows = &.{};
- p.gpa.free(f.pager_spans);
- f.pager_spans = &.{};
+ if (f.location_rows.len > 0 or f.pager_spans.len > 0) {
+ if (f.dropped_marks) |m| m.deinit(p.gpa);
+ f.dropped_marks = .{ .len = f.content.len, .hash = std.hash.Wyhash.hash(0, f.content), .rows = f.location_rows, .spans = f.pager_spans };
+ f.location_rows = &.{};
+ f.pager_spans = &.{};
+ } else if (f.dropped_marks) |m| if (m.len == new.len and m.hash == std.hash.Wyhash.hash(0, new)) {
+ f.location_rows = m.rows;
+ f.pager_spans = m.spans;
+ f.dropped_marks = null;
+ };
for (p.panes) |slot| if (slot) |pane| {
if (pane.file) |*file| if (file == f) {
for (0..pane.sel.len) |button| {
@@ -1182,7 +1194,9 @@ pub fn setContentSpan(p: *Pardes, f: *State, new: []u8, span_in: ?Span) void {
f.saved_hash = std.hash.Wyhash.hash(0, f.content);
f.saved_len = f.content.len;
}
- p.gpa.free(f.content);
+ // Raw: `free` overwrites a safe build's freed memory, a whole file's
+ // worth per keystroke.
+ if (f.content.len > 0) p.gpa.rawFree(f.content, .of(u8), @returnAddress());
f.content = new;
f.revision +%= 1;
if (f.saved_hash) |h| if ((f.saved_len orelse new.len) == new.len and std.hash.Wyhash.hash(0, new) == h) {
@@ -1241,14 +1255,43 @@ fn spliced(at: usize, old_len: usize, new_len: usize, span: Span) usize {
}
/// What `old` and `new` agree on at either end.
-fn spanOf(old: []const u8, new: []const u8) Span {
+/// What `new` kept of `old` at either end, compared 32 bytes at a time
+/// (a byte at a time was most of a `d` in a 7 MB file).
+pub fn spanOf(old: []const u8, new: []const u8) Span {
+ const block = 32;
const n = @min(old.len, new.len);
- const head = std.mem.indexOfDiff(u8, old[0..n], new[0..n]) orelse n;
+ var head: usize = 0;
+ while (head + block <= n and std.mem.eql(u8, old[head..][0..block], new[head..][0..block])) head += block;
+ while (head < n and old[head] == new[head]) head += 1;
var tail: usize = 0;
+ while (tail + block <= n - head and std.mem.eql(u8, old[old.len - tail - block ..][0..block], new[new.len - tail - block ..][0..block])) tail += block;
while (tail < n - head and old[old.len - 1 - tail] == new[new.len - 1 - tail]) tail += 1;
return .{ .head = head, .tail = tail };
}
+test "spanOf by blocks finds the byte loop's ends" {
+ var prng: std.Random.DefaultPrng = .init(5);
+ const random = prng.random();
+ var a: [160]u8 = undefined;
+ var b: [160]u8 = undefined;
+ for (0..4000) |_| {
+ const la = random.uintLessThan(usize, a.len);
+ const lb = random.uintLessThan(usize, b.len);
+ for (a[0..la]) |*c| c.* = "ab"[random.uintLessThan(usize, 2)];
+ const keep = @min(la, lb);
+ @memcpy(b[0..keep], a[0..keep]);
+ for (b[keep..lb]) |*c| c.* = "ab"[random.uintLessThan(usize, 2)];
+ if (lb > 0 and random.boolean()) b[random.uintLessThan(usize, lb)] ^= 1;
+ const old = a[0..la];
+ const new = b[0..lb];
+ const n = @min(old.len, new.len);
+ const head = std.mem.indexOfDiff(u8, old[0..n], new[0..n]) orelse n;
+ var tail: usize = 0;
+ while (tail < n - head and old[old.len - 1 - tail] == new[new.len - 1 - tail]) tail += 1;
+ try std.testing.expectEqual(Span{ .head = head, .tail = tail }, spanOf(old, new));
+ }
+}
+
fn positionIn(gpa: std.mem.Allocator, f: *State, at: usize) struct { row: usize, col: usize } {
const index = lineIndex(gpa, f) catch {
const c = modal.positionAt(f.content, at);
@@ -1492,14 +1535,18 @@ pub fn restoreSnap(pane: *Pane, f: *State, snap: Snapshot) void {
pane.ensureCursorVisible();
}
-fn pushHistory(gpa: std.mem.Allocator, slots: []Snapshot, len: *usize, snap: Snapshot) void {
- if (len.* == slots.len) {
+/// Bounded in steps and in bytes: the oldest go first, though the one
+/// pushed always stays.
+fn pushHistory(gpa: std.mem.Allocator, history: *History, slots: []Snapshot, len: *usize, snap: Snapshot) void {
+ while (len.* > 0 and (len.* == slots.len or history.bytes + snap.content.len > limits.undo_bytes)) {
+ history.bytes -= slots[0].content.len;
slots[0].deinit(gpa);
- std.mem.copyForwards(Snapshot, slots[0 .. slots.len - 1], slots[1..]);
+ std.mem.copyForwards(Snapshot, slots[0 .. len.* - 1], slots[1..len.*]);
len.* -= 1;
}
slots[len.*] = snap;
len.* += 1;
+ history.bytes += snap.content.len;
}
pub fn pushUndo(p: *Pardes, pane: *Pane) void {
@@ -1510,9 +1557,12 @@ pub fn pushUndo(p: *Pardes, pane: *Pane) void {
if (std.mem.eql(u8, last.content, f.content) and last.gen == history.gen) return;
}
const snap = snapshotOf(p.gpa, pane, f) orelse return;
- pushHistory(p.gpa, &history.undo, &history.undo_len, snap);
- for (history.redo[0..history.redo_len]) |item| item.deinit(p.gpa);
+ for (history.redo[0..history.redo_len]) |item| {
+ history.bytes -= item.content.len;
+ item.deinit(p.gpa);
+ }
history.redo_len = 0;
+ pushHistory(p.gpa, history, &history.undo, &history.undo_len, snap);
}
pub fn undo(p: *Pardes, pane: *Pane) void {
@@ -1520,9 +1570,10 @@ pub fn undo(p: *Pardes, pane: *Pane) void {
const history = f.history;
if (history.undo_len == 0) return;
const current = snapshotOf(p.gpa, pane, f) orelse return;
- pushHistory(p.gpa, &history.redo, &history.redo_len, current);
+ pushHistory(p.gpa, history, &history.redo, &history.redo_len, current);
history.undo_len -= 1;
const previous = history.undo[history.undo_len];
+ history.bytes -= previous.content.len; // the file's text now
setContent(p, f, previous.content);
restoreName(p, pane, f, previous);
restoreSnap(pane, f, previous);
@@ -1533,9 +1584,10 @@ pub fn redo(p: *Pardes, pane: *Pane) void {
const history = f.history;
if (history.redo_len == 0) return;
const current = snapshotOf(p.gpa, pane, f) orelse return;
- pushHistory(p.gpa, &history.undo, &history.undo_len, current);
+ pushHistory(p.gpa, history, &history.undo, &history.undo_len, current);
history.redo_len -= 1;
const next = history.redo[history.redo_len];
+ history.bytes -= next.content.len; // the file's text now
setContent(p, f, next.content);
restoreName(p, pane, f, next);
restoreSnap(pane, f, next);
@@ -2266,3 +2318,28 @@ pub fn paintWordSelection(
}
}
}
+
+test "undo keeps its steps within a byte bound, the newest always" {
+ const gpa = std.testing.allocator;
+ const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 80, .rows = 24 });
+ defer p.deinit();
+ const pane = try p.setTestFile("");
+ const f = &pane.file.?;
+ const step = limits.undo_bytes / 4 + 1;
+ const text = try gpa.alloc(u8, step);
+ defer gpa.free(text);
+ for (0..8) |i| {
+ @memset(text, 'a' + @as(u8, @intCast(i)));
+ pushUndo(p, pane);
+ setContent(p, f, try gpa.dupe(u8, text));
+ }
+ pushUndo(p, pane);
+ const history = f.history;
+ try std.testing.expect(history.undo_len > 0 and history.undo_len < 8);
+ try std.testing.expect(history.bytes <= limits.undo_bytes + step);
+ var sum: usize = 0;
+ for (history.undo[0..history.undo_len]) |snap| sum += snap.content.len;
+ try std.testing.expectEqual(sum, history.bytes);
+ undo(p, pane);
+ try std.testing.expectEqualStrings(text[0..1], f.content[0..1]);
+}
diff --git a/src/Registers.zig b/src/Registers.zig
index 3f2486cd..5e23da5b 100644
--- a/src/Registers.zig
+++ b/src/Registers.zig
@@ -81,6 +81,7 @@ pub fn text(r: *Registers, gpa: std.mem.Allocator, name: u21) ?[]const u8 {
const reg = r.get(name) orelse return null;
if (reg.joined) |j| return j;
var out: std.ArrayList(u8) = .empty;
+ defer out.deinit(gpa); // what a failed append left; empty once owned
for (reg.values, 0..) |v, i| {
if (i > 0 and !std.mem.endsWith(u8, reg.values[i - 1], "\n")) out.append(gpa, '\n') catch return null;
out.appendSlice(gpa, v) catch return null;
@@ -105,3 +106,15 @@ test "a register holds a value per range and joins them for one-text readers" {
try std.testing.expectEqualStrings("x", r.text(gpa, 'a').?);
try std.testing.expectEqualStrings("one\ntwo", r.text(gpa, default).?);
}
+
+test "joining a register that runs out of memory partway leaks nothing" {
+ var r: Registers = .{};
+ defer r.deinit(std.testing.allocator);
+ r.put(std.testing.allocator, default, "one", 0, 2, true);
+ r.put(std.testing.allocator, default, "two", 1, 2, false);
+ r.put(std.testing.allocator, default, &(@as([4096]u8, @splat('x'))), 1, 2, false);
+ // The first append allocates; growing for the 4096 bytes fails.
+ var failing = std.testing.FailingAllocator.init(std.testing.allocator, .{ .fail_index = 1, .resize_fail_index = 0 });
+ try std.testing.expect(r.text(failing.allocator(), default) == null);
+ try std.testing.expectEqual(failing.allocated_bytes, failing.freed_bytes);
+}
diff --git a/src/ShaderBuild.zig b/src/ShaderBuild.zig
index b50999a5..e5b6680b 100644
--- a/src/ShaderBuild.zig
+++ b/src/ShaderBuild.zig
@@ -76,7 +76,8 @@ const Result = union(enum) {
spirv: struct { bytes: []u8, source: u64, animated: bool },
};
-/// One compile of the stale files, on its own thread.
+/// One compile of the stale files, a task of its own: `deinit` cancels it
+/// (glslc's wait is a cancelation point) rather than waiting out a glslc.
const Job = struct {
io: std.Io,
gpa: std.mem.Allocator,
@@ -86,7 +87,10 @@ const Job = struct {
results: [max]Result = @splat(.none),
len: usize = 0,
done: std.atomic.Value(bool) = .init(false),
- thread: std.Thread = undefined,
+ /// Set before the cancel: the files after the one it stopped are not
+ /// compiled either (a cancel is said once, to the wait it lands in).
+ stop: std.atomic.Value(bool) = .init(false),
+ future: std.Io.Future(void) = undefined,
};
files: [max]File = @splat(.{}),
@@ -105,7 +109,7 @@ pub fn sync(b: *Build, gpa: std.mem.Allocator, io: std.Io, core: *pardes.Pardes,
var collected = false;
if (b.job) |job| {
if (!job.done.load(.acquire)) return false;
- job.thread.join();
+ job.future.await(job.io);
b.job = null;
b.collect(gpa, core, job);
collected = true;
@@ -148,7 +152,7 @@ pub fn sync(b: *Build, gpa: std.mem.Allocator, io: std.Io, core: *pardes.Pardes,
job.len += 1;
file.stale = false;
}
- job.thread = std.Thread.spawn(.{}, compile, .{job}) catch {
+ job.future = io.concurrent(compile, .{job}) catch {
for (job.paths[0..job.len]) |path| gpa.free(path);
gpa.destroy(job);
return collected;
@@ -174,7 +178,8 @@ pub fn view(b: *const Build, chain: *const Chain, out: *[max]Pass) []const Pass
pub fn deinit(b: *Build, gpa: std.mem.Allocator, fd: c_int, watches: *file_watch.Table) void {
if (b.job) |job| {
- job.thread.join();
+ job.stop.store(true, .release);
+ job.future.cancel(job.io);
freeJob(gpa, job);
}
for (b.files[0..b.len]) |file| free(gpa, file);
@@ -245,7 +250,10 @@ fn expand(buf: *[4096]u8, path: []const u8) []const u8 {
/// build's own flags (build.zig compileGlsl), source on stdin, SPIR-V on
/// stdout.
fn compile(job: *Job) void {
- for (job.paths[0..job.len], 0..) |path, i| job.results[i] = compileOne(job.gpa, job.io, path, job.known[i]);
+ for (job.paths[0..job.len], 0..) |path, i| {
+ if (job.stop.load(.acquire)) break;
+ job.results[i] = compileOne(job.gpa, job.io, path, job.known[i]);
+ }
job.done.store(true, .release);
if (job.wake.call) |call| call(job.wake.ctx);
}
@@ -378,7 +386,8 @@ test "a save that changes a file compiles it again, a failed one keeps the last
fn run(build: *Build, c: *pardes.Pardes, f: c_int, w: *file_watch.Table) void {
_ = build.sync(std.testing.allocator, std.testing.io, c, f, w, .{});
while (build.job) |job| {
- while (!job.done.load(.acquire)) std.Thread.yield() catch {};
+ job.future.await(std.testing.io);
+ job.done.store(true, .release);
_ = build.sync(std.testing.allocator, std.testing.io, c, f, w, .{});
}
}
diff --git a/src/builtins.zig b/src/builtins.zig
index cc7d1d4a..fdce534b 100644
--- a/src/builtins.zig
+++ b/src/builtins.zig
@@ -1971,6 +1971,9 @@ pub const WsDiagnostics = struct {
/// Show outermost callers first, with signatures and call sites (gc).
pub const Callstack = struct {
pub fn run(c: Ctx) void {
+ // In +Callstack itself: the next page of what it shows.
+ if (c.pane.file) |f| if (f.output) |o| if (std.meta.eql(o.from, panes.Output.Origin{ .query = .callstack }))
+ return c.p.callstackMore(c.id);
c.p.lspRequest(c.id, .callstack, "");
}
};
diff --git a/src/colors.zig b/src/colors.zig
index dd0d8938..28136975 100644
--- a/src/colors.zig
+++ b/src/colors.zig
@@ -840,7 +840,7 @@ pub fn loadThemeFile(p: *Pardes, generation: u32, bytes: []const u8, animate: bo
@memcpy(settled[0..request.path.len], request.path);
_ = p.theme_file_loaded.set(settled[0..request.path.len]);
invalidateThemeDependentRasters(p);
- _ = p.scratch.reset(.retain_capacity);
+ _ = p.scratch.reset(.{ .retain_with_limit = pardes.memory.limits.scratch_kept });
p.sync();
return true;
}
diff --git a/src/config.zig b/src/config.zig
index a92aabb6..5251b1e5 100644
--- a/src/config.zig
+++ b/src/config.zig
@@ -1230,27 +1230,12 @@ pub const Runtime = struct {
if (!state.shell.requested.set(value)) return false;
state.shell.pending = true;
},
- .tagline_size => {
- const text = std.mem.trim(u8, argument orelse return false, " \t\r\n");
- const percent = std.fmt.parseInt(u16, text, 10) catch return false;
- if (percent < tagline_percent_min or percent > tagline_percent_max) return false;
- state.font.tagline_percent = @intCast(percent);
- },
+ .tagline_size => state.font.tagline_percent = @intCast(number(u16, argument, " \t\r\n", tagline_percent_min, tagline_percent_max) orelse return false),
.window_opacity => {
- const text = std.mem.trim(u8, argument orelse return false, " \t\r\n");
- for (text) |byte| if (!std.ascii.isDigit(byte)) return false;
- const percent = std.fmt.parseInt(u8, text, 10) catch return false;
- if (percent > 100) return false;
- state.window_opacity = percent;
+ state.window_opacity = number(u8, argument, " \t\r\n", 0, 100) orelse return false;
state.window_opacity_pending = true;
},
- .window_blur => {
- const text = std.mem.trim(u8, argument orelse return false, " \t\r\n");
- for (text) |byte| if (!std.ascii.isDigit(byte)) return false;
- const percent = std.fmt.parseInt(u8, text, 10) catch return false;
- if (percent > 100) return false;
- state.window_blur = percent;
- },
+ .window_blur => state.window_blur = number(u8, argument, " \t\r\n", 0, 100) orelse return false,
// Bare, it returns to the default directory. Else an absolute or
// `~` path, to a directory there or to be made, that may be
// written: a Dump there could never be, refused now.
@@ -1264,10 +1249,7 @@ pub const Runtime = struct {
if (!state.dump_dir.set(text)) return false;
},
.message_ms => |which| {
- const text = std.mem.trim(u8, argument orelse return false, " \t\r\n");
- for (text) |byte| if (!std.ascii.isDigit(byte)) return false;
- const ms = std.fmt.parseInt(u16, text, 10) catch return false;
- if (ms > message_ms_max) return false;
+ const ms = number(u16, argument, " \t\r\n", 0, message_ms_max) orelse return false;
switch (which) {
inline else => |w| @field(state, "message_" ++ @tagName(w) ++ "_ms") = ms,
}
@@ -1330,30 +1312,10 @@ pub const Runtime = struct {
std.meta.stringToEnum(LiftStyle, text) orelse return false;
},
.motion => state.motion = stepped(animation.Motion.Flavour, state.motion, argument) orelse return false,
- .inactive_dim => {
- const text = std.mem.trim(u8, argument orelse return false, " \t\r\n%");
- const percent = std.fmt.parseInt(u8, text, 10) catch return false;
- if (percent > 100) return false;
- state.inactive_dim = percent;
- },
- .grip_width => {
- const text = std.mem.trim(u8, argument orelse return false, " \t\r\n%");
- const percent = std.fmt.parseInt(u16, text, 10) catch return false;
- if (percent < 50 or percent > 300) return false;
- state.grip_width = percent;
- },
- .callstack_depth => {
- const text = std.mem.trim(u8, argument orelse return false, " \t\r\n");
- const depth = std.fmt.parseInt(u8, text, 10) catch return false;
- if (depth < 1 or depth > @import("lsp/lsp.zig").callstack_max_depth) return false;
- state.callstack_depth = depth;
- },
- .tab => {
- const text = std.mem.trim(u8, argument orelse return false, " \t\r\n");
- const width = std.fmt.parseInt(u16, text, 10) catch return false;
- if (width < 1 or width > 16) return false;
- state.tab = width;
- },
+ .inactive_dim => state.inactive_dim = number(u8, argument, " \t\r\n%", 0, 100) orelse return false,
+ .grip_width => state.grip_width = number(u16, argument, " \t\r\n%", 50, 300) orelse return false,
+ .callstack_depth => state.callstack_depth = number(u8, argument, " \t\r\n", 1, @import("lsp/lsp.zig").callstack_max_depth) orelse return false,
+ .tab => state.tab = number(u16, argument, " \t\r\n", 1, 16) orelse return false,
.theme, .font => return false,
}
return true;
@@ -1411,6 +1373,16 @@ pub const Runtime = struct {
return all[(at + 1) % all.len];
}
+ /// A setting's number: digits only (parseInt alone takes a sign and `_`),
+ /// trimmed of `trim`, within lo..hi.
+ fn number(comptime T: type, argument: ?[]const u8, trim: []const u8, lo: T, hi: T) ?T {
+ const text = std.mem.trim(u8, argument orelse return null, trim);
+ if (text.len == 0) return null;
+ for (text) |byte| if (!std.ascii.isDigit(byte)) return null;
+ const n = std.fmt.parseInt(T, text, 10) catch return null;
+ return if (n < lo or n > hi) null else n;
+ }
+
/// What `on`, `off` or nothing after a switch word asks for: null flips
/// it, as a bare tagline word does.
fn switchedTo(argument: ?[]const u8) error{NotOnOrOff}!?bool {
@@ -2523,7 +2495,7 @@ test "CallstackDepth is bounded and keeps the last valid runtime limit" {
try std.testing.expect(Runtime.apply(&state, Runtime.find("CallstackDepth").?, value));
try std.testing.expectEqual(try std.fmt.parseInt(u8, value, 10), state.callstack_depth);
}
- for ([_][]const u8{ "0", "65", "256", "-1", "eight", "" }) |value| {
+ for ([_][]const u8{ "0", "65", "256", "-1", "+8", "1_6", "eight", "" }) |value| {
try std.testing.expect(!Runtime.apply(&state, Runtime.find("CallstackDepth").?, value));
try std.testing.expectEqual(@as(u8, 64), state.callstack_depth);
}
diff --git a/src/crash.zig b/src/crash.zig
index 34dc1b3d..a432fb87 100644
--- a/src/crash.zig
+++ b/src/crash.zig
@@ -34,6 +34,9 @@ pub const name = "crashes";
/// A panic handler is the one caller that cannot check whether its input is
/// still alive, so it does not borrow.
var dir_buf: [1024]u8 = undefined;
+
+/// The crash file's bound (see `record`).
+const max_log_bytes = 256 * 1024;
var dir_len: usize = 0;
/// Called where the launcher sets `Options.config_dir`. Ignores a path too long
@@ -109,6 +112,9 @@ pub fn record(msg: []const u8) void {
}, @as(std.c.mode_t, 0o600));
if (fd < 0) return;
defer _ = std.c.close(fd);
+ // Bounded: a file past `max_log_bytes` starts over, so it keeps the
+ // newest records rather than every crash since it was first made.
+ if (std.c.lseek(fd, 0, std.c.SEEK.END) > max_log_bytes) _ = std.c.ftruncate(fd, 0);
var w: std.Io.Writer = .fixed(&scratch);
diff --git a/src/detached/server.zig b/src/detached/server.zig
index d6a1f553..6c8d4352 100644
--- a/src/detached/server.zig
+++ b/src/detached/server.zig
@@ -107,17 +107,19 @@ const Mailbox = struct {
status: ?[]u8 = null,
};
- mutex: std.atomic.Mutex = .unlocked,
+ /// Taken by the workers and the loop; `io` is the session's (initAsync).
+ mutex: std.Io.Mutex = .init,
+ io: std.Io = undefined,
batch: Batch = .{},
wake: [2]c_int = .{ -1, -1 },
fn post(box: *Mailbox, completion: Completion) void {
- while (!box.mutex.tryLock()) std.atomic.spinLoopHint();
+ box.mutex.lockUncancelable(box.io);
// Tasks retain their slot until the owner consumes their one completion.
std.debug.assert(box.batch.len < capacity);
box.batch.items[box.batch.len] = completion;
box.batch.len += 1;
- box.mutex.unlock();
+ box.mutex.unlock(box.io);
box.signal();
}
@@ -130,8 +132,8 @@ const Mailbox = struct {
fn take(box: *Mailbox) Batch {
var bytes: [128]u8 = undefined;
while (libc.recv(box.wake[0], &bytes, bytes.len, 0) > 0) {}
- while (!box.mutex.tryLock()) std.atomic.spinLoopHint();
- defer box.mutex.unlock();
+ box.mutex.lockUncancelable(box.io);
+ defer box.mutex.unlock(box.io);
const batch = box.batch;
box.batch.len = 0;
box.batch.status = null;
@@ -184,6 +186,7 @@ pub const Session = struct {
accept_paused_ms: i64 = 0,
pub fn initAsync(s: *Session) !void {
+ s.mailbox.io = s.io;
var pair: [2]c_int = undefined;
if (libc.socketpair(libc.AF.UNIX, libc.SOCK.STREAM, 0, &pair) != 0) return error.SocketFailed;
errdefer for (pair) |fd| {
@@ -410,7 +413,7 @@ pub const Session = struct {
s.core.update(.{ .lsp_resp = .{ .id = request.id, .rows = null } });
return s.core.reportError(request.pane, "lsp", err);
};
- const future = s.io.concurrent(lspWorker, .{ s.worker_gpa, job, &s.mailbox }) catch |err| {
+ const future = s.io.concurrent(lspWorker, .{ s.io, s.worker_gpa, job, &s.mailbox }) catch |err| {
job.free(s.worker_gpa);
s.core.update(.{ .lsp_resp = .{ .id = request.id, .rows = null } });
return s.core.reportError(request.pane, "lsp", err);
@@ -418,8 +421,8 @@ pub const Session = struct {
s.lsp_task = .{ .id = request.id, .future = future };
}
- fn lspWorker(gpa: std.mem.Allocator, job: *host_io.Lsp.Job, box: *Mailbox) anyerror!void {
- host_io.Lsp.work(gpa, job, box, deliverLspRows);
+ fn lspWorker(io: std.Io, gpa: std.mem.Allocator, job: *host_io.Lsp.Job, box: *Mailbox) anyerror!void {
+ host_io.Lsp.work(io, gpa, job, box, deliverLspRows);
}
fn deliverLspRows(ctx: ?*anyopaque, id: u32, rows: ?[]u8) void {
@@ -430,10 +433,10 @@ pub const Session = struct {
fn lspStatus(ctx: ?*anyopaque, text: []const u8) void {
const s = of(ctx);
const copy = s.worker_gpa.dupe(u8, text) catch return;
- while (!s.mailbox.mutex.tryLock()) std.atomic.spinLoopHint();
+ s.mailbox.mutex.lockUncancelable(s.io);
if (s.mailbox.batch.status) |old| s.worker_gpa.free(old);
s.mailbox.batch.status = copy;
- s.mailbox.mutex.unlock();
+ s.mailbox.mutex.unlock(s.io);
s.mailbox.signal();
}
@@ -529,7 +532,8 @@ pub const Session = struct {
if (pane >= s.ptys.len) return;
const pt = &s.ptys[pane];
if (pt.fd < 0) return;
- if (pt.out.items.len > pty_backlog) {
+ // The bound holds with this write in: queued and new together.
+ if (pt.out.items.len + bytes.len > pty_backlog) {
var mbuf: [256]u8 = undefined;
const text = std.fmt.bufPrint(
&mbuf,
@@ -1145,6 +1149,9 @@ pub const Session = struct {
s.queue(c, bytes);
}
+ /// A client's queued output is at most `out_backlog + wire.max_payload`:
+ /// past the backlog it is closed, and one frame lands on top of it first
+ /// (a frame bigger than the backlog must still go out whole).
fn queue(s: *Session, c: *Client, bytes: []const u8) void {
if (c.out.items.len > out_backlog) return s.close(c, .backlog);
s.account();
diff --git a/src/dump.zig b/src/dump.zig
index 76a6de85..67934e0a 100644
--- a/src/dump.zig
+++ b/src/dump.zig
@@ -394,17 +394,6 @@ test "oversized recognized output argument is rejected before restore" {
);
}
-pub fn writeFile(io: std.Io, gpa: std.mem.Allocator, path: []const u8, state: State) !void {
- try validate(state);
- var out: std.Io.Writer.Allocating = .init(gpa);
- defer out.deinit();
- try std.zon.stringify.serialize(state, .{ .whitespace = true }, &out.writer);
-
- var file = try std.Io.Dir.createFileAbsolute(io, path, .{});
- defer file.close(io);
- try file.writeStreamingAll(io, out.written());
-}
-
pub const Parsed = struct {
value: State,
arena: std.heap.ArenaAllocator,
diff --git a/src/edit.zig b/src/edit.zig
index 466b5cdb..55365692 100644
--- a/src/edit.zig
+++ b/src/edit.zig
@@ -119,7 +119,15 @@ pub fn typeToTty(p: *Pardes, id: usize, pane: *const Pane, text: []const u8) voi
for (panes.terminal.encodePaste(pane, cp)) |part| if (part.len > 0) p.emitWrite(id, part);
}
-pub fn applyPaste(p: *Pardes, bytes: []const u8) void {
+pub fn applyPaste(p: *Pardes, whole: []const u8) void {
+ // Every shell's paste comes through here, bounded: what is past the
+ // limit is left out, at a character's start, and said.
+ const limit = @import("memory.zig").limits.max_paste_bytes;
+ const bytes = if (whole.len > limit) whole[0..modal.graphemeStart(whole, limit)] else whole;
+ if (whole.len > limit) {
+ var said: [96]u8 = undefined;
+ p.setMessage(p.active, std.fmt.bufPrint(&said, "paste cut at its limit, {d} KiB: the rest left out", .{limit / 1024}) catch "paste cut at its limit");
+ }
// A prompt answering for a header takes the paste, as it takes keys.
const asking = if (p.panes[p.active]) |active| active.prompt != .none else false;
if (!asking) if (tagline.focusedHeader(p)) |t| {
@@ -466,8 +474,10 @@ fn editText(p: *Pardes, t: *Text, lo: i32, hi: i32, col: i32) ?panes.EditText {
fn editTextEol(p: *Pardes, t: *Text, b: Bounds) ?panes.EditText {
const eb = editText(p, t, b.lo_row, b.hi_row, -1) orelse return null;
const r: usize = @intCast(@max(0, b.hi_row - eb.row0));
- if (r + 1 < modal.lineCount(eb.text)) return eb;
- if (b.hi_col < @as(i32, @intCast(modal.lineSlice(eb.text, r).len))) return eb;
+ // A file's own line count and line, from its index.
+ const lines = if (indexedLine(p, t, eb.text, 0) != null) panes.File.nlines(p.gpa, &t.pane().?.file.?) else modal.lineCount(eb.text);
+ if (r + 1 < lines) return eb;
+ if (b.hi_col < @as(i32, @intCast(lineAt(p, t, eb.text, r).line.len))) return eb;
return editText(p, t, b.lo_row, b.hi_row + 1, -1);
}
@@ -476,6 +486,47 @@ pub fn setEditText(p: *Pardes, t: *Text, new: []u8) void {
setEditTextEnd(p, t, new, null);
}
+const LineAt = struct { start: usize, line: []const u8 };
+
+/// `text`'s line count: the file's index when `text` is the pane's file.
+fn lineCountOf(p: *Pardes, t: *Text, text: []const u8) usize {
+ if (indexedLine(p, t, text, 0) != null) return panes.File.nlines(p.gpa, &t.pane().?.file.?);
+ return modal.cursorLineCount(text);
+}
+
+/// The row offset `off` is on: a search of the file's index when `text` is
+/// the pane's file, else the newlines before it counted (modal.lineAtOffset).
+fn rowOf(p: *Pardes, t: *Text, text: []const u8, off: usize) usize {
+ if (indexedLine(p, t, text, 0) != null) {
+ const index = panes.File.lineIndex(p.gpa, &t.pane().?.file.?) catch return modal.lineAtOffset(text, off);
+ return std.sort.upperBound(usize, index, @min(off, text.len), struct {
+ fn order(key: usize, item: usize) std.math.Order {
+ return std.math.order(key, item);
+ }
+ }.order) -| 1;
+ }
+ return modal.lineAtOffset(text, off);
+}
+
+/// Line `row` of `text` and where it starts: through the file's line index
+/// when `text` is the pane's file (a lookup), else counted from the top.
+/// Finding line 94000 by counting was most of a keystroke in a 7 MB file.
+fn lineAt(p: *Pardes, t: *Text, text: []const u8, row: usize) LineAt {
+ return indexedLine(p, t, text, row) orelse .{ .start = modal.lineStartOffset(text, row), .line = modal.lineSlice(text, row) };
+}
+
+/// lineAt's lookup, null when `text` is not the pane's file or `row` is past its last line.
+fn indexedLine(p: *Pardes, t: *Text, text: []const u8, row: usize) ?LineAt {
+ if (t.what != .body) return null;
+ const pane = t.pane() orelse return null;
+ const f = if (pane.file) |*f| f else return null;
+ if (f.content.ptr != text.ptr or f.content.len != text.len) return null;
+ if (row >= panes.File.nlines(p.gpa, f)) return null;
+ const start = @min(panes.File.lineStart(p.gpa, f, row), text.len);
+ const end = std.mem.indexOfScalarPos(u8, text, start, '\n') orelse text.len;
+ return .{ .start = start, .line = text[start..end] };
+}
+
/// Where text `s` put in at `c` ends: `g.`'s place after typing it.
fn insertedEnd(c: modal.Cursor, s: []const u8) modal.Cursor {
const nl = std.mem.lastIndexOfScalar(u8, s, '\n') orelse return .{ .row = c.row, .col = c.col + s.len };
@@ -486,6 +537,13 @@ fn insertedEnd(c: modal.Cursor, s: []const u8) modal.Cursor {
/// rows) when the caller knows it, as typing does: then nothing scans the
/// whole text to find it. Null, it is found by comparing the texts.
pub fn setEditTextEnd(p: *Pardes, t: *Text, new: []u8, known_end: ?modal.Cursor) void {
+ setEditTextSpan(p, t, new, known_end, null);
+}
+
+/// `setEditTextEnd` with what a file's splice left alone at either end, when
+/// the caller knows it (typing): the line index is then not found again by
+/// comparing the whole old and new texts, which a keystroke in a 7 MB file did.
+fn setEditTextSpan(p: *Pardes, t: *Text, new: []u8, known_end: ?modal.Cursor, span: ?panes.File.Span) void {
if (t.what == .tag) {
// A tag is edited as it is shown, but only what follows its
// prefix is its own: an edit that changed the prefix is refused.
@@ -511,16 +569,13 @@ pub fn setEditTextEnd(p: *Pardes, t: *Text, new: []u8, known_end: ?modal.Cursor)
const pane = t.pane() orelse return retireEditText(p, new);
// what changed ended where the texts agree again from their ends
const old: []const u8, const row0: i32 = if (pane.file) |f| .{ f.content, 0 } else if (pane.ovl) |o| .{ o.text, o.row } else .{ "", 0 };
- const end = known_end orelse found: {
- // ponytail: O(file), for the edits that do not say where they ended
- // (paste, a pipe, s): typing passes its end and never comes here.
- const front = std.mem.indexOfDiff(u8, old, new) orelse @min(old.len, new.len);
- var back: usize = 0;
- while (back < @min(old.len, new.len) - front and old[old.len - 1 - back] == new[new.len - 1 - back]) back += 1;
- break :found modal.positionAt(new, new.len - back);
- };
+ // ponytail: O(file), for the edits that do not say what they changed
+ // (paste, a pipe, d, s): compared once, block by block, here; the same
+ // span then spares the line index a second comparison.
+ const found = span orelse if (known_end == null or pane.file != null) panes.File.spanOf(old, new) else null;
+ const end = known_end orelse modal.positionAt(new, new.len - found.?.tail);
t.last_edit = .{ .row = @as(i32, @intCast(end.row)) + row0, .col = @intCast(end.col) };
- if (pane.file) |*f| return panes.File.setContent(p, f, new);
+ if (pane.file) |*f| return panes.File.setContentSpan(p, f, new, found);
panes.terminal.setEditText(p, pane, new);
}
@@ -815,8 +870,10 @@ fn insertEdit(p: *Pardes, t: *Text, key: Key) void {
const text = eb.text;
const c = modal.Cursor{ .row = @intCast(@max(0, t.cur_row - eb.row0)), .col = @intCast(@max(0, t.cur_col)) };
if (key.text.len > 0 and !key.ctrl and !key.alt) {
- const new = modal.insertAt(p.gpa, text, c, key.text) catch return;
- setEditTextEnd(p, t, new, insertedEnd(c, key.text));
+ // insertAt's offset (col clamped to the line), the line found once.
+ const at = if (indexedLine(p, t, text, c.row)) |l| l.start + @min(c.col, l.line.len) else modal.insertOffset(text, c);
+ const new = modal.spliceAlloc(p.gpa, text, at, at, key.text) catch return;
+ setEditTextSpan(p, t, new, insertedEnd(c, key.text), .{ .head = at, .tail = text.len - at });
for (key.text) |ch| {
if (ch == '\n') {
t.cur_row += 1;
@@ -918,7 +975,8 @@ fn insertEdit(p: *Pardes, t: *Text, key: Key) void {
},
Key.backspace => {
if (t.cur_col > 0) {
- const line = modal.lineSlice(text, c.row);
+ const found = lineAt(p, t, text, c.row);
+ const line = found.line;
var prev = modal.prevGrapheme(line, c.col);
// in leading blanks, back to the previous indent stop (helix
// dedent): a whole unit when on one, else the part past it
@@ -931,8 +989,12 @@ fn insertEdit(p: *Pardes, t: *Text, key: Key) void {
prev = c.col;
while (drop > 0 and prev > 0 and line[prev - 1] == ' ') : (drop -= 1) prev -= 1;
}
- const new = modal.deleteSpan(p.gpa, text, .{ .row = c.row, .col = prev }, c) catch return;
- setEditTextEnd(p, t, new, .{ .row = c.row, .col = prev });
+ // deleteSpan's splice, the line found once.
+ const s = found.start + @min(prev, line.len);
+ const e = found.start + @min(c.col, line.len);
+ const new = if (e > s) modal.spliceAlloc(p.gpa, text, s, e, "") catch return else p.gpa.dupe(u8, text) catch return;
+ const span: panes.File.Span = if (e > s) .{ .head = s, .tail = text.len - e } else .{ .head = text.len, .tail = 0 };
+ setEditTextSpan(p, t, new, .{ .row = c.row, .col = prev }, span);
t.cur_col = @intCast(prev);
t.cur_pinned = true;
t.show();
@@ -1479,26 +1541,33 @@ pub fn normalJoin(p: *Pardes, t: *Text, select_space: bool) void {
const text = eb.text;
var rs: [Text.max_selections]modal.Selection = undefined;
const got = t.ranges(text, eb.row0, &rs);
- const nlines = modal.cursorLineCount(text);
+ // Lines, their count and rows from the file's index when it has one:
+ // counted from the top, a J in a 7 MB file was 8 ms.
+ const nlines = lineCountOf(p, t, text);
const arena = p.scratch.allocator();
- const chs = arena.alloc(TextChange, nlines) catch return;
- var chs_len: usize = 0;
+ var changes: std.ArrayList(TextChange) = .empty;
var next: usize = 0; // lines below this one are joined already
for (rs[0..got.n]) |r| {
- const span = Text.rangeLineSpan(text, r);
+ // Text.rangeLineSpan, through rowOf
+ const lo = @min(r.anchor, r.head);
+ const hi = @max(r.anchor, r.head);
+ const span = .{ .start = rowOf(p, t, text, lo), .end = rowOf(p, t, text, if (lo == hi) hi else @max(modal.prevGrapheme(text, hi), lo)) };
var end = span.end;
if (span.start == end) end = @min(end + 1, nlines - 1);
var l = @max(span.start, next);
while (l < end) : (l += 1) {
- const from = modal.lineEndOffset(text, l);
- var to = if (l + 1 >= nlines) text.len else modal.lineStartOffset(text, l + 1);
+ const here = lineAt(p, t, text, l);
+ const from = here.start + here.line.len;
+ var to = if (l + 1 >= nlines) text.len else lineAt(p, t, text, l + 1).start;
while (to < text.len and (text[to] == ' ' or text[to] == '\t')) to += 1;
- const sep: []const u8 = if (to == modal.lineEndOffset(text, @min(l + 1, nlines - 1))) "" else " ";
- chs[chs_len] = .{ .from = from, .to = to, .ins = sep };
- chs_len += 1;
+ const last = lineAt(p, t, text, @min(l + 1, nlines - 1));
+ const sep: []const u8 = if (to == last.start + last.line.len) "" else " ";
+ changes.append(arena, .{ .from = from, .to = to, .ins = sep }) catch return;
}
next = @max(next, end);
}
+ const chs = changes.items;
+ const chs_len = chs.len;
if (chs_len == 0) return;
pushUndo(p, t);
const new = applyChanges(p, text, chs[0..chs_len]) catch return;
@@ -2459,3 +2528,72 @@ test "a paste into a terminal is xterm's: bracketed when the program asked, cont
p.update(.{ .paste = "x\x1b[201~y\n" });
try std.testing.expectEqualStrings("\x1b[200~x [201~y\n\x1b[201~", try take(p, &out));
}
+
+test "a paste past the limit is cut at it, and says so" {
+ const gpa = std.testing.allocator;
+ const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 80, .rows = 24 });
+ defer p.deinit();
+ const pane = try p.setTestFile("");
+ pane.body.mode = .insert;
+ const limit = @import("memory.zig").limits.max_paste_bytes;
+ const big = try gpa.alloc(u8, limit + 100);
+ defer gpa.free(big);
+ @memset(big, 'x');
+ applyPaste(p, big);
+ try std.testing.expect(pane.file.?.content.len <= limit);
+ try std.testing.expect(pane.file.?.content.len > 0);
+ try std.testing.expect(std.mem.indexOf(u8, pane.msg[0..pane.msg_len], "paste cut") != null);
+}
+
+test "typing and backspace through the line index keep the text and the index as a rebuild has them" {
+ const gpa = std.testing.allocator;
+ const p = try Pardes.init(gpa, .{ .tty_only = true });
+ defer p.deinit();
+ while (p.nextEffect()) |_| {}
+ const pane = try p.setTestFile("one\n two\n\nthree four\n");
+ pane.body.mode = .insert;
+ var prng: std.Random.DefaultPrng = .init(11);
+ const random = prng.random();
+ for (0..300) |_| {
+ _ = panes.File.lineIndex(gpa, &pane.file.?) catch unreachable;
+ const f = &pane.file.?;
+ const row = random.uintLessThan(usize, panes.File.nlines(gpa, f));
+ const line = modal.lineSlice(f.content, row);
+ pane.body.cur_row = @intCast(row);
+ pane.body.cur_col = @intCast(random.uintLessThan(usize, line.len + 1));
+ pane.body.cur_pinned = true;
+ if (random.boolean()) {
+ insertKey(p, &pane.body, .{ .cp = 'x', .text = "x" });
+ } else {
+ insertKey(p, &pane.body, .{ .cp = Key.backspace });
+ }
+ // the index the edits kept, against one built from the text
+ const kept = try gpa.dupe(usize, try panes.File.lineIndex(gpa, &pane.file.?));
+ defer gpa.free(kept);
+ gpa.free(pane.file.?.line_starts);
+ pane.file.?.line_starts = &.{};
+ try std.testing.expectEqualSlices(usize, try panes.File.lineIndex(gpa, &pane.file.?), kept);
+ }
+}
+
+test "J joins a line with the next, its indent dropped, a space between unless the next is empty" {
+ const gpa = std.testing.allocator;
+ const cases = [_]struct { text: []const u8, row: i32, rows: i32 = 0, want: []const u8 }{
+ .{ .text = "a\n b\nc\n", .row = 0, .want = "a b\nc\n" },
+ .{ .text = "a\n\nc\n", .row = 0, .want = "a\nc\n" },
+ .{ .text = "a\nb", .row = 1, .want = "a\nb" },
+ .{ .text = "one\n\ttwo\nthree\nfour\n", .row = 0, .rows = 2, .want = "one two three\nfour\n" },
+ };
+ for (cases) |case| {
+ const p = try Pardes.init(gpa, .{ .tty_only = true });
+ defer p.deinit();
+ while (p.nextEffect()) |_| {}
+ const pane = try p.setTestFile(case.text);
+ pane.body.mode = .normal;
+ pane.body.cur_row = case.row;
+ pane.body.cur_col = 0;
+ if (case.rows > 0) pane.body.vsel = .{ .active = true, .row = case.row + case.rows, .col = 0, .explicit = true };
+ normalJoin(p, &pane.body, false);
+ try std.testing.expectEqualStrings(case.want, pane.file.?.content);
+ }
+}
diff --git a/src/exec.zig b/src/exec.zig
index d03a4a48..c9f304b0 100644
--- a/src/exec.zig
+++ b/src/exec.zig
@@ -913,6 +913,12 @@ pub fn commandDone(p: *Pardes, id: usize, status: ?u8) void {
pane.repl = null;
pane.command_status = status;
pane.body.mode = .normal;
+ // Look's `git show`: its output went to a +Pager, the +Diff now; only a
+ // failure is worth the pane.
+ if (pane.command_pages) {
+ pane.command_pages = false;
+ if (status == 0) return p.removePane(id, null) catch {};
+ }
var buf: [16]u8 = undefined;
const code = if (status) |n| std.fmt.bufPrint(&buf, "{d}", .{n}) catch "?" else "?";
var said: [32]u8 = undefined;
diff --git a/src/fs.zig b/src/fs.zig
index 061d4225..032ab9c0 100644
--- a/src/fs.zig
+++ b/src/fs.zig
@@ -1087,17 +1087,17 @@ pub const platform_has_fs = !pardes.isolated and switch (pardes.platform) {
const find_max_hits = 512;
/// What a Find or Grep walk passed over, said under its hits: directories
-/// it might not open, files read only in part, and caps it stopped at.
+/// it might not open, and caps it stopped at.
pub const WalkNotes = struct {
skipped: usize = 0,
- /// Files longer than grep_max_bytes, searched in their first part only.
- partial: usize = 0,
hits_cut: bool = false,
+ /// A pane search's matching lines it stopped at, its rows filling
+ /// look.search_text_output_bytes; 0 if none.
+ rows_cut: usize = 0,
/// The cap on entries walked it stopped at, 0 if none.
walk_cut: usize = 0,
pub const max_hits = find_max_hits;
- pub const max_file_bytes = grep_max_bytes;
pub const max_files = grep_max_files;
pub const max_depth = find_max_depth;
@@ -1105,7 +1105,7 @@ pub const WalkNotes = struct {
pub fn write(n: WalkNotes, out: []u8) usize {
var w = std.Io.Writer.fixed(out);
if (n.hits_cut) w.print("cut at {d} hits\n", .{max_hits}) catch {};
- if (n.partial > 0) w.print("{d} file{s} read only in part (first {d} KiB)\n", .{ n.partial, if (n.partial == 1) "" else "s", max_file_bytes / 1024 }) catch {};
+ if (n.rows_cut > 0) w.print("cut at {d} lines\n", .{n.rows_cut}) catch {};
if (n.walk_cut > 0) w.print("walk cut at {d} entries\n", .{n.walk_cut}) catch {};
if (n.skipped > 0) w.print("{d} director{s} skipped: permission denied\n", .{ n.skipped, if (n.skipped == 1) "y" else "ies" }) catch {};
return w.buffered().len;
@@ -1124,7 +1124,8 @@ pub const WalkNotes = struct {
};
const find_max_depth = 16;
const find_max_steps = 100_000;
-pub const search_max_output_bytes = pardes.MAX_PANES * find_max_hits * (4096 + 320);
+/// One root's Find or Grep rows at most: its hits, each a path and a line.
+pub const search_root_output_bytes = find_max_hits * (4096 + 320);
const find_skip = [_][]const u8{
".git", ".jj", "target", "node_modules",
@@ -1194,9 +1195,10 @@ const grep_max_files = 20_000;
const GrepResult = struct { bytes: usize, hits: usize };
-fn grepText(path: []const u8, text: []const u8, pat: []const u8, out: []u8, budget: usize) GrepResult {
+/// `text` starts at line `first_line` + 1 of its file.
+fn grepText(path: []const u8, text: []const u8, pat: []const u8, out: []u8, budget: usize, first_line: usize) GrepResult {
var result: GrepResult = .{ .bytes = 0, .hits = 0 };
- var line: usize = 0;
+ var line: usize = first_line;
var it = std.mem.splitScalar(u8, text, '\n');
while (it.next()) |raw| {
line += 1;
@@ -1220,7 +1222,7 @@ pub fn grep(arena: std.mem.Allocator, gpa: std.mem.Allocator, dir: []const u8, b
if (!platform_has_fs) {
for (sources) |s| {
if (hits >= find_max_hits or written == out.len) break;
- const result = grepText(s.path, s.contents, pat, out[written..], find_max_hits - hits);
+ const result = grepText(s.path, s.contents, pat, out[written..], find_max_hits - hits, 0);
hits += result.hits;
written += result.bytes;
}
@@ -1276,30 +1278,39 @@ pub fn grep(arena: std.mem.Allocator, gpa: std.mem.Allocator, dir: []const u8, b
const path_z = std.fmt.bufPrintSentinel(&pathbuf, "{s}", .{path}, 0) catch return error.PathTooLong;
const fd = libc.open(path_z, .{ .ACCMODE = .RDONLY, .CLOEXEC = true, .NONBLOCK = true });
if (fd < 0) continue;
+ defer _ = libc.close(fd);
+ // The whole file, a buffer at a time: each searched through its last
+ // whole line, the rest carried into the next.
+ const shown = lsp.rel(home, path);
var len: usize = 0;
- var readable = true;
- while (len < buf.len) {
- const n = libc.read(fd, buf[len..].ptr, buf.len - len);
- if (n < 0) {
- if (libc.errno(n) == .INTR) continue;
- readable = false;
- break;
+ var lines_before: usize = 0;
+ var first = true;
+ file: while (true) {
+ var eof = false;
+ while (len < buf.len) {
+ const n = libc.read(fd, buf[len..].ptr, buf.len - len);
+ if (n < 0) {
+ if (libc.errno(n) == .INTR) continue;
+ break :file;
+ }
+ if (n == 0) {
+ eof = true;
+ break;
+ }
+ len += @intCast(n);
}
- if (n == 0) break;
- len += @intCast(n);
+ if (first and std.mem.indexOfScalar(u8, buf[0..@min(len, 1024)], 0) != null) break;
+ first = false;
+ // A line longer than the buffer is searched in buffer-sized parts.
+ const end = if (eof) len else if (std.mem.lastIndexOfScalar(u8, buf[0..len], '\n')) |nl| nl + 1 else len;
+ const result = grepText(shown, buf[0..end], pat, out[written..], find_max_hits - hits, lines_before);
+ hits += result.hits;
+ written += result.bytes;
+ if (eof or hits >= find_max_hits or written == out.len) break;
+ lines_before += std.mem.count(u8, buf[0..end], "\n");
+ std.mem.copyForwards(u8, buf[0 .. len - end], buf[end..len]);
+ len -= end;
}
- // Read to its cap with more behind it: searched in part, and said.
- var more: [1]u8 = undefined;
- const longer = readable and len == buf.len and libc.read(fd, &more, 1) > 0;
- _ = libc.close(fd);
- if (!readable) continue;
- const text = buf[0..len];
- if (std.mem.indexOfScalar(u8, text[0..@min(len, 1024)], 0) != null) continue;
- if (longer) notes.partial += 1;
- const shown = lsp.rel(home, path);
- const result = grepText(shown, text, pat, out[written..], find_max_hits - hits);
- hits += result.hits;
- written += result.bytes;
if (hits >= find_max_hits) notes.hits_cut = true;
}
return written;
@@ -1366,14 +1377,14 @@ test "a directory the walk may not open is skipped and counted: Grep and Find ke
try std.testing.expectEqual(@as(usize, 1), notes.skipped);
}
-test "Grep says when a cap hid what it might have found: a file read in part, the hits cut" {
+test "Grep reads a long file to its end, and says when its hits were cut" {
if (!platform_has_fs) return;
const gpa = std.testing.allocator;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
var base_buf: [std.fs.max_path_bytes]u8 = undefined;
const dir = base_buf[0..try tmp.dir.realPath(std.testing.io, &base_buf)];
- // The match past the first 256 KiB of a long file.
+ // A match past the first buffer of a long file, on its own line number.
const long = try gpa.alloc(u8, grep_max_bytes + 64);
defer gpa.free(long);
@memset(long, 'x');
@@ -1386,8 +1397,9 @@ test "Grep says when a cap hid what it might have found: a file read in part, th
defer gpa.free(out);
var notes: WalkNotes = .{};
var n = try grep(arena.allocator(), gpa, dir, dir, "needle", out, &notes);
- try std.testing.expectEqual(@as(usize, 0), n);
- try std.testing.expectEqual(@as(usize, 1), notes.partial);
+ var want_buf: [64]u8 = undefined;
+ const want = try std.fmt.bufPrint(&want_buf, "long.txt:{d}:", .{std.mem.count(u8, long, "\n")});
+ try std.testing.expect(std.mem.startsWith(u8, out[0..n], want));
// More hits than the cap.
var many: std.ArrayList(u8) = .empty;
defer many.deinit(gpa);
@@ -1398,7 +1410,7 @@ test "Grep says when a cap hid what it might have found: a file read in part, th
try std.testing.expect(notes.hits_cut);
var said: [256]u8 = undefined;
const lines = said[0..notes.write(&said)];
- try std.testing.expectEqualStrings("cut at 512 hits\n1 file read only in part (first 256 KiB)\n", lines);
+ try std.testing.expectEqualStrings("cut at 512 hits\n", lines);
try std.testing.expect(WalkNotes.isNote("cut at 512 hits") and WalkNotes.isNote("2 directories skipped: permission denied") and !WalkNotes.isNote("src/2 directories.txt"));
}
diff --git a/src/gui/gui.zig b/src/gui/gui.zig
index f9921111..9cd37b6b 100644
--- a/src/gui/gui.zig
+++ b/src/gui/gui.zig
@@ -828,18 +828,13 @@ fn emitTouchClick(t: *Touch, in: *Input, point: TouchNormPoint, button: pardes.M
in.post(.{ .mouse = .{ .button = button, .kind = .release, .col = cell.col, .row = cell.row, .tag_hit = cell.tag_hit, .body_hit = cell.body_hit } });
}
-fn normCell(norm: f32, win: f32, cell: f32) u16 {
- const px = std.math.clamp(norm, 0.0, 1.0) * win;
- return @intFromFloat(@max(0, @floor(px / cell)));
-}
-
const Pty = struct {
fd: c_int,
pid: libc.pid_t,
serial: u32,
kill_at: i64 = 0,
- reader: ?std.Thread = null,
- stop: [2]c_int = .{ -1, -1 },
+ /// Its reader, blocked in an Io read: `closePty` cancels it.
+ reader: ?std.Io.Future(void) = null,
/// A command pane's child, watched to its exit (host_io.watchExit);
/// the pty stays open until both its end of file and its exit.
cmd: host_io.CommandWatch = .{},
@@ -876,31 +871,6 @@ const Msg = union(enum) {
}
};
-const LspWorkers = struct {
- const capacity = 16;
- active: std.atomic.Value(usize) = .init(0),
-
- fn start(workers: *LspWorkers) bool {
- var count = workers.active.load(.monotonic);
- while (count < capacity)
- count = workers.active.cmpxchgWeak(count, count + 1, .monotonic, .monotonic) orelse return true;
- return false;
- }
-
- fn finish(workers: *LspWorkers) void {
- const previous = workers.active.fetchSub(1, .release);
- std.debug.assert(previous > 0);
- }
-
- fn wait(workers: *LspWorkers) void {
- var spins: u8 = 0;
- while (workers.active.load(.acquire) != 0) {
- spins +%= 1;
- if (spins == 0) std.Thread.yield() catch {} else std.atomic.spinLoopHint();
- }
- }
-};
-
const PipeTasks = selection_pipe.Tasks;
const queue_capacity = 512;
@@ -918,10 +888,13 @@ const MessageBatch = struct {
const Queue = struct {
gpa: std.mem.Allocator,
lsp_allocator: std.mem.Allocator,
- lsp_workers: *LspWorkers,
+ /// The query in flight; the UI thread's alone (spawnLsp, teardown).
+ lsp_task: ?host_io.Lsp.Task = null,
sdl_wake: bool, // wake a blocking SDL_WaitEventTimeout on cross-thread push
- mutex: libc.pthread_mutex_t = .{},
- space: libc.pthread_cond_t = .{},
+ /// The process's Io: its terminal readers wait for space on `space`.
+ io: std.Io,
+ mutex: std.Io.Mutex = .init,
+ space: std.Io.Condition = .init,
items: [queue_capacity]Msg = undefined,
head: usize = 0,
len: usize = 0,
@@ -934,13 +907,11 @@ const Queue = struct {
completion_len: usize = 0,
fn lock(q: *Queue) void {
- // unreachable failures: pthread calls on this queue's own initialised, non-recursive
- // mutex and condition fail only on misuse (EINVAL, EDEADLK), never on input.
- std.debug.assert(libc.pthread_mutex_lock(&q.mutex) == .SUCCESS);
+ q.mutex.lockUncancelable(q.io);
}
fn unlock(q: *Queue) void {
- std.debug.assert(libc.pthread_mutex_unlock(&q.mutex) == .SUCCESS);
+ q.mutex.unlock(q.io);
}
fn wake(q: *Queue) void {
@@ -973,14 +944,14 @@ const Queue = struct {
};
if (matches) q.removeAt(i).deinit(q.gpa, q.lsp_allocator) else i += 1;
}
- std.debug.assert(libc.pthread_cond_broadcast(&q.space) == .SUCCESS);
+ q.space.broadcast(q.io);
}
fn pushOutput(q: *Queue, pane: u8, gen: u32, bytes: []u8) bool {
q.lock();
while (!q.closed and q.readers[pane] == gen and q.len >= output_capacity) {
q.waiting += 1;
- std.debug.assert(libc.pthread_cond_wait(&q.space, &q.mutex) == .SUCCESS);
+ q.space.waitUncancelable(q.io, &q.mutex);
q.waiting -= 1;
}
if (q.closed or q.readers[pane] != gen) {
@@ -1088,7 +1059,7 @@ const Queue = struct {
@memcpy(batch.items[batch.len..][0..q.completion_len], q.completions[0..q.completion_len]);
batch.len += q.completion_len;
q.completion_len = 0;
- std.debug.assert(libc.pthread_cond_broadcast(&q.space) == .SUCCESS);
+ q.space.broadcast(q.io);
}
fn discardCompletions(q: *Queue) void {
@@ -1104,7 +1075,7 @@ const Queue = struct {
q.closed = true;
q.files_changed = false;
q.readers = @splat(null);
- std.debug.assert(libc.pthread_cond_broadcast(&q.space) == .SUCCESS);
+ q.space.broadcast(q.io);
q.unlock();
q.discardCompletions();
q.lock();
@@ -1121,15 +1092,12 @@ const Queue = struct {
fn deinit(q: *Queue) void {
q.close();
std.debug.assert(q.waiting == 0);
- std.debug.assert(libc.pthread_cond_destroy(&q.space) == .SUCCESS);
- std.debug.assert(libc.pthread_mutex_destroy(&q.mutex) == .SUCCESS);
}
};
test "GUI completion survives a full output queue" {
const gpa = std.testing.allocator;
- var workers: LspWorkers = .{};
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = gpa, .lsp_workers = &workers, .sdl_wake = false, .lsp_id = 7 };
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa, .sdl_wake = false, .lsp_id = 7 };
defer queue.deinit();
queue.acceptReader(0, 1);
for (0..output_capacity) |_| queue.push(.{ .output = .{
@@ -1185,8 +1153,7 @@ const PtyTests = struct {
test "GUI PTY backpressure retains byte order and tail before EOF" {
const gpa = std.testing.allocator;
- var workers: LspWorkers = .{};
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = gpa, .lsp_workers = &workers, .sdl_wake = false };
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa, .sdl_wake = false };
defer queue.deinit();
queue.acceptReader(0, 1);
for (0..output_capacity) |_| queue.push(.{ .output = .{ .pane = 0, .gen = 1, .bytes = try gpa.dupe(u8, "before") } });
@@ -1220,8 +1187,7 @@ test "GUI PTY backpressure retains byte order and tail before EOF" {
test "GUI PTY backpressure cancellation and close release owned producers" {
const gpa = std.testing.allocator;
for ([_]bool{ false, true }) |close| {
- var workers: LspWorkers = .{};
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = gpa, .lsp_workers = &workers, .sdl_wake = false };
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa, .sdl_wake = false };
defer queue.deinit();
queue.acceptReader(0, 1);
for (0..output_capacity) |_| queue.push(.{ .output = .{ .pane = 0, .gen = 1, .bytes = try gpa.dupe(u8, "before") } });
@@ -1252,8 +1218,7 @@ test "GUI PTY backpressure cancellation and close release owned producers" {
test "GUI PTY EOF reserve cannot evict terminal output" {
const gpa = std.testing.allocator;
- var workers: LspWorkers = .{};
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = gpa, .lsp_workers = &workers, .sdl_wake = false };
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa, .sdl_wake = false };
defer queue.deinit();
for (0..pardes.MAX_PANES) |pane| queue.acceptReader(@intCast(pane), 1);
for (0..output_capacity) |_| queue.push(.{ .output = .{ .pane = 0, .gen = 1, .bytes = try gpa.dupe(u8, "before") } });
@@ -1269,8 +1234,7 @@ test "GUI PTY reader delivers a real shell tail before EOF and joins on close" {
const gpa = std.testing.allocator;
const core = try pardes.Pardes.init(gpa, .{ .tty_only = true });
defer core.deinit();
- var workers: LspWorkers = .{};
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = gpa, .lsp_workers = &workers, .sdl_wake = false };
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa, .sdl_wake = false };
defer queue.deinit();
var ptys: [pardes.MAX_PANES]?Pty = @splat(null);
var gens: [pardes.MAX_PANES]u32 = @splat(1);
@@ -1320,8 +1284,7 @@ test "GUI PTY Restore joins a real reader waiting for queue space" {
var core = try pardes.Pardes.init(gpa, .{ .tty_only = true });
defer core.deinit();
try dump.dumpState(core);
- var workers: LspWorkers = .{};
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = gpa, .lsp_workers = &workers, .sdl_wake = false };
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa, .sdl_wake = false };
defer queue.deinit();
queue.acceptReader(1, 1);
for (0..output_capacity) |_| queue.push(.{ .output = .{ .pane = 1, .gen = 1, .bytes = try gpa.dupe(u8, "other pane") } });
@@ -1365,8 +1328,7 @@ test "GUI PTY deletion joins an idle reader and retains only its owned child for
const gpa = std.testing.allocator;
const core = try pardes.Pardes.init(gpa, .{ .tty_only = true });
defer core.deinit();
- var workers: LspWorkers = .{};
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = gpa, .lsp_workers = &workers, .sdl_wake = false };
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa, .sdl_wake = false };
defer queue.deinit();
var ptys: [pardes.MAX_PANES]?Pty = @splat(null);
var gens: [pardes.MAX_PANES]u32 = @splat(1);
@@ -1397,8 +1359,7 @@ test "GUI PTY deletion joins an idle reader and retains only its owned child for
test "GUI PTY file watcher stops and joins without closing its watched descriptor" {
if (!file_watch.supported) return error.SkipZigTest;
const gpa = std.testing.allocator;
- var workers: LspWorkers = .{};
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = gpa, .lsp_workers = &workers, .sdl_wake = false };
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa, .sdl_wake = false };
defer queue.deinit();
const fd = file_watch.init(true);
if (fd < 0) return error.WatchInitFailed;
@@ -1422,8 +1383,7 @@ test "GUI completion failure survives backlog and leaves the document unchanged"
pane.body.cur_col = 1;
core.lspRequest(core.active, .completion, "");
const id = core.lsp_wait.?.id;
- var workers: LspWorkers = .{};
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = gpa, .lsp_workers = &workers, .sdl_wake = false, .lsp_id = id };
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa, .sdl_wake = false, .lsp_id = id };
defer queue.deinit();
queue.acceptReader(0, 1);
for (0..output_capacity) |_| queue.push(.{ .output = .{
@@ -1452,8 +1412,7 @@ test "GUI completion failure survives backlog and leaves the document unchanged"
test "GUI completions retain their arrival order across LSP and pipes" {
const gpa = std.testing.allocator;
- var workers: LspWorkers = .{};
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = gpa, .lsp_workers = &workers, .sdl_wake = false, .lsp_id = 2 };
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa, .sdl_wake = false, .lsp_id = 2 };
defer queue.deinit();
queue.push(.{ .pipe = .{ .id = 1, .success = true, .outputs = &.{} } });
queue.push(.{ .lsp = .{ .id = 2, .rows = try gpa.dupe(u8, "second") } });
@@ -1469,8 +1428,7 @@ test "GUI completions retain their arrival order across LSP and pipes" {
test "GUI completion reset frees queued payloads and rejects late LSP workers" {
const gpa = std.testing.allocator;
- var workers: LspWorkers = .{};
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = gpa, .lsp_workers = &workers, .sdl_wake = false, .lsp_id = 9 };
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa, .sdl_wake = false, .lsp_id = 9 };
defer queue.deinit();
queue.acceptReader(0, 1);
queue.push(.{ .output = .{ .pane = 0, .gen = 1, .bytes = try gpa.dupe(u8, "retained") } });
@@ -1523,29 +1481,22 @@ fn lspStatusSink(ctx: ?*anyopaque, text: []const u8) void {
q.push(.{ .lsp_status = copy });
}
-fn readPtyThread(gpa: std.mem.Allocator, fd: c_int, stop: c_int, pane: u8, gen: u32, q: *Queue) void {
+fn readPty(io: std.Io, gpa: std.mem.Allocator, fd: c_int, pane: u8, gen: u32, q: *Queue) void {
+ const pty: std.Io.File = .{ .handle = fd, .flags = .{ .nonblocking = false } };
var buf: [0x10000]u8 = undefined;
var failure: ?anyerror = null;
while (true) {
- var fds = [_]libc.pollfd{
- .{ .fd = stop, .events = libc.POLL.IN, .revents = 0 },
- .{ .fd = fd, .events = libc.POLL.IN, .revents = 0 },
+ const n = pty.readStreaming(io, &.{&buf}) catch |err| switch (err) {
+ // A pty whose child has gone answers EIO: its end of file.
+ error.EndOfStream, error.InputOutput => break,
+ error.Canceled => return,
+ else => {
+ failure = err;
+ break;
+ },
};
- if (libc.poll(&fds, fds.len, -1) < 0) {
- if (libc.errno(-1) == .INTR) continue;
- failure = error.PollFailed;
- break;
- }
- if (fds[0].revents != 0) return;
- if (fds[1].revents == 0) continue;
- const n = libc.read(fd, &buf, buf.len);
- if (n < 0) {
- if (libc.errno(n) == .INTR) continue;
- if (libc.errno(n) != .IO) failure = error.ReadFailed;
- break;
- }
- if (n == 0) break;
- const bytes = gpa.dupe(u8, buf[0..@intCast(n)]) catch |err| {
+ if (n == 0) continue;
+ const bytes = gpa.dupe(u8, buf[0..n]) catch |err| {
failure = err;
break;
};
@@ -1566,14 +1517,9 @@ fn stopPipe() ![2]c_int {
fn spawnReader(gpa: std.mem.Allocator, pt: *Pty, pane: u8, gen: u32, q: *Queue) !void {
std.debug.assert(pt.reader == null and pt.fd >= 0);
- const stop = try stopPipe();
- errdefer for (stop) |fd| {
- _ = libc.close(fd);
- };
q.acceptReader(pane, gen);
errdefer q.cancelReader(pane, gen);
- pt.reader = try std.Thread.spawn(.{}, readPtyThread, .{ gpa, pt.fd, stop[0], pane, gen, q });
- pt.stop = stop;
+ pt.reader = try q.io.concurrent(readPty, .{ q.io, gpa, pt.fd, pane, gen, q });
}
fn watchThread(fd: c_int, stop: c_int, q: *Queue) void {
@@ -1592,9 +1538,8 @@ fn watchThread(fd: c_int, stop: c_int, q: *Queue) void {
}
}
-fn lspThread(lsp_allocator: std.mem.Allocator, workers: *LspWorkers, job: *host_io.Lsp.Job, q: *Queue) void {
- defer workers.finish();
- host_io.Lsp.work(lsp_allocator, job, q, pushLspRows);
+fn lspThread(io: std.Io, lsp_allocator: std.mem.Allocator, job: *host_io.Lsp.Job, q: *Queue) anyerror!void {
+ host_io.Lsp.work(io, lsp_allocator, job, q, pushLspRows);
}
fn pushLspRows(ctx: ?*anyopaque, id: u32, rows: ?[]u8) void {
@@ -1602,107 +1547,52 @@ fn pushLspRows(ctx: ?*anyopaque, id: u32, rows: ?[]u8) void {
q.push(.{ .lsp = .{ .id = id, .rows = rows } });
}
-fn spawnLsp(core: *pardes.Pardes, q: *Queue, e: host_io.Lsp.Request) void {
+fn spawnLsp(core: *pardes.Pardes, io: std.Io, q: *Queue, e: host_io.Lsp.Request) void {
const lsp_allocator = q.lsp_allocator;
q.lock();
q.lsp_id = e.id;
q.discardLsp();
q.unlock();
- if (!q.lsp_workers.start()) {
- core.update(.{ .lsp_resp = .{ .id = e.id, .rows = null } });
- return core.reportError(e.pane, "lsp", error.WorkersBusy);
+ // Its waits are cancelation points: this join is short, and what it
+ // still delivers carries an id the queue now rejects.
+ if (q.lsp_task) |*old| {
+ old.future.cancel(io) catch {};
+ q.lsp_task = null;
}
const job = host_io.Lsp.snapshot(lsp_allocator, core, e) catch |err| {
- q.lsp_workers.finish();
core.update(.{ .lsp_resp = .{ .id = e.id, .rows = null } });
return core.reportError(e.pane, "lsp", err);
};
- const th = std.Thread.spawn(.{}, lspThread, .{ lsp_allocator, q.lsp_workers, job, q }) catch |err| {
- q.lsp_workers.finish();
+ const future = io.concurrent(lspThread, .{ io, lsp_allocator, job, q }) catch |err| {
job.free(lsp_allocator);
core.update(.{ .lsp_resp = .{ .id = e.id, .rows = null } });
return core.reportError(e.pane, "lsp", err);
};
- th.detach();
+ q.lsp_task = .{ .id = e.id, .future = future };
}
-test "GUI LSP worker limit rejects before allocation and recovers after owned workers exit" {
+test "GUI LSP query answers, and a newer one cancels it" {
const gpa = std.testing.allocator;
+ const io = std.testing.io;
const core = try pardes.Pardes.init(gpa, .{ .tty_only = true });
defer core.deinit();
- const pane = try core.setTestFile("abc");
- pane.body.cur_col = 1;
- var workers: LspWorkers = .{};
- var gate: std.Io.Event = .unset;
- var threads: [LspWorkers.capacity]?std.Thread = @splat(null);
- defer {
- gate.set(std.testing.io);
- for (threads) |thread| if (thread) |owned| owned.join();
- workers.wait();
- }
- for (&threads) |*thread| {
- try std.testing.expect(workers.start());
- thread.* = std.Thread.spawn(.{}, struct {
- fn run(active: *LspWorkers, ready: *std.Io.Event) void {
- defer active.finish();
- ready.waitUncancelable(std.testing.io);
- }
- }.run, .{ &workers, &gate }) catch |err| {
- workers.finish();
- return err;
- };
- }
- try std.testing.expectEqual(@as(usize, LspWorkers.capacity), workers.active.load(.monotonic));
- try std.testing.expect(!workers.start());
- var failing = std.testing.FailingAllocator.init(gpa, .{ .fail_index = 0 });
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = failing.allocator(), .lsp_workers = &workers, .sdl_wake = false };
+ _ = try core.setTestFile("abc");
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa, .sdl_wake = false };
defer queue.deinit();
- core.lspRequest(core.active, .completion, "");
- const rejected = core.lsp_wait.?.id;
- queue.lsp_id = rejected -% 1;
- queue.push(.{ .lsp = .{ .id = queue.lsp_id.?, .rows = try gpa.dupe(u8, "obsolete queued result") } });
- spawnLsp(core, &queue, .{
- .id = rejected,
- .kind = .completion,
- .pane = @intCast(core.active),
- .offset = 1,
- .arg = "",
- });
- try std.testing.expect(core.lsp_wait == null);
- try std.testing.expectEqualStrings("abc", pane.file.?.content);
- try std.testing.expectEqual(@as(i32, 1), pane.body.cur_col);
- try std.testing.expect(std.mem.indexOf(u8, pane.msg[0..pane.msg_len], "workers busy") != null);
- try std.testing.expectEqual(@as(usize, 0), failing.alloc_index);
- try std.testing.expect(!failing.has_induced_failure);
- try std.testing.expectEqual(rejected, queue.lsp_id.?);
- try std.testing.expectEqual(@as(usize, 0), queue.completion_len);
- queue.push(.{ .lsp = .{ .id = rejected -% 1, .rows = try gpa.dupe(u8, "obsolete late result") } });
- try std.testing.expectEqual(@as(usize, 0), queue.completion_len);
- try std.testing.expectEqual(@as(usize, LspWorkers.capacity), workers.active.load(.monotonic));
-
- gate.set(std.testing.io);
- workers.wait();
- try std.testing.expectEqual(@as(usize, 0), workers.active.load(.monotonic));
- queue.lsp_allocator = gpa;
- core.lspRequest(core.active, .status, "");
- const accepted = core.lsp_wait.?.id;
- spawnLsp(core, &queue, .{
- .id = accepted,
- .kind = .status,
- .pane = @intCast(core.active),
- .offset = 0,
- .arg = "",
- });
- workers.wait();
+ for (0..2) |_| {
+ core.lspRequest(core.active, .status, "");
+ spawnLsp(core, io, &queue, .{ .id = core.lsp_wait.?.id, .kind = .status, .pane = @intCast(core.active), .offset = 0, .arg = "" });
+ }
+ const last = core.lsp_wait.?.id;
+ try queue.lsp_task.?.future.await(io);
+ queue.lsp_task = null;
var batch = queue.take();
defer for (batch.slice()) |msg| msg.deinit(gpa, gpa);
try std.testing.expectEqual(@as(usize, 1), batch.len);
- try std.testing.expectEqual(accepted, batch.items[0].lsp.id);
+ try std.testing.expectEqual(last, batch.items[0].lsp.id);
try std.testing.expect(batch.items[0].lsp.rows != null);
- core.update(.{ .lsp_resp = .{ .id = accepted, .rows = batch.items[0].lsp.rows } });
+ core.update(.{ .lsp_resp = .{ .id = last, .rows = batch.items[0].lsp.rows } });
try std.testing.expect(core.lsp_wait == null);
- try std.testing.expectEqual(@as(usize, 0), workers.active.load(.monotonic));
- try std.testing.expectEqualStrings("abc", pane.file.?.content);
}
fn pipeThread(io: std.Io, gpa: std.mem.Allocator, job: *selection_pipe.Job, q: *Queue) anyerror!void {
@@ -1748,11 +1638,10 @@ test "GUI worker setup failures finish matching LSP and pipe requests" {
var failing = std.testing.FailingAllocator.init(gpa, .{
.fail_index = if (failure == 0) 0 else std.math.maxInt(usize),
});
- var workers: LspWorkers = .{};
var queue: Queue = .{
+ .io = std.testing.io,
.gpa = gpa,
.lsp_allocator = failing.allocator(),
- .lsp_workers = &workers,
.sdl_wake = false,
};
defer queue.deinit();
@@ -1768,7 +1657,7 @@ test "GUI worker setup failures finish matching LSP and pipe requests" {
if (failure == 0) {
queue.lsp_id = req.id -% 1;
queue.push(.{ .lsp = .{ .id = queue.lsp_id.?, .rows = try gpa.dupe(u8, "old queued result") } });
- spawnLsp(core, &queue, req);
+ spawnLsp(core, std.testing.io, &queue, req);
try std.testing.expectEqual(req.id, queue.lsp_id.?);
try std.testing.expectEqual(@as(usize, 0), queue.completion_len);
queue.push(.{ .lsp = .{ .id = req.id -% 1, .rows = try gpa.dupe(u8, "late old result") } });
@@ -1791,7 +1680,7 @@ test "GUI worker setup failures finish matching LSP and pipe requests" {
spawnPipe(core, failing_io, failing.allocator(), &queue, &tasks, pipe_id);
try std.testing.expect(core.pipe.wait == null);
try std.testing.expectEqualStrings("abc", pane.file.?.content);
- try std.testing.expectEqual(@as(usize, 0), workers.active.load(.monotonic));
+ try std.testing.expect(queue.lsp_task == null);
try std.testing.expectEqual(@as(usize, 0), tasks.len);
try std.testing.expectEqual(@as(usize, 0), queue.len);
}
@@ -2071,22 +1960,6 @@ fn fixedCellLayout(g: *const Gui) CellLayout {
return .{ .w = @floatFromInt(g.cell_w), .h = @floatFromInt(g.cell_h), .x_off = 0, .y_off = 0 };
}
-fn compactTaglineLayout(g: *const Gui, origin_col: f32) CellLayout {
- const body_w: f32 = @floatFromInt(g.cell_w);
- const tag_w: f32 = @floatFromInt(g.tagline_width);
- return .{
- .w = tag_w,
- .h = @floatFromInt(g.cell_h),
- .x_off = origin_col * (body_w - tag_w),
- .y_off = 0,
- };
-}
-
-fn taglineLayoutForCell(g: *const Gui, col: u16) CellLayout {
- // Canonical tag cells are physical grips; text is drawn by TagLayer.
- return compactTaglineLayout(g, @floatFromInt(col));
-}
-
const boxContains = pardes.animation.Box.contains;
/// What one tier draws, or one track in tiers 2 and 3 (docs/render-pipeline.md
@@ -2663,15 +2536,14 @@ fn localSession(
var ptys: [pardes.MAX_PANES]?Pty = @splat(null);
var gens: [pardes.MAX_PANES]u32 = @splat(0);
- var lsp_workers: LspWorkers = .{};
var queue: Queue = .{
+ .io = io,
.gpa = gpa,
.lsp_allocator = allocs.lsp,
- .lsp_workers = &lsp_workers,
.sdl_wake = true,
};
defer {
- lsp_workers.wait();
+ if (queue.lsp_task) |*task| task.future.cancel(io) catch {};
queue.deinit();
}
var pipe_tasks: PipeTasks = .{};
@@ -3035,15 +2907,14 @@ fn runGrid(init: std.process.Init, opts_in: pardes.Options) !void {
var ptys: [pardes.MAX_PANES]?Pty = @splat(null);
var gens: [pardes.MAX_PANES]u32 = @splat(0);
- var lsp_workers: LspWorkers = .{};
var queue: Queue = .{
+ .io = io,
.gpa = gpa,
.lsp_allocator = allocs.lsp,
- .lsp_workers = &lsp_workers,
.sdl_wake = false,
};
defer {
- lsp_workers.wait();
+ if (queue.lsp_task) |*task| task.future.cancel(io) catch {};
queue.deinit();
}
var pipe_tasks: PipeTasks = .{};
@@ -4195,13 +4066,12 @@ const Shell = struct {
fn closePty(s: *Shell, pane: u8) void {
const pt = if (s.ptys[pane]) |*pt| pt else return;
if (pt.fd < 0) return;
+ // Out of the queue first, which lets go a reader waiting for room
+ // in it; then its read is canceled (or, at its end, it is joined).
s.queue.cancelReader(pane, s.gens[pane]);
- if (pt.reader) |thread| {
- _ = host_io.writeFd(pt.stop[1], "x");
- thread.join();
+ if (pt.reader) |*reader| {
+ reader.cancel(s.queue.io); // the Io it was started on (spawnReader)
pt.reader = null;
- for (pt.stop) |fd| _ = libc.close(fd);
- pt.stop = .{ -1, -1 };
}
_ = libc.close(pt.fd);
pt.fd = -1;
@@ -4848,11 +4718,10 @@ test "the headless grid host round-trips a yank back as a paste" {
var ptys: [pardes.MAX_PANES]?Pty = @splat(null);
var gens: [pardes.MAX_PANES]u32 = @splat(0);
- var lsp_workers: LspWorkers = .{};
var queue: Queue = .{
+ .io = std.testing.io,
.gpa = gpa,
.lsp_allocator = gpa,
- .lsp_workers = &lsp_workers,
.sdl_wake = false,
};
defer queue.deinit();
@@ -4933,7 +4802,7 @@ fn openLink(ctx: ?*anyopaque, url: []const u8) void {
fn lsp(ctx: ?*anyopaque, req: host_io.Lsp.Request) void {
const s = shellOf(ctx);
- if (s.threads_ok) return spawnLsp(s.core, s.queue, req);
+ if (s.threads_ok) return spawnLsp(s.core, s.io, s.queue, req);
s.core.update(.{ .lsp_resp = .{ .id = req.id, .rows = null } });
s.core.reportError(req.pane, "lsp", error.WorkersUnavailable);
}
@@ -5198,6 +5067,12 @@ const Glide = struct {
below: []pardes.Cell = &.{},
nabove: u16 = 0,
nbelow: u16 = 0,
+ /// The core's lines a scroll moved, not yet measured; and what the
+ /// glide in flight has moved, in lines and in the picture's rows. A
+ /// wrapped line is several rows, and the thumb counts lines.
+ pending_lines: f32 = 0,
+ lines_moved: f32 = 0,
+ rows_moved: f32 = 0,
/// The Motion flavour the last loop step read.
motion: pardes.animation.Motion = .{},
@@ -5211,6 +5086,16 @@ const Glide = struct {
glide.pending = false;
glide.nabove = 0;
glide.nbelow = 0;
+ glide.pending_lines = 0;
+ glide.lines_moved = 0;
+ glide.rows_moved = 0;
+ }
+
+ /// The glide's lag in the core's lines: its rows, scaled by the lines
+ /// they carried.
+ fn lagLines(glide: *const Glide) f32 {
+ if (glide.rows_moved == 0) return glide.offset;
+ return glide.offset * glide.lines_moved / glide.rows_moved;
}
fn deinit(glide: *Glide, gpa: std.mem.Allocator) void {
@@ -5270,6 +5155,9 @@ const Glide = struct {
break :found kk;
} else 0;
if (shift == 0) return glide.stop();
+ glide.rows_moved += @floatFromInt(shift);
+ glide.lines_moved += glide.pending_lines;
+ glide.pending_lines = 0;
// The rows that left: past the top going down, the bottom going up.
if (!glide.ensure(gpa)) return glide.stop();
const keep = if (glide.dir > 0) &glide.above else &glide.below;
@@ -5326,6 +5214,8 @@ fn stepGlide(g: *Gui, core: *pardes.Pardes, gpa: std.mem.Allocator) void {
glide.offset = 0;
glide.nabove = 0;
glide.nbelow = 0;
+ glide.lines_moved = 0;
+ glide.rows_moved = 0;
}
}
const notch = g.scroll_notch;
@@ -5357,6 +5247,8 @@ fn stepGlide(g: *Gui, core: *pardes.Pardes, gpa: std.mem.Allocator) void {
}
var left = notch;
var moved = false;
+ const first = pane.scroll();
+ defer glide.pending_lines += @floatFromInt(@abs(pane.scroll() - first));
while (left != 0) {
const down = left > 0;
left += if (down) -1 else 1;
@@ -9347,7 +9239,7 @@ fn paneDecor(g: *Gui, gpa: std.mem.Allocator, regions: []const pardes.Region, gr
// In pixels, not rows, and with the picture while it glides
// or lags behind the core's rows (both in rows of the body).
const lag: f32 = if (g.glide.offset != 0 and g.glide.pane == rail.owner)
- g.glide.offset
+ g.glide.lagLines()
else if (g.scroll_pane != null and g.scroll_pane.? == rail.owner) g.scroll_lag else 0;
const track_px = body_y1 - y0;
const size = @min(track_px, @max(layout.h, rail.thumb_span * track_px));
@@ -9983,6 +9875,12 @@ test "the scrollbar thumb moves by the pixel and follows a glide" {
g.glide.pane = core.active;
g.glide.offset = -1;
try std.testing.expectApproxEqAbs(at10, try thumb.top(&g, core), 1e-3);
+ // A wrapped line: the picture moved two rows for the one line, and the
+ // thumb lags the line, not two.
+ g.glide.lines_moved = 1;
+ g.glide.rows_moved = 2;
+ g.glide.offset = -2;
+ try std.testing.expectApproxEqAbs(at10, try thumb.top(&g, core), 1e-3);
}
test "the rule between stacked panes stays in the tag band's slack, at any tagline size" {
@@ -10581,12 +10479,11 @@ fn appendWorkspacePet(g: *Gui, core: ?*const pardes.Pardes, surface: *const pard
return;
}
// Read only the rendered global row. No pane/column tags, status text or
- // mouse targets are changed, and editing the workspace parks the pet.
+ // mouse targets are changed; editing the workspace tag leaves it be.
var occupied: usize = 0;
for (surface.cells[0..surface.cols], 0..) |*cell, i| {
if (cellCodepoint(cell) != ' ') occupied = i + 1;
}
- const editing = p.header_focus and p.header_column == null;
const band_top: f32 = @floatFromInt(taglineBandOffset(0, builder.win_h, g.cell_h, g.tagline_height));
const region = if (occupied >= surface.cols) null else pet.lane(
occupied,
@@ -10594,7 +10491,6 @@ fn appendWorkspacePet(g: *Gui, core: ?*const pardes.Pardes, surface: *const pard
builder.win_w,
band_top,
@floatFromInt(g.tagline_height),
- editing,
);
// SDL's regular pump already wakes at least every 16 ms. Quantization in
// sample keeps this independent of input, render rate and scene effects,
@@ -10602,16 +10498,24 @@ fn appendWorkspacePet(g: *Gui, core: ?*const pardes.Pardes, surface: *const pard
const pose = g.pet_state.sample(kind, c.SDL_GetTicks(), region) orelse return;
const ink = overlayRgb(p.chromeTheme().tag_fg);
const eye = overlayRgb(p.chromeTheme().tag_bg);
+ // Behind the cursor: the overlay is over the cells, so the pixels a
+ // cursor covers are left out.
+ var boxes: [max_cursors]CursorBox = undefined;
+ const cursors = boxes[0..cursorBoxes(g, surface, fixedCellLayout(g), builder.win_h, &boxes)];
for (0..pet.height) |y| for (0..pet.width) |x| {
const color = pet.pixel(kind, pose, x, y);
if (color == 0) continue;
const x0 = pose.x + @as(f32, @floatFromInt(x)) * pose.scale;
const y0 = pose.y + @as(f32, @floatFromInt(y)) * pose.scale;
+ const covered = for (cursors) |box| {
+ if (x0 < box.x1 and x0 + pose.scale > box.x0 and y0 < box.y1 and y0 + pose.scale > box.y0) break true;
+ } else false;
+ if (covered) continue;
builder.addRect(x0, y0, x0 + pose.scale, y0 + pose.scale, if (color == 2) eye else ink);
};
}
-test "pet overlay stays beyond workspace text and vanishes while its tag is edited" {
+test "pet overlay stays beyond workspace text and keeps going while its tag is edited" {
std.testing.refAllDecls(pet);
const core = try pardes.Pardes.init(std.testing.allocator, .{ .cols = 80, .rows = 24 });
defer core.deinit();
@@ -10638,10 +10542,13 @@ test "pet overlay stays beyond workspace text and vanishes while its tag is edit
try std.testing.expect(x >= 20 * 8 - 0.01);
try std.testing.expect(y >= 0 and y < 20);
}
+ const before = g.pet_state;
pardes.tagline.enterHeader(core, null);
builder.len = 0;
appendWorkspacePet(&g, core, &surface, &builder);
- try std.testing.expectEqual(@as(usize, 0), builder.len);
+ try std.testing.expect(builder.len > 0);
+ try std.testing.expectEqual(before.tick, g.pet_state.tick);
+ try std.testing.expectEqual(before.x, g.pet_state.x);
}
fn cursorColor(chrome: *const pardes.Chrome, cell: *const pardes.Cell, role: pardes.FontRole) [3]u8 {
diff --git a/src/gui/pet.zig b/src/gui/pet.zig
index a249d70f..7a13ca91 100644
--- a/src/gui/pet.zig
+++ b/src/gui/pet.zig
@@ -13,8 +13,8 @@ const hop_ticks = 8;
/// Only the trailing blank part of the global tag is eligible. The caller
/// supplies its last occupied cell, including any wide-grapheme continuation.
-pub fn lane(occupied: usize, cell_w: f32, screen_w: f32, top: f32, band_h: f32, editing: bool) ?Lane {
- if (editing or cell_w <= 0 or band_h < height + 2) return null;
+pub fn lane(occupied: usize, cell_w: f32, screen_w: f32, top: f32, band_h: f32) ?Lane {
+ if (cell_w <= 0 or band_h < height + 2) return null;
const scale = @min(3, @floor((band_h - 2) / height));
const left = @as(f32, @floatFromInt(occupied + 2)) * cell_w;
const right = screen_w - 2 * cell_w - width * scale;
@@ -32,11 +32,10 @@ pub const State = struct {
frame: u8 = 0,
rng: std.Random.DefaultPrng = undefined,
+ /// No lane (the tag's text has filled it) hides the pet but keeps
+ /// where it was and what it was doing.
pub fn sample(s: *State, kind: Kind, now_ms: u64, area: ?Lane) ?Pose {
- const region = area orelse {
- s.* = .{};
- return null;
- };
+ const region = area orelse return null;
if (kind == .off) {
s.* = .{};
return null;
@@ -142,11 +141,10 @@ pub fn pixel(kind: Kind, pose: Pose, x_in: usize, y: usize) u2 {
};
}
-test "pet stays in trailing workspace blanks and disappears during editing" {
- try std.testing.expect(lane(20, 8, 200, 0, 16, false) == null);
- try std.testing.expect(lane(3, 8, 200, 0, 16, true) == null);
- try std.testing.expect(lane(3, 8, 200, 0, 10, false) == null);
- const region = lane(3, 8, 200, 2, 20, false).?;
+test "pet stays in trailing workspace blanks, and a lost lane hides it without a reset" {
+ try std.testing.expect(lane(20, 8, 200, 0, 16) == null);
+ try std.testing.expect(lane(3, 8, 200, 0, 10) == null);
+ const region = lane(3, 8, 200, 2, 20).?;
try std.testing.expect(region.left >= 5 * 8);
var state: State = .{};
var moved = false;
@@ -159,12 +157,15 @@ test "pet stays in trailing workspace blanks and disappears during editing" {
reversed = reversed or pose.left;
}
try std.testing.expect(moved and reversed);
+ const kept = state;
try std.testing.expect(state.sample(.cat, 300000, null) == null);
+ try std.testing.expectEqual(kept.x, state.x);
+ try std.testing.expectEqual(kept.tick, state.tick);
try std.testing.expect(state.sample(.off, 300100, region) == null);
}
test "pet clock is fixed rate and sprites bounded in both directions" {
- const region = lane(1, 8, 400, 0, 16, false).?;
+ const region = lane(1, 8, 400, 0, 16).?;
var state: State = .{};
const start = state.sample(.frog, 1000, region).?;
try std.testing.expectEqualDeep(start, state.sample(.frog, 1099, region).?);
@@ -180,7 +181,7 @@ test "pet clock is fixed rate and sprites bounded in both directions" {
}
test "pet rests at random spots and the frog travels only in the air" {
- const region = lane(1, 8, 800, 0, 16, false).?;
+ const region = lane(1, 8, 800, 0, 16).?;
var state: State = .{};
var last = state.sample(.frog, 0, region).?;
var rested_midway = false;
@@ -195,7 +196,7 @@ test "pet rests at random spots and the frog travels only in the air" {
}
test "pet initial idle visibly animates without walking or leaving its tile" {
- const region = lane(1, 8, 400, 0, 16, false).?;
+ const region = lane(1, 8, 400, 0, 16).?;
for ([_]Kind{ .cat, .frog }) |kind| {
var state: State = .{};
const initial = state.sample(kind, 0, region).?;
diff --git a/src/host_io.zig b/src/host_io.zig
index c593551b..2c736e20 100644
--- a/src/host_io.zig
+++ b/src/host_io.zig
@@ -203,11 +203,14 @@ pub const Lsp = struct {
}
others.deinit(gpa);
}
+ var copied: usize = 0;
for (core.panes, 0..) |slot, i| {
const other = slot orelse continue;
if (i == req.pane) continue;
const f = other.file orelse continue;
if (f.output != null) continue;
+ if (copied + f.content.len > pardes.memory.limits.lsp_snapshot_bytes) continue;
+ copied += f.content.len;
const local = filesystem.localPath(f.path) orelse continue;
const other_path = try gpa.dupe(u8, local);
const other_source = gpa.dupeSentinel(u8, f.content, 0) catch |err| {
@@ -224,13 +227,19 @@ pub const Lsp = struct {
// Null is failure; the receiver frees non-null rows with the job's allocator.
pub const Deliver = *const fn (ctx: ?*anyopaque, id: u32, rows: ?[]u8) void;
- pub fn work(gpa: std.mem.Allocator, job: *Job, ctx: ?*anyopaque, deliver: Deliver) void {
+ pub fn work(io: std.Io, gpa: std.mem.Allocator, job: *Job, ctx: ?*anyopaque, deliver: Deliver) void {
defer job.free(gpa);
- var arena: std.heap.ArenaAllocator = .init(gpa);
- defer arena.deinit();
+ // The query's memory is the fixed region memory.zig reserved at
+ // startup: a hard bound, reused by each query in turn.
+ const region = pardes.memory.takeLspQuery() orelse {
+ deliver(ctx, job.id, null);
+ return;
+ };
+ var arena: std.heap.FixedBufferAllocator = .init(region);
+ defer pardes.memory.giveLspQuery(arena.end_index);
var out: std.Io.Writer.Allocating = .init(gpa);
defer out.deinit();
- pardes.lsp.query(gpa, arena.allocator(), .{
+ pardes.lsp.query(io, gpa, arena.allocator(), .{
.kind = job.kind,
.path = job.path,
.source = job.source,
@@ -240,6 +249,7 @@ pub const Lsp = struct {
.others = job.others,
.callstack_depth = job.callstack_depth,
.callstack_corners = job.callstack_corners,
+ .budget = &arena,
}, &out.writer) catch {
deliver(ctx, job.id, null);
return;
@@ -367,7 +377,7 @@ pub const Lsp = struct {
.offset = 0,
.arg = "",
});
- work(gpa, job, null, Sink.take);
+ work(std.testing.io, gpa, job, null, Sink.take);
// `status` is the one kind that answers with no file and no cursor, which
// is what makes it assertable here without a language server on the box.
@@ -416,7 +426,7 @@ pub const Lsp = struct {
.arg = "renamed",
});
if (fail) failing.fail_index = failing.alloc_index;
- work(failing.allocator(), job, &sink, Sink.take);
+ work(std.testing.io, failing.allocator(), job, &sink, Sink.take);
try std.testing.expectEqual(fail, sink.failed);
try std.testing.expect(core.lsp_wait == null);
if (fail) {
@@ -482,7 +492,7 @@ pub const Lsp = struct {
defer core.deinit();
const job = try snapshot(gpa, core, .{ .id = 37, .kind = .status, .pane = @intCast(core.active), .offset = 0, .arg = "" });
var sink: Sink = .{};
- work(gpa, job, &sink, Sink.take);
+ work(std.testing.io, gpa, job, &sink, Sink.take);
if (sink.rows) |rows| gpa.free(rows);
try std.testing.expect(allocator.failed);
try std.testing.expectEqual(@as(usize, 1), sink.calls);
@@ -1179,7 +1189,7 @@ pub const Shell = struct {
if (builtin.os.tag == .windows) return;
var saved_buf: [std.fs.max_path_bytes:0]u8 = @splat(0);
const saved: ?[:0]const u8 = if (std.c.getenv("XDG_RUNTIME_DIR")) |v| std.fmt.bufPrintSentinel(&saved_buf, "{s}", .{std.mem.span(v)}, 0) catch null else null;
- defer _ = if (saved) |v| setenv("XDG_RUNTIME_DIR", v.ptr, 1) else unsetenv("XDG_RUNTIME_DIR");
+ defer _ = if (saved) |v| setenv("XDG_RUNTIME_DIR", v.ptr, 1) else testUnsetenv("XDG_RUNTIME_DIR");
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
@@ -1213,7 +1223,7 @@ pub const Shell = struct {
try std.testing.expectEqualStrings(bash_rc, readSmall(c.bashPath().?, &buf) orelse return error.ReadFailed);
// No runtime dir: private files, one per owner, gone at teardown.
- _ = unsetenv("XDG_RUNTIME_DIR");
+ _ = testUnsetenv("XDG_RUNTIME_DIR");
var d = PromptFiles.init();
var e = PromptFiles.init();
defer e.deinit();
@@ -1294,6 +1304,44 @@ pub const ChildEnv = struct {
"TERM_PROGRAM=" ++ pardes.config.child_term_program,
};
+ /// What this editor tells its children of itself (exportPaneEnv, `$winid`),
+ /// kept here rather than set into this process's environment: std's Io read
+ /// that block at startup, and setenv/unsetenv rewrite it in place under it
+ /// (a spawn then scans a null inside it). `build` puts each exported one in
+ /// place of an inherited variable of its name; a cleared one hides it; one
+ /// never exported is inherited as it is.
+ pub const exported_names = [_][]const u8{ "PARDES_PID", "PARDES_9P", "PARDES_PANE", "PARDES_MOUNT", "winid" };
+ var exported_state: [exported_names.len]enum { inherited, cleared, set } = @splat(.inherited);
+ var exported_line: [exported_names.len][pardes.memory.limits.host_path_cap + 64:0]u8 = undefined;
+
+ /// Set (or, null, clear) what children are told for `var_name`.
+ pub fn exportVar(var_name: []const u8, value: ?[]const u8) void {
+ const i = exportedIndex(var_name).?;
+ const v = value orelse {
+ exported_state[i] = .cleared;
+ return;
+ };
+ const line = std.fmt.bufPrintSentinel(&exported_line[i], "{s}={s}", .{ var_name, v }, 0) catch {
+ exported_state[i] = .cleared;
+ return;
+ };
+ exported_state[i] = .set;
+ _ = line;
+ }
+
+ /// What children are told for `var_name`, as `exportVar` left it; null
+ /// when cleared or never exported.
+ pub fn exported(var_name: []const u8) ?[]const u8 {
+ const i = exportedIndex(var_name) orelse return null;
+ if (exported_state[i] != .set) return null;
+ return std.mem.span(@as([*:0]const u8, &exported_line[i]))[var_name.len + 1 ..];
+ }
+
+ fn exportedIndex(var_name: []const u8) ?usize {
+ for (exported_names, 0..) |n, i| if (std.mem.eql(u8, n, var_name)) return i;
+ return null;
+ }
+
/// Wide enough for any real environment; `build` answers null rather than
/// truncate, because a child missing half its variables is a worse bug
/// than one missing TERM, and the caller then execs with `environ` intact.
@@ -1318,7 +1366,8 @@ pub const ChildEnv = struct {
if (std.mem.eql(u8, inherited, name(mine))) break true;
} else false;
if (shadowed) continue;
- if (n + own.len + 1 > slots.len) return null;
+ if (exportedIndex(inherited)) |e| if (exported_state[e] != .inherited) continue;
+ if (n + own.len + exported_names.len + 1 > slots.len) return null;
slots[n] = entry;
n += 1;
}
@@ -1336,10 +1385,14 @@ pub const ChildEnv = struct {
if (std.mem.eql(u8, name(entry.?), name(default))) break true;
} else false;
if (set) continue;
- if (n + own.len + 4 > slots.len) return null;
+ if (n + own.len + exported_names.len + 4 > slots.len) return null;
slots[n] = default;
n += 1;
}
+ for (&exported_line, exported_state) |*line, state| if (state == .set) {
+ slots[n] = line;
+ n += 1;
+ };
for (own) |mine| {
slots[n] = mine;
n += 1;
@@ -1411,14 +1464,14 @@ test "the child environment replaces the launcher's terminal identity exactly on
defer if (restore) |t| {
_ = Shell.setenv("TERM", t.ptr, 1);
} else {
- _ = unsetenv("TERM");
+ _ = testUnsetenv("TERM");
};
// A launcher TERM must be shadowed rather than duplicated, and the rest of
// the environment must arrive untouched.
try std.testing.expectEqual(@as(c_int, 0), Shell.setenv("TERM", "dumb", 1));
try std.testing.expectEqual(@as(c_int, 0), Shell.setenv("PARDES_CHILD_ENV_PROBE", "1", 1));
- defer _ = unsetenv("PARDES_CHILD_ENV_PROBE");
+ defer _ = testUnsetenv("PARDES_CHILD_ENV_PROBE");
var slots: ChildEnv.Slots = undefined;
// Where the user named no pager: a terminal's shell pages into a
@@ -1481,6 +1534,16 @@ test "the child environment replaces the launcher's terminal identity exactly on
extern "c" fn unsetenv(name: [*:0]const u8) c_int;
+/// For tests: unset `name` without compacting the environment block std
+/// captured at startup (std.testing.environ and Io's spawns read it later). A
+/// new variable first moves glibc's `environ` to a heap copy, which unsetenv
+/// then compacts instead. Runtime code never changes this process's
+/// environment (ChildEnv.exportVar).
+pub fn testUnsetenv(name: [*:0]const u8) c_int {
+ _ = Shell.setenv("PARDES_TEST_ENVIRON_COPIED", "1", 1);
+ return unsetenv(name);
+}
+
/// The environment a pane's command is given (exportPaneEnv, `$winid`,
/// ChildEnv), as `NAME=value` lines in `arena`, for a command that is not a
/// pane's: an Edit's filters, run from pane `serial`.
@@ -1497,10 +1560,7 @@ pub fn commandEnv(arena: std.mem.Allocator, serial: u32, adopts: bool) ![]const
fn exportWinid(serial: u32) void {
var buf: [16]u8 = undefined;
- if (serial != 0) if (std.fmt.bufPrintSentinel(&buf, "{d}", .{serial}, 0)) |text| {
- if (Shell.setenv("winid", text, 1) == 0) return;
- } else |_| {};
- _ = unsetenv("winid");
+ ChildEnv.exportVar("winid", if (serial == 0) null else std.fmt.bufPrint(&buf, "{d}", .{serial}) catch null);
}
/// The longest line a command pane runs (exec.zig refuses a longer one).
@@ -1587,17 +1647,18 @@ pub fn forkShell(
if (helper) |path| {
const c = core.?;
const pn = c.panes[pane].?;
- const socket = libc.getenv("PARDES_9P") orelse return error.SessionSocketRequired;
+ const socket = ChildEnv.exported("PARDES_9P") orelse return error.SessionSocketRequired;
var command: std.Io.Writer.Allocating = .init(c.gpa);
defer command.deinit();
- try @import("linux/v9fs.zig").writeLaunchCommand(&command.writer, path, std.mem.span(socket), &spawn.argv);
+ try @import("linux/v9fs.zig").writeLaunchCommand(&command.writer, path, socket, &spawn.argv);
if (!try pardes.panes.terminal.queuePendingCommand(pn, command.written())) return error.ShellAlreadyStarted;
}
// Built here and not after the fork: between fork and exec the child may
// not call setenv, whose malloc can deadlock against a pty reader thread
// that held the heap when the fork took its snapshot.
var env_slots: ChildEnv.Slots = undefined;
- const paging: ChildEnv.Paging = if (one_line != null)
+ const pages = if (core) |c| if (c.panes[pane]) |pn| pn.command_pages else false else false;
+ const paging: ChildEnv.Paging = if (one_line != null and !pages)
.command
else if (core) |c| (if (c.settings.pager == .off) .terminal_off else .terminal) else .terminal;
const envp = ChildEnv.build(&env_slots, paging);
@@ -1695,7 +1756,7 @@ test "a forked shell is told which terminal it is talking to" {
defer if (restore) |t| {
_ = Shell.setenv("TERM", t.ptr, 1);
} else {
- _ = unsetenv("TERM");
+ _ = testUnsetenv("TERM");
};
_ = Shell.setenv("TERM", "dumb", 1);
diff --git a/src/hunks.zig b/src/hunks.zig
index 73c0654a..24aaf63d 100644
--- a/src/hunks.zig
+++ b/src/hunks.zig
@@ -368,21 +368,34 @@ const max_line_distance = 0.6;
/// rather than aligned at a quadratic cost (delta aligns them all).
const max_run = 256;
const max_cells = 1 << 16;
+/// Pairs one hunk compares (each a table of up to `max_cells`): past it, the
+/// rest of its lines are shown unemphasised. And the scratch each pair is
+/// aligned in, reused by the next: its table and the ranges it marks.
+const max_pairs = 4096;
+const pair_scratch_bytes = 8 << 20;
/// Pair each removed line with the first added line after the last one
/// paired that is near enough to it, in order, and emphasise in both the
/// tokens one has and the other has not.
fn inferEdits(arena: std.mem.Allocator, minus: []HunkLine, plus: []HunkLine) !void {
if (minus.len == 0 or plus.len == 0 or minus.len > max_run or plus.len > max_run) return;
+ const plus_tokens = try arena.alloc([]const []const u8, plus.len);
+ for (plus, plus_tokens) |line, *tokens| tokens.* = try tokenize(arena, line.code);
+ var scratch: std.heap.FixedBufferAllocator = .init(try @import("memory.zig").unfilled(arena, pair_scratch_bytes));
+ var pairs: usize = 0;
var plus_index: usize = 0;
for (minus) |*m| {
const m_tokens = try tokenize(arena, m.code);
var j = plus_index;
while (j < plus.len) : (j += 1) {
- const p_tokens = try tokenize(arena, plus[j].code);
+ const p_tokens = plus_tokens[j];
if ((m_tokens.len + 1) * (p_tokens.len + 1) > max_cells) continue;
- var alignment = try Alignment.init(arena, m_tokens, p_tokens);
- const marks = try annotate(arena, &alignment, m.code, plus[j].code);
+ if (pairs == max_pairs) return;
+ pairs += 1;
+ scratch.reset();
+ const pair = scratch.allocator();
+ var alignment = Alignment.init(pair, m_tokens, p_tokens) catch continue;
+ const marks = annotate(pair, &alignment, m.code, plus[j].code) catch continue;
if (marks.distance > max_line_distance) continue;
for (marks.minus) |r| for (m.styles[r[0]..r[1]]) |*b| {
b.* |= syntax.diff_emph;
diff --git a/src/image.zig b/src/image.zig
index 8bf9de08..5797ce9e 100644
--- a/src/image.zig
+++ b/src/image.zig
@@ -768,7 +768,13 @@ pub fn readable(bytes: []const u8) bool {
/// decode + downscale to RGBA, gpa-owned. Returns null on any failure — the
/// pane then simply shows a blank body.
pub fn decode(gpa: std.mem.Allocator, bytes: []const u8) ?struct { rgba: []u8, w: usize, h: usize } {
- if (bytes.len == 0) return null;
+ if (bytes.len == 0 or bytes.len > std.math.maxInt(c_int)) return null;
+ // Bounded before decoding: a few KB of PNG can name gigapixels.
+ var iw: c_int = 0;
+ var ih: c_int = 0;
+ var ic: c_int = 0;
+ if (stbi_info_from_memory(bytes.ptr, @intCast(bytes.len), &iw, &ih, &ic) != 1) return null;
+ if (@as(usize, @intCast(@max(0, iw))) * @as(usize, @intCast(@max(0, ih))) > @import("memory.zig").limits.image_decode_pixels) return null;
var img = zstbi.Image.loadFromMemory(bytes, 4) catch return null; // 4 = RGBA
defer img.deinit();
var scaled: ?zstbi.Image = null;
diff --git a/src/locations.zig b/src/locations.zig
index 2828566d..1e4a20cf 100644
--- a/src/locations.zig
+++ b/src/locations.zig
@@ -217,6 +217,98 @@ pub fn treeContinuation(line: []const u8, buffer: []u8, max_cells: usize) []cons
return out.buffered()[0..end];
}
+const Resolved = struct { code: []const u8 = "", colors: []const u8 = &.{}, source_row: usize = 0 };
+
+/// Each Callstack row's code (its call site's line, or a caller's header) and
+/// colors, by input line. A page spans thousands of files, so they are taken
+/// a file at a time: grouped by path, each file read, line-indexed and
+/// analyzed once, its rows' code and colors copied out, and the file let go
+/// before the next. Row by row, the cache compared the whole source each
+/// time and past its 64 entries parsed it again, every lookup walked the
+/// file from its top, and every source stayed in the arena to the end.
+fn resolveCallstack(p: *pardes.Pardes, arena: std.mem.Allocator, dir: []const u8, input: []const u8) ![]Resolved {
+ const mark = @import("lsp/lsp.zig").callstack_match;
+ var all: std.ArrayList([]const u8) = .empty;
+ var by_path: std.StringArrayHashMapUnmanaged(std.ArrayList(u32)) = .empty;
+ var lines = std.mem.splitScalar(u8, std.mem.trimEnd(u8, input, "\n"), '\n');
+ while (lines.next()) |raw| {
+ const line = if (std.mem.startsWith(u8, raw, mark)) raw[mark.len..] else raw;
+ const index: u32 = @intCast(all.items.len);
+ try all.append(arena, line);
+ const target = parseRaw(line[treePrefix(line).end..]);
+ if (target.at.line == 0) continue;
+ const entry = try by_path.getOrPut(arena, target.path);
+ if (!entry.found_existing) entry.value_ptr.* = .empty;
+ try entry.value_ptr.append(arena, index);
+ }
+ const resolved = try arena.alloc(Resolved, all.items.len);
+ @memset(resolved, .{});
+ var file_arena: std.heap.ArenaAllocator = .init(p.gpa);
+ defer file_arena.deinit();
+ for (by_path.keys(), by_path.values()) |path, indexes| {
+ _ = file_arena.reset(.retain_capacity);
+ const fa = file_arena.allocator();
+ const source = sourceText(p, fa, dir, path);
+ var cached: Cache.Hit = .{ .analysis = .{} };
+ defer cached.deinit(p.tree_sitter_gpa);
+ // Where each line starts, the file's length closing the last.
+ var starts: std.ArrayList(usize) = .empty;
+ if (source) |text| {
+ cached = p.locations_cache.get(p.tree_sitter_gpa, text.path, text.bytes, true, true) catch .{ .analysis = .{} };
+ try starts.append(fa, 0);
+ var at: usize = 0;
+ while (std.mem.indexOfScalarPos(u8, text.bytes, at, '\n')) |nl| : (at = nl + 1) try starts.append(fa, nl + 1);
+ }
+ for (indexes.items) |index| {
+ const line = all.items[index];
+ const prefix = treePrefix(line);
+ const target = parseRaw(line[prefix.end..]);
+ var code = line[prefix.end + target.code_start ..];
+ var colors: []const u8 = &.{};
+ var source_row = target.at.line - 1;
+ if (source) |text| {
+ const row = target.at.line - 1;
+ if (prefix.branch) {
+ // Choose the innermost header containing the server's name range.
+ var chosen: ?syntax.ContextDeclaration = null;
+ for (cached.analysis.declarations) |declaration| {
+ if (declaration.start_line <= row and row <= declaration.header_end_line) {
+ if (chosen == null or declaration.end_byte - declaration.start_byte < chosen.?.end_byte - chosen.?.start_byte)
+ chosen = declaration;
+ }
+ }
+ if (chosen) |header| {
+ code = text.bytes[header.start_byte..header.header_end_byte];
+ source_row = header.start_line;
+ } else {
+ const fallback = indexedLine(text.bytes, starts.items, row);
+ if (fallback.len > 0) code = fallback;
+ }
+ } else if (code.len == 0) {
+ // A call site the language worker sent bare (it reads no
+ // sources for Callstack): its line, from the source here.
+ code = indexedLine(text.bytes, starts.items, row);
+ }
+ const offset = if (source_row < starts.items.len) starts.items[source_row] else text.bytes.len;
+ if (offset + code.len <= cached.analysis.colors.len and
+ std.mem.eql(u8, code, text.bytes[offset..][0..code.len]))
+ colors = cached.analysis.colors[offset..][0..code.len];
+ code = try arena.dupe(u8, code);
+ colors = try arena.dupe(u8, colors);
+ }
+ resolved[index] = .{ .code = code, .colors = colors, .source_row = source_row };
+ }
+ }
+ return resolved;
+}
+
+/// modal.lineSlice through a line index (`starts`, as resolveCallstack builds it).
+fn indexedLine(text: []const u8, starts: []const usize, row: usize) []const u8 {
+ if (row >= starts.len or starts[row] >= text.len) return "";
+ const end = if (row + 1 < starts.len) starts[row + 1] - 1 else text.len;
+ return text[starts[row]..end];
+}
+
/// Enrich caller nodes on the UI thread, using the same source/declaration cache
/// as LocationsContext. The LSP worker only supplies relationships and addresses.
pub fn formatCallstack(p: *pardes.Pardes, dir: []const u8, input: []const u8) !Result {
@@ -232,9 +324,10 @@ pub fn formatCallstack(p: *pardes.Pardes, dir: []const u8, input: []const u8) !R
rows.deinit(p.gpa);
}
const stacked = p.settings.callstack_layout == .stacked;
- var sources: std.StringHashMap(?Source) = .init(arena);
+ const resolved = try resolveCallstack(p, arena, dir, input);
var lines = std.mem.splitScalar(u8, std.mem.trimEnd(u8, input, "\n"), '\n');
- while (lines.next()) |raw| {
+ var index: usize = 0;
+ while (lines.next()) |raw| : (index += 1) {
const mark = @import("lsp/lsp.zig").callstack_match;
const focus = std.mem.startsWith(u8, raw, mark);
const line = if (focus) raw[mark.len..] else raw;
@@ -245,41 +338,9 @@ pub fn formatCallstack(p: *pardes.Pardes, dir: []const u8, input: []const u8) !R
try appendMetadata(p.gpa, &rows, .{ .path = "", .at = .{}, .label = "", .code = "", .original = null }, .context, 0, line.len, false);
continue;
}
- const entry = try sources.getOrPut(target.path);
- if (!entry.found_existing) entry.value_ptr.* = sourceText(p, arena, dir, target.path);
- const source = entry.value_ptr.*;
- var cached: Cache.Hit = .{ .analysis = .{} };
- defer cached.deinit(p.tree_sitter_gpa);
- if (source) |text| cached = p.locations_cache.get(p.tree_sitter_gpa, text.path, text.bytes, true, true) catch .{ .analysis = .{} };
- var code = line[prefix.end + target.code_start ..];
- var colors: []const u8 = &.{};
- var source_row = target.at.line - 1;
- if (source) |text| {
- const row = target.at.line - 1;
- if (prefix.branch) {
- // Choose the innermost header containing the server's name range.
- var chosen: ?syntax.ContextDeclaration = null;
- for (cached.analysis.declarations) |declaration| {
- if (declaration.start_line <= row and row <= declaration.header_end_line) {
- if (chosen == null or declaration.end_byte - declaration.start_byte < chosen.?.end_byte - chosen.?.start_byte)
- chosen = declaration;
- }
- }
- if (chosen) |header| {
- code = text.bytes[header.start_byte..header.header_end_byte];
- source_row = header.start_line;
- } else {
- const fallback = @import("modal.zig").lineSlice(text.bytes, row);
- if (fallback.len > 0) code = fallback;
- }
- }
- {
- const offset = @import("modal.zig").lineStartOffset(text.bytes, source_row);
- if (offset + code.len <= cached.analysis.colors.len and
- std.mem.eql(u8, code, text.bytes[offset..][0..code.len]))
- colors = cached.analysis.colors[offset..][0..code.len];
- }
- }
+ const code = resolved[index].code;
+ const colors = resolved[index].colors;
+ var source_row = resolved[index].source_row;
const recursion = prefix.branch and std.mem.endsWith(u8, line, " ↻ recursion");
const first_line = code[0 .. std.mem.indexOfScalar(u8, code, '\n') orelse code.len];
const source_indent = if (stacked) first_line.len - std.mem.trimStart(u8, first_line, " \t").len else 0;
diff --git a/src/look.zig b/src/look.zig
index f4fbe52e..02754fff 100644
--- a/src/look.zig
+++ b/src/look.zig
@@ -587,6 +587,10 @@ fn lookFirstHit(p: *Pardes, id: usize) void {
/// Fills the results buffer, and answers how many rows a text or PDF
/// search found (0 for Find and Grep, which do not count). With
/// `open_empty` false a text search that found nothing opens no buffer.
+/// A search of one pane's text (or its PDF) writes at most this many bytes
+/// of rows: past it, the rows stop and say where.
+pub const search_text_output_bytes = 16 << 20;
+
pub fn runSearch(p: *Pardes, id: usize, pat_raw: []const u8, kind: Search, start: SearchStart, open_empty: bool) !usize {
const pane = p.panes[id] orelse return 0;
// Blanks at either end are the pattern's (a look of an indented line);
@@ -598,7 +602,9 @@ pub fn runSearch(p: *Pardes, id: usize, pat_raw: []const u8, kind: Search, start
// root, and the directory the results buffer is named in. From a
// column's or the workspace's tag, the session's.
const dir = if (p.exec_header) p.sessionDir() else Pardes.paneDir(pane);
- const out = try arena.alloc(u8, filesystem.search_max_output_bytes);
+ // As much as the search can write and no more: a root's hits for each
+ // root Grep walks, one for Find, `search_text_output_bytes` in a pane.
+ var out: []u8 = &.{};
var out_len: usize = 0;
var nrows: usize = 0;
var anchor: ?usize = null;
@@ -631,6 +637,7 @@ pub fn runSearch(p: *Pardes, id: usize, pat_raw: []const u8, kind: Search, start
roots[nroots] = d;
nroots += 1;
}
+ out = try @import("memory.zig").unfilled(arena, @max(1, nroots) * filesystem.search_root_output_bytes);
// A pane's directory that is not there (a scratch named into one
// not made yet, a peer's) has nothing to grep: passed over, not the
// search's failure.
@@ -641,9 +648,11 @@ pub fn runSearch(p: *Pardes, id: usize, pat_raw: []const u8, kind: Search, start
};
nrows = std.mem.count(u8, out[0..out_len], "\n");
} else if (kind == .find) {
+ out = try @import("memory.zig").unfilled(arena, filesystem.search_root_output_bytes);
out_len = try filesystem.find(arena, dir, pat, out, &notes);
nrows = std.mem.count(u8, out[0..out_len], "\n");
} else if (pane.hasPdf()) {
+ out = try @import("memory.zig").unfilled(arena, search_text_output_bytes);
if (comptime pdf_enabled) {
const found = try panes.Pdf.searchRows(
&pane.pdf.?,
@@ -658,6 +667,7 @@ pub fn runSearch(p: *Pardes, id: usize, pat_raw: []const u8, kind: Search, start
anchor = found.anchor;
}
} else {
+ out = try @import("memory.zig").unfilled(arena, search_text_output_bytes);
const lines = try edit.paneCursorLines(p, &pane.body);
// a real file names itself; a terminal or an output buffer has no path
const has_path = if (pane.file) |f| f.output == null else false;
@@ -675,7 +685,10 @@ pub fn runSearch(p: *Pardes, id: usize, pat_raw: []const u8, kind: Search, start
const row = try std.fmt.allocPrint(arena, "{s}:{d}:{d}{c}{d} {s}\n", .{
loc, i + 1, at + 1, config.range_sep, at + pat.len, std.mem.trimEnd(u8, ln, " \t"),
});
- if (row.len > out.len - out_len) break;
+ if (row.len > out.len - out_len) {
+ notes.rows_cut = nrows;
+ break;
+ }
if (start == .cursor and (i < cl or (i == cl and at <= cc))) anchor = nrows;
@memcpy(out[out_len..][0..row.len], row);
out_len += row.len;
@@ -1451,6 +1464,7 @@ fn lookUnresolved(p: *Pardes, id: usize, pane: *Pane, trimmed: []const u8, text:
// 9P is no keyboard input, and searches whatever the key mode.
if (pane.image != null or (pane.body.mode == .tty and !p.fs.serving)) return;
if (text.len == 0) return;
+ if (lookCommit(p, id, pane, trimmed)) return;
if (p.settings.look_word == .search and pane.file != null) return lookWord(p, id, pane, text);
p.word_look = true;
defer p.word_look = false;
@@ -1471,6 +1485,49 @@ fn lookUnresolved(p: *Pardes, id: usize, pane: *Pane, trimmed: []const u8, text:
}
}
+/// A commit hash (7 to 40 hex digits, a letter and a digit among them)
+/// looked at inside a git repository: `git show` it, paged into a +Pager,
+/// which stacks its hunks in a +Diff (ctl.fillPager); the command pane
+/// goes when it succeeds (exec.commandDone).
+// ponytail: a hex word that names no commit leaves git's error in a command pane, not a search; check the object first if that bites.
+fn lookCommit(p: *Pardes, id: usize, pane: *Pane, word: []const u8) bool {
+ if (comptime !pardes.hosted) return false;
+ if (!isCommitHash(word)) return false;
+ var dir = filesystem.localPath(Pardes.paneDir(pane)) orelse return false;
+ while (true) {
+ var buf: [4096]u8 = undefined;
+ const dot_git = std.fmt.bufPrint(&buf, "{s}/.git", .{dir}) catch return false;
+ if (exec.kindOf(dot_git) != null) break;
+ dir = std.fs.path.dirname(dir) orelse return false;
+ }
+ var line: [64]u8 = undefined;
+ const dst = exec.execute(p, id, std.fmt.bufPrint(&line, "git show {s}", .{word}) catch return false) orelse return true;
+ if (p.panes[dst]) |c| c.command_pages = true;
+ return true;
+}
+
+fn isCommitHash(word: []const u8) bool {
+ if (word.len < 7 or word.len > 40) return false;
+ var digit = false;
+ var letter = false;
+ for (word) |c| switch (c) {
+ '0'...'9' => digit = true,
+ 'a'...'f' => letter = true,
+ else => return false,
+ };
+ return digit and letter;
+}
+
+test "a commit hash is 7 to 40 lowercase hex digits with a letter and a digit" {
+ try std.testing.expect(isCommitHash("9bffa7041c"));
+ try std.testing.expect(isCommitHash("9bffa7041cd2e8a0b6b1f7c3e4d5a6b7c8d9e0f1"));
+ try std.testing.expect(!isCommitHash("9bffa7"));
+ try std.testing.expect(!isCommitHash("defaced"));
+ try std.testing.expect(!isCommitHash("1234567"));
+ try std.testing.expect(!isCommitHash("0x9bffa7041c"));
+ try std.testing.expect(!isCommitHash("9BFFA7041C"));
+}
+
/// Opens (or finds) `path` as Look would, `id`'s own pane when it is empty,
/// and selects what `expr` addresses there from its dot. An address that
/// does not evaluate moves nothing and says why (acme: no jump).
diff --git a/src/lsp/lsp.zig b/src/lsp/lsp.zig
index 4a70efe5..1c1b57a2 100644
--- a/src/lsp/lsp.zig
+++ b/src/lsp/lsp.zig
@@ -26,6 +26,10 @@ pub const Kind = enum {
};
pub const callstack_match = "@callstack-match ";
+/// The last row of a Callstack page that stopped full: `<path> <callers>`,
+/// the entry indices from the top the next page starts at (`3.0.17`), and
+/// how many callers this page holds.
+pub const callstack_more = "@callstack-more ";
pub const CallstackCorners = enum { rounded, square };
pub const callstack_default_depth: u8 = 8;
pub const callstack_max_depth: u8 = 64;
@@ -46,6 +50,9 @@ pub const Req = struct {
/// For `explain`: the query it narrates, read from `arg` (`<kind>
/// <arg>`) by `explaining`; a definition when none was asked before.
explains: Kind = .definition,
+ /// The fixed region `arena` allocates from, when it is one: a walk that
+ /// can grow (Callstack) reads how much is left and stops in time.
+ budget: ?*const std.heap.FixedBufferAllocator = null,
};
pub const Doc = struct { path: []const u8, source: [:0]const u8 };
@@ -102,18 +109,18 @@ pub fn speaks(path: []const u8) bool {
return false;
}
-pub fn query(gpa: std.mem.Allocator, arena: std.mem.Allocator, req: Req, out: *std.Io.Writer) !void {
+pub fn query(io: std.Io, gpa: std.mem.Allocator, arena: std.mem.Allocator, req: Req, out: *std.Io.Writer) !void {
if (req.kind == .status) {
try out.print("backend: {s}\n", .{backend_name});
- inline for (backends) |b| try b.query(gpa, arena, req, out);
+ inline for (backends) |b| try b.query(io, gpa, arena, req, out);
return;
}
inline for (backends) |b| {
if (b.speaks(req.path) and b.supports.contains(req.kind))
- return b.query(gpa, arena, req, out);
+ return b.query(io, gpa, arena, req, out);
}
if (req.kind == .explain and backends.len > 0)
- return backends[0].query(gpa, arena, req, out);
+ return backends[0].query(io, gpa, arena, req, out);
// Nothing asked: said why, where an empty answer would read as nothing
// found.
inline for (backends) |b| if (b.speaks(req.path))
@@ -217,6 +224,6 @@ test "a question no backend answers for a file says why rather than find nothing
var buf: [256]u8 = undefined;
var out: std.Io.Writer = .fixed(&buf);
// A file no server speaks for is answered, not left empty.
- try query(std.testing.allocator, arena.allocator(), .{ .kind = .incoming_calls, .path = "/x/notes.txt", .source = "", .offset = 0 }, &out);
+ try query(std.testing.io, std.testing.allocator, arena.allocator(), .{ .kind = .incoming_calls, .path = "/x/notes.txt", .source = "", .offset = 0 }, &out);
try std.testing.expectStringStartsWith(out.buffered(), "@none ");
}
diff --git a/src/lsp/lsp_client.zig b/src/lsp/lsp_client.zig
index b396879b..e356c979 100644
--- a/src/lsp/lsp_client.zig
+++ b/src/lsp/lsp_client.zig
@@ -8,9 +8,10 @@
//! worker thread, and a language server costs tens of milliseconds to start
//! and MINUTES to index a large workspace. So a server is spawned lazily on
//! the first query that needs it, kept for the life of the editor, and each
-//! spec gets at most one — `conns[i]` guards itself with a pthread mutex
-//! because the gui shell detaches its workers and a superseded query can still
-//! be inside `run` when the next arrives.
+//! spec gets at most one — `conns[i]` guards itself with an `Io.Mutex`
+//! because a canceled query can still be inside `run` when the next arrives.
+//! Every wait is an `Io` cancelation point: a shell cancels the worker of a
+//! query it no longer wants, and the worker stops there.
//!
//! ONE READER THREAD PER SERVER, and it is not optional. The first design
//! pumped the socket only while a query waited, which works for a server that
@@ -28,7 +29,8 @@
//! under a thread still polling it.
//!
//! Nothing here may wedge the editor:
-//! - every write and every mailbox wait is bounded by a deadline,
+//! - every write is bounded by a deadline, and every mailbox wait by a
+//! deadline or, while the server narrates progress, by cancelation,
//! - a query the server does not answer in time returns no rows and sends
//! `$/cancelRequest`; the server is NOT killed for being busy (an indexing
//! server is busy for minutes and the status row says so) — but three
@@ -58,20 +60,10 @@ extern "c" fn access(path: [*:0]const u8, mode: c_int) c_int;
extern "c" fn getenv(name: [*:0]const u8) ?[*:0]const u8;
extern "c" fn usleep(usec: c_uint) c_int;
extern "c" fn atexit(f: *const fn () callconv(.c) void) c_int;
-extern "c" fn realpath(path: [*:0]const u8, resolved: [*]u8) ?[*:0]u8;
// test-only libc (the seam's own tests build a real directory tree)
extern "c" fn mkdtemp(template: [*:0]u8) ?[*:0]u8;
extern "c" fn mkdir(path: [*:0]const u8, mode: libc.mode_t) c_int;
extern "c" fn system(cmd: [*:0]const u8) c_int;
-// pthread condattr surface, absent from std.c: what makes the mailbox waits
-// tick on CLOCK_MONOTONIC (linux) or a relative timeout (darwin).
-const pthread_condattr_t = extern struct { data: [8]u8 align(@alignOf(usize)) = @splat(0) };
-extern "c" fn pthread_condattr_init(attr: *pthread_condattr_t) c_int;
-extern "c" fn pthread_condattr_setclock(attr: *pthread_condattr_t, clock: c_int) c_int;
-extern "c" fn pthread_condattr_destroy(attr: *pthread_condattr_t) c_int;
-extern "c" fn pthread_cond_init(cond: *libc.pthread_cond_t, attr: ?*const pthread_condattr_t) c_int;
-extern "c" fn pthread_cond_timedwait_relative_np(cond: *libc.pthread_cond_t, mutex: *libc.pthread_mutex_t, reltime: *const libc.timespec) c_int;
-const CLOCK_MONOTONIC: c_int = 1; // linux ABI; the setclock call is linux-only
const X_OK: c_int = 1;
const POLLIN: i16 = 0x001;
@@ -182,21 +174,35 @@ fn specFor(path: []const u8) ?usize {
return null;
}
-// Deadlines. Requests are bounded because tty.zig cancels-and-joins the
-// previous worker on a new keypress, so the worst UI stall a wedged wait can
-// cause is one req_ms. Timeouts do NOT kill the server — an indexing
-// rust-analyzer legitimately sits on a `gd` for longer than anyone will wait,
-// and the message row is already narrating why.
+// Deadlines. A shell cancels-and-joins the previous worker on a new query,
+// and its waits are cancelation points: so a request needs no deadline to
+// keep the editor responsive, and waits for its answer. Past req_ms the
+// message row says the server is still at it; only a server silent and idle
+// (no $/progress) for wedge_ms has failed to answer. Timeouts do NOT kill the
+// server — an indexing rust-analyzer legitimately sits on a `gd` for minutes.
+// The handshake runs protected from cancelation, so it keeps its deadline.
const init_ms = 8_000; // spawn + initialize handshake
-const req_ms = 4_000; // one request/response round trip
+const req_ms = 4_000; // a request past this is said to be still working
+const wedge_ms = 300_000; // silent and idle this long: not answering (rust-analyzer takes ~1 min on `default`'s callers in agave)
const diag_ms = 1_200; // wait for a publishDiagnostics push after didChange
const reply_ms = 2_000; // our answers to server-to-client requests
+const reply_queue_bytes = 64 << 10; // replies waiting for the socket (Conn.replies)
+const parse_kept = 1 << 20; // what the reader's parse arena keeps between messages
+const max_diag_files = 256; // files a server's pushed diagnostics are kept for
+const max_diag_bytes = 32 << 20; // and their bytes
const wedged_strikes = 3; // consecutive timeouts before a restart
-const max_rows = 2000;
+/// Rows one answer may hold, and its writer's bytes: carved from the query's
+/// fixed region (memory.limits.arena.lsp_query) with the rest of its memory.
+const max_rows = 100_000;
+/// What a Callstack walk leaves of its query's region for rendering the
+/// tree it found: past this it stops and says so.
+const callstack_reserve = 32 << 20;
+/// What rendering leaves of the answer's writer for its closing line.
+const row_room = 4096;
const max_doc_bytes = 8 << 20;
-const Err = error{ Dead, Timeout, Protocol, OutOfMemory, NoServer, Backoff, WriteFailed };
+const Err = error{ Dead, Timeout, Protocol, OutOfMemory, NoServer, Backoff, WriteFailed, Canceled };
/// Long-lived state outlives every query arena and cannot borrow the caller's
/// gpa (a different one shows up in the harness than in the shell), so
@@ -251,8 +257,22 @@ const State = enum(u8) {
};
const Conn = struct {
- mu: libc.pthread_mutex_t = .{},
- cond: libc.pthread_cond_t = .{},
+ mu: std.Io.Mutex = .init,
+ cond: std.Io.Condition = .init,
+ /// Frames go out whole: a query's requests and the reader's replies
+ /// share the socket, and interleaved halves are a parse error that ends
+ /// the server.
+ write_mu: std.Io.Mutex = .init,
+ /// Replies the reader made while a query's write held the socket, sent
+ /// by that writer once its own message is out (releaseWrite): the reader
+ /// never waits to write, since a server blocked on its output reads
+ /// nothing more of ours.
+ /// Two halves: the reader appends to `replies[filling]`, and the writer
+ /// flips them and sends the other, with no copy and no wait.
+ replies: [2][reply_queue_bytes]u8 = undefined,
+ replies_len: [2]usize = .{ 0, 0 },
+ filling: u1 = 0,
+ replies_mu: std.Io.Mutex = .init,
state: State = .off,
/// bumped per spawn. A reader thread that sees a different gen than its
/// own is reading a corpse and exits; a waiter that sees one stops waiting.
@@ -264,9 +284,6 @@ const Conn = struct {
/// monotonic ms when the last handshake completed — a crash shortly
/// after "ready" counts as a handshake failure for backoff purposes
ready_at_ms: i64 = 0,
- /// linux: the zeroed condvar defaults to REALTIME; re-initialized with a
- /// monotonic condattr before its first wait (under the mutex)
- cond_monotonic: bool = false,
timeouts: u8 = 0,
pid: libc.pid_t = -1,
sock: c_int = -1,
@@ -278,6 +295,8 @@ const Conn = struct {
extra_roots: std.ArrayList([]u8) = .empty,
docs: std.ArrayList(Doc) = .empty,
diags: std.ArrayList(DiagSet) = .empty,
+ /// The bytes `diags` holds, kept under max_diag_bytes.
+ diag_bytes: usize = 0,
/// the response mailbox: one request outstanding per connection
want_id: u32 = 0,
resp: ?[]u8 = null,
@@ -285,13 +304,12 @@ const Conn = struct {
progress: i32 = 0,
title: [48]u8 = @splat(0),
title_len: u8 = 0,
+ /// The server says it is still loading its workspace (rust-analyzer's
+ /// serverStatus, not quiescent): an empty answer now is not one.
+ loading: bool = false,
+ /// its index in `conns`, for what it posts
+ si: usize = 0,
- fn lock(c: *Conn) void {
- _ = libc.pthread_mutex_lock(&c.mu);
- }
- fn unlock(c: *Conn) void {
- _ = libc.pthread_mutex_unlock(&c.mu);
- }
fn alive(c: *const Conn) bool {
return c.state == .starting or c.state == .ready;
}
@@ -406,10 +424,10 @@ const Trace = struct {
// ------------------------------------------------------------------- query
-pub fn query(gpa: std.mem.Allocator, arena: std.mem.Allocator, asked: lsp.Req, out: *std.Io.Writer) !void {
+pub fn query(io: std.Io, gpa: std.mem.Allocator, arena: std.mem.Allocator, asked: lsp.Req, out: *std.Io.Writer) !void {
_ = gpa;
const req = lsp.explaining(asked);
- if (req.kind == .status) return status(req, out);
+ if (req.kind == .status) return status(io, req, out);
var tr: Trace = .{ .on = req.kind == .explain };
const si = specFor(req.path) orelse {
@@ -421,13 +439,14 @@ pub fn query(gpa: std.mem.Allocator, arena: std.mem.Allocator, asked: lsp.Req, o
};
tr.note("file {s} -> {s} (languageId {s})", .{ std.fs.path.basename(req.path), specs[si].name, specs[si].lang });
- const scratch_buf = try arena.alloc(u8, max_rows * 512);
+ // Raw: `alloc` fills a safe build's new memory, all 51 MB of it, per query.
+ const scratch_buf = (arena.rawAlloc(max_rows * 512, .of(u8), @returnAddress()) orelse return error.OutOfMemory)[0 .. max_rows * 512];
var scratch: std.Io.Writer = .fixed(scratch_buf);
const t0 = nowUs();
var err_name: []const u8 = "";
var failure: ?anyerror = null;
- answer(arena, si, req, &scratch, &tr) catch |e| {
+ answer(io, arena, si, req, &scratch, &tr) catch |e| {
failure = e;
err_name = @errorName(e);
tr.note("ERROR: {s}", .{err_name});
@@ -443,9 +462,9 @@ pub fn query(gpa: std.mem.Allocator, arena: std.mem.Allocator, asked: lsp.Req, o
// again, not that it is not there.
if (failure) |err| if (err == error.Backoff) {
const c = &conns[si];
- c.lock();
+ c.mu.lockUncancelable(io);
const left_ms = c.retry_after_ms -| nowMs();
- c.unlock();
+ c.mu.unlock(io);
return lsp.none(out, "{s} failed recently; retry in {d}s", .{ specs[si].name, @divFloor(left_ms + 999, 1000) });
};
if (failure) |err| return err;
@@ -464,17 +483,34 @@ fn traceOut(tr: *const Trace, req: lsp.Req, out: *std.Io.Writer, rows: usize, us
try out.print("\n{d} row(s) in {d}us\n", .{ rows, us });
}
-fn answer(arena: std.mem.Allocator, si: usize, req: lsp.Req, out: *std.Io.Writer, tr: *Trace) Err!void {
+fn answer(io: std.Io, arena: std.mem.Allocator, si: usize, req: lsp.Req, out: *std.Io.Writer, tr: *Trace) Err!void {
const c = &conns[si];
- c.lock();
- defer c.unlock();
- const g = try ensure(c, si, arena, req, tr);
- run(c, si, arena, req, out, tr) catch |e| {
+ try c.mu.lock(io);
+ defer c.mu.unlock(io);
+ const g = try ensure(c, io, si, arena, req, tr);
+ const before = out.end;
+ try attempt(c, io, si, arena, req, out, tr, g);
+ // A server still loading its workspace answers at once, with nothing
+ // (rust-analyzer before its index): that is no answer. Wait until it says
+ // it is loaded, the message row saying so, and ask again.
+ const answered = out.buffered()[before..];
+ if (c.loading and c.gen == g and (answered.len == 0 or std.mem.startsWith(u8, answered, "@none "))) {
+ tr.note("{s} is still loading: waiting for it, then asking again", .{specs[si].name});
+ post(si, .always, "{s} is still loading the workspace; the answer comes when it is done\u{2026}", .{specs[si].name});
+ while (c.loading and c.gen == g and c.alive()) _ = try timedWait(c, io, nowMs() + 500);
+ out.end = before;
+ try attempt(c, io, si, arena, req, out, tr, g);
+ }
+}
+
+/// One run of a query, and what its failure says of the server.
+fn attempt(c: *Conn, io: std.Io, si: usize, arena: std.mem.Allocator, req: lsp.Req, out: *std.Io.Writer, tr: *Trace, g: u32) Err!void {
+ run(c, io, si, arena, req, out, tr) catch |e| {
switch (e) {
// transport-level: this server is gone; forget it, and the next
// query respawns. Gen-checked so a respawn that happened while we
// waited is not the one we kill.
- error.Dead, error.Protocol => shutdownIf(c, g),
+ error.Dead, error.Protocol => shutdownIf(c, io, g),
error.Timeout => {
// Slow is only wedged when the server is IDLE. One with
// active `$/progress` work (rust-analyzer running cargo
@@ -487,18 +523,19 @@ fn answer(arena: std.mem.Allocator, si: usize, req: lsp.Req, out: *std.Io.Writer
c.timeouts +|= 1;
if (c.timeouts >= wedged_strikes and c.gen == g) {
post(si, .always, "{s} not answering — restarting", .{specs[si].name});
- shutdownIf(c, g);
+ shutdownIf(c, io, g);
}
}
},
- error.OutOfMemory, error.NoServer, error.Backoff, error.WriteFailed => {},
+ // Canceled: the shell asked something newer, not a wedged server.
+ error.OutOfMemory, error.NoServer, error.Backoff, error.WriteFailed, error.Canceled => {},
}
return e;
};
c.timeouts = 0;
}
-fn run(c: *Conn, si: usize, arena: std.mem.Allocator, req: lsp.Req, out: *std.Io.Writer, tr: *Trace) Err!void {
+fn run(c: *Conn, io: std.Io, si: usize, arena: std.mem.Allocator, req: lsp.Req, out: *std.Io.Writer, tr: *Trace) Err!void {
// `explain` narrates the last query asked (a definition, `gd`, when
// none was) — dispatch below on the effective kind so the trace
// follows the code that query really runs.
@@ -510,18 +547,18 @@ fn run(c: *Conn, si: usize, arena: std.mem.Allocator, req: lsp.Req, out: *std.Io
var uri: std.ArrayList(u8) = .empty;
try uriOf(&uri, arena, req.path);
- try syncDoc(c, si, arena, uri.items, req.source);
+ try syncDoc(c, io, si, arena, uri.items, req.source);
// Every other open file this server answers for, before a query whose
// answer reaches them: zls renames only in the documents it has.
if (lsp.reachesOtherFiles(kind)) for (req.others) |doc| if (specFor(doc.path) == si and !std.mem.eql(u8, doc.path, req.path)) {
var other: std.ArrayList(u8) = .empty;
try uriOf(&other, arena, doc.path);
- try syncDoc(c, si, arena, other.items, doc.source);
+ try syncDoc(c, io, si, arena, other.items, doc.source);
tr.note("synced {s} first", .{std.fs.path.basename(doc.path)});
};
const pos = posOf(req.source, req.offset, c.caps.enc);
- var cx: Cx = .{ .arena = arena, .base = req.root, .cur_path = req.path, .cur_src = req.source, .out = out, .relative_parents = req.kind == .callstack, .callstack_corners = req.callstack_corners };
+ var cx: Cx = .{ .arena = arena, .base = req.root, .cur_path = req.path, .cur_src = req.source, .out = out, .fixed_out = true, .relative_parents = req.kind == .callstack, .callstack_corners = req.callstack_corners };
for (req.others) |doc| try cx.files.append(arena, .{ .path = doc.path, .text = doc.source });
tr.note("server {s} (pid {d}), root {s}, {s} columns", .{
@tagName(c.state), c.pid, c.root, @tagName(c.caps.enc),
@@ -540,7 +577,7 @@ fn run(c: *Conn, si: usize, arena: std.mem.Allocator, req: lsp.Req, out: *std.Io
var b = try atPos(arena, uri.items, pos);
if (kind == .references) try app(&b, arena, ",\"context\":{\"includeDeclaration\":true}");
tr.note("-> {s} @ {d}:{d}", .{ method, pos.line + 1, pos.ch + 1 });
- const result = (try call(c, arena, method, b.items, deadline)) orelse {
+ const result = (try call(c, io, arena, method, b.items, deadline)) orelse {
tr.note("<- empty (no result, an error response, or null)", .{});
return;
};
@@ -549,12 +586,12 @@ fn run(c: *Conn, si: usize, arena: std.mem.Allocator, req: lsp.Req, out: *std.Io
},
.select_refs => {
const b = try atPos(arena, uri.items, pos);
- const result = (try call(c, arena, "textDocument/documentHighlight", b.items, deadline)) orelse return;
+ const result = (try call(c, io, arena, "textDocument/documentHighlight", b.items, deadline)) orelse return;
for (items(result)) |h| try emitRange(&cx, c.caps.enc, uri.items, get(h, "range"), "");
},
.hover => {
const b = try atPos(arena, uri.items, pos);
- const result = (try call(c, arena, "textDocument/hover", b.items, deadline)) orelse return;
+ const result = (try call(c, io, arena, "textDocument/hover", b.items, deadline)) orelse return;
const contents = get(result, "contents") orelse return;
const text = str(contents) orelse str(get(contents, "value")) orelse blk: {
for (items(contents)) |m| if (str(m) orelse str(get(m, "value"))) |t| break :blk t;
@@ -569,26 +606,26 @@ fn run(c: *Conn, si: usize, arena: std.mem.Allocator, req: lsp.Req, out: *std.Io
try app(&b, arena, "\"textDocument\":{\"uri\":");
try jstr(&b, arena, uri.items);
try app(&b, arena, "}");
- const result = (try call(c, arena, "textDocument/documentSymbol", b.items, deadline)) orelse return;
+ const result = (try call(c, io, arena, "textDocument/documentSymbol", b.items, deadline)) orelse return;
try walkSymbols(&cx, c.caps.enc, uri.items, result, 0);
},
.workspace_symbols => {
var b: std.ArrayList(u8) = .empty;
try app(&b, arena, "\"query\":");
try jstr(&b, arena, req.arg);
- const result = (try call(c, arena, "workspace/symbol", b.items, deadline)) orelse return;
+ const result = (try call(c, io, arena, "workspace/symbol", b.items, deadline)) orelse return;
for (items(result)) |sym| {
const loc = get(sym, "location") orelse continue;
try emitRange(&cx, c.caps.enc, str(get(loc, "uri")) orelse continue, get(loc, "range"), str(get(sym, "name")) orelse "");
}
},
- .diagnostics => try diagnostics(c, arena, &cx, uri.items, deadline),
- .workspace_diagnostics => try workspaceDiagnostics(c, arena, &cx, deadline),
+ .diagnostics => try diagnostics(c, io, arena, &cx, uri.items, deadline),
+ .workspace_diagnostics => try workspaceDiagnostics(c, io, arena, &cx, deadline),
.rename => {
var b = try atPos(arena, uri.items, pos);
try app(&b, arena, ",\"newName\":");
try jstr(&b, arena, req.arg);
- const result = (try call(c, arena, "textDocument/rename", b.items, deadline)) orelse return;
+ const result = (try call(c, io, arena, "textDocument/rename", b.items, deadline)) orelse return;
// Other open files that say the old name, should the server
// answer for this file alone (zls renaming at a declaration does,
// whatever it was told): applied here, they would no longer build.
@@ -603,7 +640,7 @@ fn run(c: *Conn, si: usize, arena: std.mem.Allocator, req: lsp.Req, out: *std.Io
try app(&b, arena, "\"textDocument\":{\"uri\":");
try jstr(&b, arena, uri.items);
try app(&b, arena, "},\"options\":{\"tabSize\":4,\"insertSpaces\":true}");
- const result = (try call(c, arena, "textDocument/formatting", b.items, deadline)) orelse return;
+ const result = (try call(c, io, arena, "textDocument/formatting", b.items, deadline)) orelse return;
try formatEdits(&cx, c.caps.enc, result, req.source);
},
.code_action => {
@@ -611,7 +648,7 @@ fn run(c: *Conn, si: usize, arena: std.mem.Allocator, req: lsp.Req, out: *std.Io
try app(&b, arena, "\"textDocument\":{\"uri\":");
try jstr(&b, arena, uri.items);
try b.print(arena, "}},\"range\":{{\"start\":{{\"line\":{d},\"character\":{d}}},\"end\":{{\"line\":{d},\"character\":{d}}}}},\"context\":{{\"diagnostics\":[]}}", .{ pos.line, pos.ch, pos.line, pos.ch });
- const result = (try call(c, arena, "textDocument/codeAction", b.items, deadline)) orelse return;
+ const result = (try call(c, io, arena, "textDocument/codeAction", b.items, deadline)) orelse return;
for (items(result)) |ca| {
const title = str(get(ca, "title")) orelse continue;
try lsp.row(cx.out, lsp.rel(cx.base, cx.cur_path), pos.line, 0, flat(arena, title));
@@ -621,7 +658,7 @@ fn run(c: *Conn, si: usize, arena: std.mem.Allocator, req: lsp.Req, out: *std.Io
.completion => {
var b = try atPos(arena, uri.items, pos);
try app(&b, arena, ",\"context\":{\"triggerKind\":1}");
- const result = (try call(c, arena, "textDocument/completion", b.items, deadline)) orelse return;
+ const result = (try call(c, io, arena, "textDocument/completion", b.items, deadline)) orelse return;
const list = if (get(result, "items")) |it| items(it) else items(result);
const here = lsp.rel(cx.base, cx.cur_path);
var n: usize = 0;
@@ -643,11 +680,11 @@ fn run(c: *Conn, si: usize, arena: std.mem.Allocator, req: lsp.Req, out: *std.Io
n += 1;
}
},
- .callstack => try callstack(c, si, arena, &cx, uri.items, pos, deadline, tr, req.callstack_depth),
- .incoming_calls => try hierarchy(c, si, arena, &cx, uri.items, pos, deadline, .incoming, tr),
- .outgoing_calls => try hierarchy(c, si, arena, &cx, uri.items, pos, deadline, .outgoing, tr),
- .supertypes => try hierarchy(c, si, arena, &cx, uri.items, pos, deadline, .supers, tr),
- .subtypes => try hierarchy(c, si, arena, &cx, uri.items, pos, deadline, .subs, tr),
+ .callstack => try callstack(c, io, si, arena, &cx, uri.items, pos, deadline, tr, req.callstack_depth, req.budget, req.arg),
+ .incoming_calls => try hierarchy(c, io, si, arena, &cx, uri.items, pos, deadline, .incoming, tr),
+ .outgoing_calls => try hierarchy(c, io, si, arena, &cx, uri.items, pos, deadline, .outgoing, tr),
+ .supertypes => try hierarchy(c, io, si, arena, &cx, uri.items, pos, deadline, .supers, tr),
+ .subtypes => try hierarchy(c, io, si, arena, &cx, uri.items, pos, deadline, .subs, tr),
.status, .explain => unreachable,
}
}
@@ -687,13 +724,13 @@ fn walkSymbols(cx: *Cx, enc: Enc, uri: []const u8, node: std.json.Value, depth:
/// Pull when the server does (LSP 3.17), the push store otherwise. The store
/// path waits briefly for a publish that postdates the didChange we just
/// sent, so `]d` right after an edit sees the new truth, not the old one.
-fn diagnostics(c: *Conn, arena: std.mem.Allocator, cx: *Cx, uri: []const u8, deadline: i64) Err!void {
+fn diagnostics(c: *Conn, io: std.Io, arena: std.mem.Allocator, cx: *Cx, uri: []const u8, deadline: i64) Err!void {
if (c.caps.pull) {
var b: std.ArrayList(u8) = .empty;
try app(&b, arena, "\"textDocument\":{\"uri\":");
try jstr(&b, arena, uri);
try app(&b, arena, "}");
- const result = (try call(c, arena, "textDocument/diagnostic", b.items, deadline)) orelse return;
+ const result = (try call(c, io, arena, "textDocument/diagnostic", b.items, deadline)) orelse return;
for (items(get(result, "items"))) |dg| try emitDiag(cx, c.caps.enc, uri, dg, arena);
return;
}
@@ -702,13 +739,13 @@ fn diagnostics(c: *Conn, arena: std.mem.Allocator, cx: *Cx, uri: []const u8, dea
stale = d.stale;
break;
};
- if (stale) waitFresh(c, uri, nowMs() + diag_ms);
+ if (stale) try waitFresh(c, io, uri, nowMs() + diag_ms);
try renderStore(c, arena, cx, uri);
}
-fn workspaceDiagnostics(c: *Conn, arena: std.mem.Allocator, cx: *Cx, deadline: i64) Err!void {
+fn workspaceDiagnostics(c: *Conn, io: std.Io, arena: std.mem.Allocator, cx: *Cx, deadline: i64) Err!void {
if (c.caps.pull_workspace) {
- const result = (try call(c, arena, "workspace/diagnostic", "\"previousResultIds\":[]", deadline)) orelse return;
+ const result = (try call(c, io, arena, "workspace/diagnostic", "\"previousResultIds\":[]", deadline)) orelse return;
for (items(get(result, "items"))) |per| {
const uri = str(get(per, "uri")) orelse continue;
for (items(get(per, "items"))) |dg| try emitDiag(cx, c.caps.enc, uri, dg, arena);
@@ -741,7 +778,7 @@ fn renderStore(c: *Conn, arena: std.mem.Allocator, cx: *Cx, only_uri: ?[]const u
/// Block (mutex released) until the reader marks `uri` fresh or the deadline
/// passes. The reader broadcasts on every publishDiagnostics.
-fn waitFresh(c: *Conn, uri: []const u8, deadline: i64) void {
+fn waitFresh(c: *Conn, io: std.Io, uri: []const u8, deadline: i64) error{Canceled}!void {
const g = c.gen;
while (c.gen == g and c.alive()) {
var fresh = false;
@@ -750,7 +787,7 @@ fn waitFresh(c: *Conn, uri: []const u8, deadline: i64) void {
break;
};
if (fresh) return;
- if (!timedWait(c, deadline)) return;
+ if (!try timedWait(c, io, deadline)) return;
}
}
@@ -873,18 +910,21 @@ fn sortEdits(edits: []PutEdit) void {
/// A bounded static hierarchy. Reuse the prepared item verbatim (including
/// server data), and retain every call-site range rather than just a declaration.
-fn hierarchyResult(c: *Conn, arena: std.mem.Allocator, item: std.json.Value, method: []const u8, deadline: i64) Err!?std.json.Value {
+fn hierarchyResult(c: *Conn, io: std.Io, arena: std.mem.Allocator, item: std.json.Value, method: []const u8, deadline: i64) Err!?std.json.Value {
if (jsonDepth(item, 0) > 96) return null;
var body: std.ArrayList(u8) = .empty;
try app(&body, arena, "\"item\":");
try app(&body, arena, std.json.Stringify.valueAlloc(arena, item, .{}) catch return error.OutOfMemory);
- return call(c, arena, method, body.items, deadline);
+ return call(c, io, arena, method, body.items, deadline);
}
const CallTree = struct {
- const Site = struct { range: std.json.Value, focus: bool };
+ /// What a node keeps of the server's item: its own copies, so the
+ /// response it came in is freed once its subtree is walked.
+ const Call = struct { uri: []const u8, name: []const u8, at: Range };
+ const Site = struct { range: Range, focus: bool };
const Node = struct {
- item: std.json.Value,
+ call: Call,
ranges: std.ArrayList(Site) = .empty,
children: std.ArrayList(usize) = .empty,
cycle: bool = false,
@@ -893,10 +933,39 @@ const CallTree = struct {
roots: std.ArrayList(usize) = .empty,
path: [lsp.callstack_max_depth]std.json.Value = undefined,
depth_limit: usize = lsp.callstack_default_depth,
- visited: usize = 0,
limited: bool = false,
+ out_of_time: bool = false,
+ out_of_memory: bool = false,
+ budget: ?*const std.heap.FixedBufferAllocator = null,
+ si: usize = 0,
+ collected: usize = 0,
+ started_ms: i64 = 0,
+ narrated: bool = false,
siblings: [lsp.callstack_max_depth]bool = @splat(false),
rendered: usize = 0,
+ /// Paging. A page starts at `start`, a path of entry indices from the
+ /// top (empty: the start), skipping what is before it at each level;
+ /// `rows` and `bytes` count what rendering takes, and the walk stops
+ /// before their caps at `cut`, which the next page starts at (`more`).
+ /// The ancestors on the path are shown again on it, as context.
+ start: [lsp.callstack_max_depth]u32 = undefined,
+ start_len: usize = 0,
+ at: [lsp.callstack_max_depth]u32 = undefined,
+ cut: [lsp.callstack_max_depth]u32 = undefined,
+ cut_len: usize = 0,
+ more: bool = false,
+ rows: usize = 0,
+ row_cap: usize = max_rows - 16,
+ /// The bytes those rows take, over-estimated (the uri for the path it
+ /// becomes), kept under the answer writer's room.
+ bytes: usize = 0,
+ byte_cap: usize = std.math.maxInt(usize),
+
+ /// A row of a caller at `depth`: its tree columns, the uri the path is
+ /// made from, the name, and room for the address.
+ fn rowBytes(depth: usize, caller: Call) usize {
+ return 5 * (depth + 2) + caller.uri.len + caller.name.len + 40;
+ }
/// Incoming paths arrive nearest-first. Insert them outermost-first,
/// sharing common caller prefixes and retaining all their call sites.
@@ -909,11 +978,14 @@ const CallTree = struct {
const item = get(entry, "from").?;
const children = if (parent) |id| tree.nodes.items[id].children.items else tree.roots.items;
const found = for (children) |id| {
- if (sameCall(tree.nodes.items[id].item, item)) break id;
+ if (sameCall(tree.nodes.items[id].call, item)) break id;
} else null;
+ const depth = path.len - 1 - at;
const id = found orelse blk: {
const id = tree.nodes.items.len;
- try tree.nodes.append(arena, .{ .item = item });
+ try tree.nodes.append(arena, .{ .call = try callOf(arena, item) });
+ tree.rows += 1;
+ tree.bytes += rowBytes(depth, tree.nodes.items[id].call);
if (parent) |pid| {
try tree.nodes.items[pid].children.append(arena, id);
} else try tree.roots.append(arena, id);
@@ -924,23 +996,39 @@ const CallTree = struct {
for (items(get(entry, "fromRanges"))) |range| {
const parsed = rangeOf(range) orelse continue;
for (node.ranges.items) |*other| {
- if (std.meta.eql(parsed, rangeOf(other.range).?)) {
+ if (std.meta.eql(parsed, other.range)) {
other.focus = other.focus or at == 0;
break;
}
- } else try node.ranges.append(arena, .{ .range = range, .focus = at == 0 });
+ } else {
+ try node.ranges.append(arena, .{ .range = parsed, .focus = at == 0 });
+ tree.rows += 1;
+ tree.bytes += rowBytes(depth + 1, .{ .uri = node.call.uri, .name = "", .at = parsed });
+ }
}
parent = id;
}
}
};
-fn sameCall(a: std.json.Value, b: std.json.Value) bool {
- const au = str(get(a, "uri")) orelse return false;
+fn callOf(arena: std.mem.Allocator, item: std.json.Value) Err!CallTree.Call {
+ return .{
+ .uri = try arena.dupe(u8, str(get(item, "uri")).?),
+ .name = try arena.dupe(u8, str(get(item, "name")) orelse "(unnamed)"),
+ .at = rangeOf(get(item, "selectionRange") orelse get(item, "range")).?,
+ };
+}
+
+fn sameCall(a: CallTree.Call, b: std.json.Value) bool {
const bu = str(get(b, "uri")) orelse return false;
- const ar = rangeOf(get(a, "selectionRange") orelse get(a, "range")) orelse return false;
const br = rangeOf(get(b, "selectionRange") orelse get(b, "range")) orelse return false;
- return std.mem.eql(u8, au, bu) and std.meta.eql(ar, br);
+ return std.mem.eql(u8, a.uri, bu) and std.meta.eql(a.at, br);
+}
+
+fn sameItem(a: std.json.Value, b: std.json.Value) bool {
+ const au = str(get(a, "uri")) orelse return false;
+ const ar = rangeOf(get(a, "selectionRange") orelse get(a, "range")) orelse return false;
+ return sameCall(.{ .uri = au, .name = "", .at = ar }, b);
}
fn callPrefix(out: *std.Io.Writer, tree: *const CallTree, depth: usize) Err!void {
@@ -954,44 +1042,115 @@ fn validCaller(entry: std.json.Value) bool {
rangeOf(get(from, "selectionRange") orelse get(from, "range")) != null;
}
-fn callstack(c: *Conn, si: usize, arena: std.mem.Allocator, cx: *Cx, uri: []const u8, pos: Pos, deadline: i64, tr: *Trace, max_depth: u8) Err!void {
+fn callstack(c: *Conn, io: std.Io, si: usize, arena: std.mem.Allocator, cx: *Cx, uri: []const u8, pos: Pos, deadline: i64, tr: *Trace, max_depth: u8, budget: ?*const std.heap.FixedBufferAllocator, arg: []const u8) Err!void {
if (!c.caps.call_hier) return lsp.none(cx.out, "{s} does not answer call hierarchy (no callHierarchyProvider)", .{specs[si].name});
const b = try atPos(arena, uri, pos);
- const prepared = (try call(c, arena, "textDocument/prepareCallHierarchy", b.items, deadline)) orelse return;
+ const prepared = (try call(c, io, arena, "textDocument/prepareCallHierarchy", b.items, deadline)) orelse return;
if (items(prepared).len == 0) return lsp.none(cx.out, "no function at this position", .{});
+ // The rows come from the tree alone: the core reads the sources.
+ cx.no_text = true;
+ // Each response is parsed into its own part of the region, freed once
+ // its subtree is walked; only the path being walked is live JSON.
+ // Raw, as query()'s scratch: `alloc` would fill all ~100 MB of it.
+ const parse_len = if (budget) |fixed| (fixed.buffer.len - fixed.end_index) / 2 else 0;
+ var parse_fba: std.heap.FixedBufferAllocator = .init(if (budget != null)
+ (arena.rawAlloc(parse_len, .of(u8), @returnAddress()) orelse return error.OutOfMemory)[0..parse_len]
+ else
+ &.{});
+ const parse = if (budget != null) parse_fba.allocator() else arena;
for (items(prepared)) |item| {
- var tree: CallTree = .{ .depth_limit = std.math.clamp(max_depth, 1, lsp.callstack_max_depth) };
- const incoming = try hierarchyResult(c, arena, item, "callHierarchy/incomingCalls", deadline);
- const count = try collectCallers(c, arena, item, incoming, deadline, &tree, 0);
- if (count == 0) try cx.out.writeAll("No callers reported\n");
+ var tree: CallTree = .{
+ .depth_limit = std.math.clamp(max_depth, 1, lsp.callstack_max_depth),
+ .si = si,
+ .started_ms = nowMs(),
+ .budget = budget,
+ // The page ends while the answer's writer has room for the rest.
+ .byte_cap = if (cx.fixed_out) (cx.out.buffer.len - cx.out.end) -| (1 << 20) else std.math.maxInt(usize),
+ };
+ var steps = std.mem.tokenizeScalar(u8, std.mem.trim(u8, arg, " \n"), '.');
+ while (steps.next()) |step| {
+ if (tree.start_len == tree.start.len) break;
+ tree.start[tree.start_len] = std.fmt.parseInt(u32, step, 10) catch break;
+ tree.start_len += 1;
+ }
+ const incoming = try hierarchyResult(c, io, parse, item, "callHierarchy/incomingCalls", deadline);
+ const count = try collectCallers(c, io, arena, if (budget != null) &parse_fba else null, item, incoming, &tree, 0, tree.start_len > 0);
+ if (tree.narrated) post(si, .always, "Callstack: {d} callers", .{tree.collected});
+ if (count == 0 and tree.start_len == 0) try cx.out.writeAll("No callers reported\n");
try renderCallers(cx, c.caps.enc, &tree, tree.roots.items, 0);
- if (tree.limited) try cx.out.writeAll("… continue from a function above with Callstack\n");
+ if (tree.more) {
+ try cx.out.writeAll(lsp.callstack_more);
+ for (tree.cut[0..tree.cut_len], 0..) |index, level| try cx.out.print("{s}{d}", .{ if (level == 0) "" else ".", index });
+ try cx.out.print(" {d}\n", .{tree.collected});
+ } else if (tree.out_of_time) {
+ try cx.out.writeAll("… the language server ran out of time; continue from a function above with Callstack\n");
+ } else if (tree.out_of_memory) {
+ try cx.out.writeAll("… stopped at the query's memory limit; continue from a function above with Callstack\n");
+ } else if (tree.limited) try cx.out.writeAll("… continue from a function above with Callstack\n");
tr.note("callstack: {d} callers", .{tree.rendered});
}
}
-fn collectCallers(c: *Conn, arena: std.mem.Allocator, focus: std.json.Value, incoming: ?std.json.Value, deadline: i64, tree: *CallTree, depth: usize) Err!usize {
+/// No caller count and no overall deadline: the walk narrates itself on the
+/// message row after a second, and it stops when a request goes unanswered
+/// (what was collected is shown), when the page is full (the rest is the
+/// next page), or when the shell cancels it for a newer query.
+fn collectCallers(c: *Conn, io: std.Io, arena: std.mem.Allocator, parse: ?*std.heap.FixedBufferAllocator, focus: std.json.Value, incoming: ?std.json.Value, tree: *CallTree, depth: usize, on_path: bool) Err!usize {
var count: usize = 0;
- for (items(incoming)) |entry| {
- if (tree.visited >= 64) {
- tree.limited = true;
- break;
+ for (items(incoming), 0..) |entry, index| {
+ // A later page skips what the pages before it walked.
+ const resuming = on_path and depth < tree.start_len;
+ if (resuming and index < tree.start[depth]) continue;
+ tree.at[depth] = @intCast(index);
+ if (tree.budget) |b| if (b.buffer.len - b.end_index < callstack_reserve) {
+ tree.out_of_memory = true;
+ };
+ if (!tree.more and (tree.rows >= tree.row_cap or tree.bytes >= tree.byte_cap or tree.out_of_memory)) {
+ // The page is full: the next goes on here. Never where this
+ // one began, which would page in place: past that entry.
+ tree.more = true;
+ tree.cut_len = depth + 1;
+ @memcpy(tree.cut[0..tree.cut_len], tree.at[0..tree.cut_len]);
+ if (tree.cut_len == tree.start_len and std.mem.eql(u32, tree.cut[0..tree.cut_len], tree.start[0..tree.start_len]))
+ tree.cut[depth] += 1;
}
+ if (tree.out_of_time or tree.more) break;
if (!validCaller(entry)) continue;
const from = get(entry, "from").?;
- const cycle = sameCall(focus, from) or for (tree.path[0..depth]) |ancestor| {
- if (sameCall(get(ancestor, "from").?, from)) break true;
+ const cycle = sameItem(focus, from) or for (tree.path[0..depth]) |ancestor| {
+ if (sameItem(get(ancestor, "from").?, from)) break true;
} else false;
tree.path[depth] = entry;
- tree.visited += 1;
count += 1;
+ tree.collected += 1;
+ if (nowMs() - tree.started_ms >= 1000) {
+ tree.narrated = true;
+ post(tree.si, .chatty, "Callstack: {d} callers\u{2026}", .{tree.collected});
+ }
var children: usize = 0;
if (!cycle) {
- if (depth + 1 == tree.depth_limit or tree.visited >= 64) {
+ if (depth + 1 == tree.depth_limit) {
tree.limited = true;
} else {
- const ancestors = try hierarchyResult(c, arena, from, "callHierarchy/incomingCalls", deadline);
- children = try collectCallers(c, arena, focus, ancestors, deadline, tree, depth + 1);
+ const mark = if (parse) |fixed| fixed.end_index else 0;
+ defer if (parse) |fixed| {
+ fixed.end_index = mark;
+ };
+ const ancestors = hierarchyResult(c, io, if (parse) |fixed| fixed.allocator() else arena, from, "callHierarchy/incomingCalls", nowMs() + req_ms) catch |e| switch (e) {
+ error.Timeout => blk: {
+ tree.out_of_time = true;
+ break :blk null;
+ },
+ // A response bigger than the parse region: this caller
+ // stops here, the page with it.
+ error.OutOfMemory => blk: {
+ tree.out_of_memory = true;
+ break :blk null;
+ },
+ else => return e,
+ };
+ const deeper = resuming and index == tree.start[depth] and depth + 1 < tree.start_len;
+ if (!tree.out_of_time and !tree.out_of_memory) children = try collectCallers(c, io, arena, parse, focus, ancestors, tree, depth + 1, deeper);
}
}
if (children == 0) try tree.addPath(arena, tree.path[0 .. depth + 1], cycle);
@@ -999,51 +1158,61 @@ fn collectCallers(c: *Conn, arena: std.mem.Allocator, focus: std.json.Value, inc
return count;
}
+/// Test callers sink below the rest; each group keeps the usual order.
+// ponytail: substring heuristic, "latest.zig" or "contest" count as tests too
+fn testCaller(caller: CallTree.Call) bool {
+ return std.ascii.findIgnoreCase(caller.name, "test") != null or
+ std.ascii.findIgnoreCase(std.fs.path.basenamePosix(caller.uri), "test") != null;
+}
+
fn callerLess(tree: *const CallTree, a: usize, b: usize) bool {
- const left = tree.nodes.items[a].item;
- const right = tree.nodes.items[b].item;
- const uri_order = std.mem.order(u8, str(get(left, "uri")).?, str(get(right, "uri")).?);
+ const left = tree.nodes.items[a].call;
+ const right = tree.nodes.items[b].call;
+ if (testCaller(left) != testCaller(right)) return testCaller(right);
+ const uri_order = std.mem.order(u8, left.uri, right.uri);
if (uri_order != .eq) return uri_order == .lt;
- return callRangeLess({}, get(left, "selectionRange") orelse get(left, "range").?, get(right, "selectionRange") orelse get(right, "range").?);
+ return rangeLess(left.at, right.at);
}
-fn callRangeLess(_: void, a: std.json.Value, b: std.json.Value) bool {
- const left = rangeOf(a).?;
- const right = rangeOf(b).?;
+fn rangeLess(left: Range, right: Range) bool {
return left.sl < right.sl or (left.sl == right.sl and left.sc < right.sc);
}
fn renderCallers(cx: *Cx, enc: Enc, tree: *CallTree, children: []usize, depth: usize) Err!void {
std.mem.sort(usize, children, @as(*const CallTree, tree), callerLess);
for (children, 0..) |id, index| {
- if (tree.rendered >= 64) {
+ // emitRange's row ceiling and the writer's room, met here before a
+ // prefix is half written
+ if (cx.rows >= max_rows or (cx.fixed_out and cx.out.buffer.len - cx.out.end < row_room)) {
tree.limited = true;
return;
}
const node = &tree.nodes.items[id];
- const item = node.item;
- const uri = str(get(item, "uri")).?;
const more = index + 1 < children.len;
try callPrefix(cx.out, tree, depth);
const has_children = node.children.items.len > 0 or node.ranges.items.len > 0;
const rounded = cx.callstack_corners == .rounded;
try cx.out.writeAll(if (more) "├" else if (rounded) "╰" else "└");
try cx.out.writeAll(if (has_children) "──┬ " else "─── ");
- const name = flat(cx.arena, str(get(item, "name")) orelse "(unnamed)");
+ const name = flat(cx.arena, node.call.name);
const label = if (node.cycle) try std.fmt.allocPrint(cx.arena, "{s} ↻ recursion", .{name}) else name;
- try emitRange(cx, enc, uri, get(item, "selectionRange") orelse get(item, "range"), label);
+ try emitAt(cx, enc, node.call.uri, node.call.at, label);
tree.rendered += 1;
tree.siblings[depth] = more;
std.mem.sort(CallTree.Site, node.ranges.items, {}, struct {
fn less(_: void, a: CallTree.Site, b: CallTree.Site) bool {
- return callRangeLess({}, a.range, b.range);
+ return rangeLess(a.range, b.range);
}
}.less);
for (node.ranges.items, 0..) |site, site_index| {
+ if (cx.rows >= max_rows or (cx.fixed_out and cx.out.buffer.len - cx.out.end < row_room)) {
+ tree.limited = true;
+ return;
+ }
if (site.focus) try cx.out.writeAll(lsp.callstack_match);
try callPrefix(cx.out, tree, depth + 1);
try cx.out.writeAll(if (node.children.items.len > 0 or site_index + 1 < node.ranges.items.len) "├─ " else if (rounded) "╰─ " else "└─ ");
- try emitRange(cx, enc, uri, site.range, "");
+ try emitAt(cx, enc, node.call.uri, site.range, "");
}
try renderCallers(cx, enc, tree, node.children.items, depth + 1);
}
@@ -1054,7 +1223,7 @@ const Hier = enum { incoming, outgoing, supers, subs };
/// The two-step hierarchy kinds: prepare at the cursor, then follow every
/// item the server returned (usually one). Gated on the server capability so
/// an old server costs zero round trips.
-fn hierarchy(c: *Conn, si: usize, arena: std.mem.Allocator, cx: *Cx, uri: []const u8, pos: Pos, deadline: i64, h: Hier, tr: *Trace) Err!void {
+fn hierarchy(c: *Conn, io: std.Io, si: usize, arena: std.mem.Allocator, cx: *Cx, uri: []const u8, pos: Pos, deadline: i64, h: Hier, tr: *Trace) Err!void {
const call_side = h == .incoming or h == .outgoing;
if (call_side and !c.caps.call_hier) {
tr.note("STOP: {s} does not advertise callHierarchyProvider", .{specs[si].name});
@@ -1072,9 +1241,9 @@ fn hierarchy(c: *Conn, si: usize, arena: std.mem.Allocator, cx: *Cx, uri: []cons
.subs => "typeHierarchy/subtypes",
};
const b = try atPos(arena, uri, pos);
- const prepared = (try call(c, arena, prepare, b.items, deadline)) orelse return;
+ const prepared = (try call(c, io, arena, prepare, b.items, deadline)) orelse return;
for (items(prepared)) |item| {
- const result = (try hierarchyResult(c, arena, item, follow, deadline)) orelse return;
+ const result = (try hierarchyResult(c, io, arena, item, follow, deadline)) orelse return;
for (items(result)) |entry| switch (h) {
.incoming => {
// one row per CALL SITE, under the caller's name — that is
@@ -1134,6 +1303,10 @@ const Cx = struct {
cur_path: []const u8,
cur_src: []const u8,
out: *std.Io.Writer,
+ /// `out` is the query's fixed answer buffer, whose room is checked.
+ fixed_out: bool = false,
+ /// Rows without their source text (Callstack: the core reads it).
+ no_text: bool = false,
rows: usize = 0,
relative_parents: bool = false,
callstack_corners: lsp.CallstackCorners = .rounded,
@@ -1169,11 +1342,16 @@ const Cx = struct {
/// columns, and a single-line range becomes the `path:LINE:COL-ENDCOL` form a
/// look SELECTS. `note` overrides the source line as the row's text.
fn emitRange(cx: *Cx, enc: Enc, uri: []const u8, range: ?std.json.Value, note: []const u8) Err!void {
+ return emitAt(cx, enc, uri, rangeOf(range) orelse return, note);
+}
+
+fn emitAt(cx: *Cx, enc: Enc, uri: []const u8, r: Range, note: []const u8) Err!void {
if (cx.rows >= max_rows) return;
const path = pathOf(cx.arena, uri) orelse return;
if (path.len == 0 or path[0] != '/') return; // rows promise absolute-or-rel-from-base
- const r = rangeOf(range) orelse return;
- const src = cx.text(path);
+ // Without sources (Callstack) the asking file is still known: its rows'
+ // columns convert from utf-16 as ever.
+ const src = if (cx.no_text and !std.mem.eql(u8, path, cx.cur_path)) null else cx.text(path);
var bol: usize = 0;
var eol: usize = 0;
@@ -1323,7 +1501,8 @@ fn transportPair(sv: *[2]libc.fd_t) bool {
/// Spawn-or-return, and tell an existing server about a new project root.
/// Returns the generation the caller's whole query is bound to.
-fn ensure(c: *Conn, si: usize, arena: std.mem.Allocator, req: lsp.Req, tr: *Trace) Err!u32 {
+fn ensure(c: *Conn, io: std.Io, si: usize, arena: std.mem.Allocator, req: lsp.Req, tr: *Trace) Err!u32 {
+ c.si = si;
if (c.state == .disabled) {
tr.note("STOP: {s} is disabled for this session (no binary; set {s})", .{ specs[si].name, specs[si].env });
return error.NoServer;
@@ -1341,7 +1520,7 @@ fn ensure(c: *Conn, si: usize, arena: std.mem.Allocator, req: lsp.Req, tr: *Trac
try app(&b, arena, "{\"jsonrpc\":\"2.0\",\"method\":\"workspace/didChangeWorkspaceFolders\",\"params\":{\"event\":{\"added\":[{\"name\":\"root\",\"uri\":\"");
try uriOf(&b, arena, root);
try app(&b, arena, "\"}],\"removed\":[]}}}");
- try frame(c.sock, b.items, nowMs() + reply_ms);
+ try send(c, io, b.items, nowMs() + wedge_ms);
const owned = sa.dupe(u8, root) catch return error.OutOfMemory;
c.extra_roots.append(sa, owned) catch sa.free(owned);
}
@@ -1430,12 +1609,13 @@ fn ensure(c: *Conn, si: usize, arena: std.mem.Allocator, req: lsp.Req, tr: *Trac
if (c.resp) |r| sa.free(r);
c.resp = null;
c.progress = 0;
+ c.loading = false;
c.timeouts = 0;
forgetDocs(c);
if (c.root.len > 0) sa.free(c.root);
c.root = owned_root;
- const th = std.Thread.spawn(.{}, reader, .{ si, g, sv[0] }) catch {
+ const th = std.Thread.spawn(.{}, reader, .{ io, si, g, sv[0] }) catch {
// no reader means nobody would ever close the fd our way; do it here,
// before anything else can see the conn
_ = libc.close(sv[0]);
@@ -1450,8 +1630,14 @@ fn ensure(c: *Conn, si: usize, arena: std.mem.Allocator, req: lsp.Req, tr: *Trac
post(si, .always, "{s} starting — {s}", .{ specs[si].name, root });
tr.note("spawned {s} (pid {d}) at {s}", .{ specs[si].name, pid, root });
- handshake(c, arena, root) catch |e| {
- shutdownIf(c, g);
+ // A start runs to the end however soon the query that began it is
+ // canceled: killing a half-started server would only make the next
+ // query start it again. The cancel lands at the next wait instead.
+ const protection = io.swapCancelProtection(.blocked);
+ const started = handshake(c, io, arena, root);
+ _ = io.swapCancelProtection(protection);
+ started catch |e| {
+ shutdownIf(c, io, g);
// NOT a session disable. A handshake that misses the deadline is
// routinely environmental — a rustup shim deciding to download the
// project's pinned toolchain before launching the real server was
@@ -1477,7 +1663,7 @@ fn ensure(c: *Conn, si: usize, arena: std.mem.Allocator, req: lsp.Req, tr: *Trac
return g;
}
-fn handshake(c: *Conn, arena: std.mem.Allocator, root: []const u8) Err!void {
+fn handshake(c: *Conn, io: std.Io, arena: std.mem.Allocator, root: []const u8) Err!void {
var b: std.ArrayList(u8) = .empty;
try b.print(arena, "\"processId\":{d},\"clientInfo\":{{\"name\":\"pardes\"}},\"rootUri\":\"", .{@as(u32, @bitCast(libc.getpid()))});
try uriOf(&b, arena, root);
@@ -1509,7 +1695,7 @@ fn handshake(c: *Conn, arena: std.mem.Allocator, root: []const u8) Err!void {
for (b.items) |ch| if (ch != '\n') try body.append(arena, ch);
const deadline = nowMs() + init_ms;
- const reply = (try call(c, arena, "initialize", body.items, deadline)) orelse return error.Protocol;
+ const reply = (try call(c, io, arena, "initialize", body.items, deadline)) orelse return error.Protocol;
const caps = get(reply, "capabilities");
c.caps.enc = if (std.mem.eql(u8, str(get(caps, "positionEncoding")) orelse "utf-16", "utf-8")) .utf8 else .utf16;
@@ -1521,7 +1707,7 @@ fn handshake(c: *Conn, arena: std.mem.Allocator, root: []const u8) Err!void {
c.caps.type_hier = provider(get(caps, "typeHierarchyProvider"));
c.caps.folders = if (get(get(get(caps, "workspace"), "workspaceFolders"), "supported")) |s| s == .bool and s.bool else false;
- try frame(c.sock, "{\"jsonrpc\":\"2.0\",\"method\":\"initialized\",\"params\":{}}", deadline);
+ try send(c, io, "{\"jsonrpc\":\"2.0\",\"method\":\"initialized\",\"params\":{}}", deadline);
}
/// A server capability that may be `true`, an options object, or absent.
@@ -1536,7 +1722,7 @@ fn provider(v: ?std.json.Value) bool {
/// didOpen the first time a file is seen, didChange when its bytes moved,
/// nothing when they did not — the common case between two presses of gd.
-fn syncDoc(c: *Conn, si: usize, arena: std.mem.Allocator, uri: []const u8, src: []const u8) Err!void {
+fn syncDoc(c: *Conn, io: std.Io, si: usize, arena: std.mem.Allocator, uri: []const u8, src: []const u8) Err!void {
const hash = std.hash.Wyhash.hash(0, src);
var doc: ?*Doc = null;
for (c.docs.items) |*d| if (std.mem.eql(u8, d.uri, uri)) {
@@ -1568,13 +1754,16 @@ fn syncDoc(c: *Conn, si: usize, arena: std.mem.Allocator, uri: []const u8, src:
try jstr(&b, arena, src);
try app(&b, arena, "}}}");
}
- try frame(c.sock, b.items, nowMs() + req_ms);
+ // A server busy with what it was sent last reads no more meanwhile
+ // (clangd parses its compile database at a first open): this waits as
+ // an answer does, for a cancel or a server that has stopped.
+ try send(c, io, b.items, nowMs() + wedge_ms);
}
/// Send a request and wait on the mailbox. Returns the parsed `result`, or
/// null for an error response / null result — both are legal "no answer".
/// Runs with the conn mutex held; the mutex is released inside the wait.
-fn call(c: *Conn, arena: std.mem.Allocator, method: []const u8, params: []const u8, deadline: i64) Err!?std.json.Value {
+fn call(c: *Conn, io: std.Io, arena: std.mem.Allocator, method: []const u8, params: []const u8, deadline: i64) Err!?std.json.Value {
const g = c.gen;
const id = c.next_id;
c.next_id +%= 1;
@@ -1589,17 +1778,36 @@ fn call(c: *Conn, arena: std.mem.Allocator, method: []const u8, params: []const
c.want_id = id;
defer c.want_id = 0;
- try frame(c.sock, b.items, deadline);
+ try send(c, io, b.items, if (c.state == .ready) nowMs() + wedge_ms else deadline);
+ // The handshake (still `.starting`) has its deadline. A ready server is
+ // waited for until it answers or the shell cancels this query for a
+ // newer one, so the first query after a start is answered, not lost:
+ // past `deadline` the message row says it is still working, and only
+ // silent and idle for wedge_ms is it not answering.
+ var said = false;
+ var busy_at = nowMs();
while (c.resp == null and c.gen == g and c.alive()) {
- if (!timedWait(c, deadline)) break;
+ const ready = c.state == .ready;
+ const waiting = timedWait(c, io, if (ready) nowMs() + 500 else deadline) catch |e| {
+ cancelRequest(c, io, arena, id);
+ return e;
+ };
+ if (!ready) {
+ if (waiting) continue;
+ break;
+ }
+ if (c.progress > 0) busy_at = nowMs();
+ if (!said and nowMs() >= deadline) {
+ said = true;
+ post(c.si, .always, "{s} is still working on it\u{2026}", .{specs[c.si].name});
+ }
+ if (nowMs() - busy_at >= wedge_ms) break;
}
+ if (said and c.resp != null) post(c.si, .always, "{s} answered", .{specs[c.si].name});
if (c.gen != g or !c.alive()) return error.Dead;
const raw = c.resp orelse {
- // give the server leave to abandon the work we stopped waiting for
- var cb: std.ArrayList(u8) = .empty;
- cb.print(arena, "{{\"jsonrpc\":\"2.0\",\"method\":\"$/cancelRequest\",\"params\":{{\"id\":{d}}}}}", .{id}) catch return error.Timeout;
- frame(c.sock, cb.items, nowMs() + reply_ms) catch {};
+ cancelRequest(c, io, arena, id);
return error.Timeout;
};
c.resp = null;
@@ -1609,49 +1817,23 @@ fn call(c: *Conn, arena: std.mem.Allocator, method: []const u8, params: []const
if (result == .null) return null;
return result;
}
-/// One bounded cond wait. False when the deadline has passed.
-///
-/// The deadline arithmetic everywhere here is CLOCK_MONOTONIC, so the wait
-/// must be too: a REALTIME abstime plus an NTP step backwards would park a
-/// worker far past `req_ms`, violating the seam's bounded-wait promise. On
-/// linux the condvar is lazily initialized with a monotonic condattr; darwin
-/// has no setclock but has a RELATIVE wait, which never consults the wall
-/// clock at all.
-fn timedWait(c: *Conn, deadline: i64) bool {
+/// Give the server leave to abandon the work we stopped waiting for.
+fn cancelRequest(c: *Conn, io: std.Io, arena: std.mem.Allocator, id: u32) void {
+ var cb: std.ArrayList(u8) = .empty;
+ cb.print(arena, "{{\"jsonrpc\":\"2.0\",\"method\":\"$/cancelRequest\",\"params\":{{\"id\":{d}}}}}", .{id}) catch return;
+ send(c, io, cb.items, nowMs() + reply_ms) catch {};
+}
+
+/// One bounded cond wait, and a cancelation point: a worker the shell
+/// cancels for a newer query stops here. False when the deadline has passed.
+fn timedWait(c: *Conn, io: std.Io, deadline: i64) error{Canceled}!bool {
const left = deadline - nowMs();
if (left <= 0) return false;
const wait_ms = @min(left, 500); // tick so gen/state changes are noticed
- if (comptime builtin.os.tag.isDarwin()) {
- const rel: libc.timespec = .{
- .sec = @divTrunc(wait_ms, 1000),
- .nsec = @rem(wait_ms, 1000) * 1_000_000,
- };
- _ = pthread_cond_timedwait_relative_np(&c.cond, &c.mu, &rel);
- return true;
- }
- if (!c.cond_monotonic) {
- // lazily re-initialize the zeroed (REALTIME) condvar with a
- // monotonic clock; under the mutex, and only before the first wait,
- // so no thread can be parked on the old one
- var attr: pthread_condattr_t = undefined;
- if (pthread_condattr_init(&attr) == 0) {
- _ = pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
- _ = pthread_cond_init(&c.cond, &attr);
- _ = pthread_condattr_destroy(&attr);
- }
- c.cond_monotonic = true;
- }
- var now: libc.timespec = undefined;
- _ = libc.clock_gettime(.MONOTONIC, &now);
- var abs: libc.timespec = .{
- .sec = now.sec + @divTrunc(wait_ms, 1000),
- .nsec = now.nsec + @rem(wait_ms, 1000) * 1_000_000,
+ c.cond.waitTimeout(io, &c.mu, .{ .duration = .{ .raw = .fromMilliseconds(wait_ms), .clock = .awake } }) catch |e| switch (e) {
+ error.Timeout => {},
+ error.Canceled => return error.Canceled,
};
- if (abs.nsec >= 1_000_000_000) {
- abs.sec += 1;
- abs.nsec -= 1_000_000_000;
- }
- _ = libc.pthread_cond_timedwait(&c.cond, &c.mu, &abs);
return true;
}
@@ -1659,7 +1841,7 @@ fn timedWait(c: *Conn, deadline: i64) bool {
/// respawn that happened during the caller's wait must not be killed for its
/// predecessor's crimes. Mutex held. The reader closes the fd; this only
/// shuts the transport down and reaps the child.
-fn shutdownIf(c: *Conn, g: u32) void {
+fn shutdownIf(c: *Conn, io: std.Io, g: u32) void {
if (c.gen != g or c.sock < 0) return;
_ = libc.shutdown(c.sock, 2); // SHUT_RDWR: the reader sees EOF and closes
reap(c.pid);
@@ -1669,7 +1851,7 @@ fn shutdownIf(c: *Conn, g: u32) void {
forgetDocs(c);
if (c.resp) |r| sa.free(r);
c.resp = null;
- _ = libc.pthread_cond_broadcast(&c.cond);
+ c.cond.broadcast(io);
}
/// TERM, a bounded grace, then KILL, to the server's whole process group
@@ -1715,6 +1897,7 @@ fn forgetDocs(c: *Conn) void {
sa.free(d.body);
}
c.diags.clearRetainingCapacity();
+ c.diag_bytes = 0;
}
// ------------------------------------------------------------ reader thread
@@ -1722,20 +1905,22 @@ fn forgetDocs(c: *Conn) void {
/// Owns the read side of one socket for one generation, and is the only
/// closer of that fd. Routes responses to the mailbox, answers server
/// requests, feeds the diagnostics store, narrates progress.
-fn reader(si: usize, g: u32, sock: c_int) void {
+fn reader(io: std.Io, si: usize, g: u32, sock: c_int) void {
const c = &conns[si];
var buf = sa.alloc(u8, 256 * 1024) catch {
- readerExit(c, si, g, sock);
+ readerExit(c, io, si, g, sock);
return;
};
defer sa.free(buf);
var len: usize = 0;
+ var parse_arena: std.heap.ArenaAllocator = .init(sa);
+ defer parse_arena.deinit();
outer: while (true) {
// drain every complete frame already buffered
drain: while (true) switch (frameNext(buf[0..len])) {
.frame => |m| {
- dispatch(c, si, g, sock, buf[m.body_start..m.body_end]);
+ dispatch(c, io, si, g, sock, buf[m.body_start..m.body_end], &parse_arena);
std.mem.copyForwards(u8, buf[0 .. len - m.consumed], buf[m.consumed..len]);
len -= m.consumed;
},
@@ -1761,9 +1946,9 @@ fn reader(si: usize, g: u32, sock: c_int) void {
if (pr == 0) {
// tick: a respawn while the server was silent leaves this thread
// reading a corpse; notice and go
- c.lock();
+ c.mu.lockUncancelable(io);
const stale = c.gen != g;
- c.unlock();
+ c.mu.unlock(io);
if (stale) break :outer;
continue;
}
@@ -1776,11 +1961,11 @@ fn reader(si: usize, g: u32, sock: c_int) void {
if (got == 0) break :outer; // the server exited or shutdownIf spoke
len += @intCast(got);
}
- readerExit(c, si, g, sock);
+ readerExit(c, io, si, g, sock);
}
-fn readerExit(c: *Conn, si: usize, g: u32, sock: c_int) void {
- c.lock();
+fn readerExit(c: *Conn, io: std.Io, si: usize, g: u32, sock: c_int) void {
+ c.mu.lockUncancelable(io);
if (c.gen == g and c.alive()) {
// the server died on its own — shutdownIf never saw it, so the corpse
// is ours to reap and the conn's transport fields are ours to clear
@@ -1800,10 +1985,14 @@ fn readerExit(c: *Conn, si: usize, g: u32, sock: c_int) void {
} else {
post(si, .always, "{s} exited — restarts on the next query", .{specs[si].name});
}
- _ = libc.pthread_cond_broadcast(&c.cond);
+ c.cond.broadcast(io);
}
- c.unlock();
+ c.mu.unlock(io);
+ // A query writes with the mutex let go (send): the fd stays its until
+ // that write is done, and shutdown(2) has already made it fail fast.
+ c.write_mu.lockUncancelable(io);
_ = libc.close(sock);
+ c.write_mu.unlock(io);
}
/// 10s doubling to 2min: the fork-per-keystroke guard's schedule.
@@ -1845,32 +2034,33 @@ fn frameNext(data: []const u8) FrameStep {
/// One message from the server. Parses into a throwaway arena; touches conn
/// state only under the mutex; replies never hold it (bounded writes must not
/// stall the mailbox).
-fn dispatch(c: *Conn, si: usize, g: u32, sock: c_int, raw: []const u8) void {
- var arena_state: std.heap.ArenaAllocator = .init(sa);
- defer arena_state.deinit();
+fn dispatch(c: *Conn, io: std.Io, si: usize, g: u32, sock: c_int, raw: []const u8, arena_state: *std.heap.ArenaAllocator) void {
+ // The reader's one parse arena, reset per message: no mapping per
+ // `$/progress` report, and no more than parse_kept kept between them.
+ defer _ = arena_state.reset(.{ .retain_with_limit = parse_kept });
const arena = arena_state.allocator();
const v = std.json.parseFromSliceLeaky(std.json.Value, arena, raw, .{}) catch return;
if (v != .object) return;
if (str(get(v, "method"))) |method| {
- if (get(v, "id")) |id| return serverRequest(arena, sock, method, id, get(v, "params"));
- return notification(c, si, g, raw, method, get(v, "params"));
+ if (get(v, "id")) |id| return serverRequest(c, io, arena, sock, method, id, get(v, "params"));
+ return notification(c, io, si, g, raw, method, get(v, "params"));
}
// a response: deliver to the one waiting query, if it is still waiting
const id = num(get(v, "id")) orelse return;
- c.lock();
- defer c.unlock();
+ c.mu.lockUncancelable(io);
+ defer c.mu.unlock(io);
if (c.gen == g and c.want_id != 0 and id == c.want_id and c.resp == null) {
c.resp = sa.dupe(u8, raw) catch null;
- _ = libc.pthread_cond_broadcast(&c.cond);
+ c.cond.broadcast(io);
}
}
/// The server asked US something. Everything optional was declined in the
/// handshake, so a null-ish answer is always legal — but it must ARRIVE, or
/// the server blocks forever on its own question.
-fn serverRequest(arena: std.mem.Allocator, sock: c_int, method: []const u8, id: std.json.Value, params: ?std.json.Value) void {
+fn serverRequest(c: *Conn, io: std.Io, arena: std.mem.Allocator, sock: c_int, method: []const u8, id: std.json.Value, params: ?std.json.Value) void {
var b: std.ArrayList(u8) = .empty;
app(&b, arena, "{\"jsonrpc\":\"2.0\",\"id\":") catch return;
switch (id) {
@@ -1890,17 +2080,17 @@ fn serverRequest(arena: std.mem.Allocator, sock: c_int, method: []const u8, id:
} else {
app(&b, arena, ",\"result\":null}") catch return;
}
- frame(sock, b.items, nowMs() + reply_ms) catch {};
+ answerServer(c, io, sock, b.items);
}
-fn notification(c: *Conn, si: usize, g: u32, raw: []const u8, method: []const u8, params: ?std.json.Value) void {
+fn notification(c: *Conn, io: std.Io, si: usize, g: u32, raw: []const u8, method: []const u8, params: ?std.json.Value) void {
if (std.mem.eql(u8, method, "textDocument/publishDiagnostics")) {
const uri = str(get(params, "uri")) orelse return;
// keep the raw MESSAGE (params included); re-parsing it per query
// beats owning a parsed tree past this arena's life
const body = sa.dupe(u8, raw) catch return;
- c.lock();
- defer c.unlock();
+ c.mu.lockUncancelable(io);
+ defer c.mu.unlock(io);
if (c.gen != g) {
sa.free(body);
return;
@@ -1914,10 +2104,25 @@ fn notification(c: *Conn, si: usize, g: u32, raw: []const u8, method: []const u8
slot = d;
break;
};
+ // Bounded in files and bytes: a new set that does not fit pushes
+ // out the oldest files' (the server sends a file's again when it
+ // changes); one bigger than the whole store is not kept.
+ if (body.len > max_diag_bytes) {
+ sa.free(body);
+ return;
+ }
if (slot) |d| {
+ c.diag_bytes -= d.body.len;
sa.free(d.body);
d.body = body;
- } else if (c.diags.items.len < 256) {
+ c.diag_bytes += body.len;
+ } else {
+ while (c.diags.items.len > 0 and (c.diags.items.len >= max_diag_files or c.diag_bytes + body.len > max_diag_bytes)) {
+ const old = c.diags.orderedRemove(0);
+ c.diag_bytes -= old.body.len;
+ sa.free(old.uri);
+ sa.free(old.body);
+ }
const owned = sa.dupe(u8, uri) catch {
sa.free(body);
return;
@@ -1927,17 +2132,18 @@ fn notification(c: *Conn, si: usize, g: u32, raw: []const u8, method: []const u8
sa.free(body);
return;
};
- } else sa.free(body);
- _ = libc.pthread_cond_broadcast(&c.cond); // waitFresh watches this
+ c.diag_bytes += body.len;
+ }
+ c.cond.broadcast(io); // waitFresh watches this
return;
}
if (std.mem.eql(u8, method, "$/progress")) {
const value = get(params, "value") orelse return;
const pkind = str(get(value, "kind")) orelse return;
const msg = str(get(value, "message")) orelse "";
- c.lock();
+ c.mu.lockUncancelable(io);
if (c.gen != g) {
- c.unlock();
+ c.mu.unlock(io);
return;
}
if (std.mem.eql(u8, pkind, "begin")) {
@@ -1948,7 +2154,7 @@ fn notification(c: *Conn, si: usize, g: u32, raw: []const u8, method: []const u8
var tbuf: [48]u8 = undefined;
const t = tbuf[0..c.title_len];
@memcpy(t, c.title[0..c.title_len]);
- c.unlock();
+ c.mu.unlock(io);
post(si, .chatty, "{s}: {s}\u{2026} {s}", .{ specs[si].name, t, msg });
return;
}
@@ -1957,7 +2163,7 @@ fn notification(c: *Conn, si: usize, g: u32, raw: []const u8, method: []const u8
const t = tbuf[0..c.title_len];
@memcpy(t, c.title[0..c.title_len]);
const pct = num(get(value, "percentage"));
- c.unlock();
+ c.mu.unlock(io);
if (pct) |p|
post(si, .chatty, "{s}: {s} {d}% {s}", .{ specs[si].name, t, p, msg })
else
@@ -1968,7 +2174,7 @@ fn notification(c: *Conn, si: usize, g: u32, raw: []const u8, method: []const u8
c.progress -= 1;
const idle = c.progress <= 0;
if (idle) c.progress = 0;
- c.unlock();
+ c.mu.unlock(io);
// the setpoint every burst of progress ends on; `.always` + the
// dedupe above means it lands exactly once however the reports raced
if (idle) post(si, .always, "{s}: ready", .{specs[si].name});
@@ -1985,6 +2191,12 @@ fn notification(c: *Conn, si: usize, g: u32, raw: []const u8, method: []const u8
if (std.mem.eql(u8, method, "experimental/serverStatus")) {
const health = str(get(params, "health")) orelse "ok";
const quiescent = if (get(params, "quiescent")) |q| q == .bool and q.bool else false;
+ c.mu.lockUncancelable(io);
+ if (c.gen == g) {
+ c.loading = !quiescent;
+ c.cond.broadcast(io);
+ }
+ c.mu.unlock(io);
if (!std.mem.eql(u8, health, "ok"))
post(si, .always, "{s}: {s} — {s}", .{ specs[si].name, health, str(get(params, "message")) orelse "" })
else if (quiescent)
@@ -1995,12 +2207,12 @@ fn notification(c: *Conn, si: usize, g: u32, raw: []const u8, method: []const u8
// ------------------------------------------------------------- introspection
-fn status(req: lsp.Req, out: *std.Io.Writer) !void {
+fn status(io: std.Io, req: lsp.Req, out: *std.Io.Writer) !void {
_ = req;
try out.print("\nprotocol servers (lsp-client):\n", .{});
for (&specs, 0..) |*s, i| {
const c = &conns[i];
- c.lock();
+ c.mu.lockUncancelable(io);
const state = c.state;
var rootbuf: [256]u8 = undefined;
const rootlen = @min(c.root.len, rootbuf.len);
@@ -2012,7 +2224,7 @@ fn status(req: lsp.Req, out: *std.Io.Writer) !void {
const pull = c.caps.pull;
const chier = c.caps.call_hier;
const thier = c.caps.type_hier;
- c.unlock();
+ c.mu.unlock(io);
const env_v = if (getenv(s.env)) |v| std.mem.span(v) else null;
// Never spawned is not off: the first query of its files starts it.
try out.print(" {s:<28} {s}", .{ s.name, if (state == .off) "not started yet (its first query starts it)" else @tagName(state) });
@@ -2069,21 +2281,80 @@ fn atPos(arena: std.mem.Allocator, uri: []const u8, pos: Pos) Err!std.ArrayList(
return b;
}
-fn frame(sock: c_int, body: []const u8, deadline: i64) Err!void {
+/// A message to the server from a query, the conn's mutex let go while it is
+/// written: the reader goes on taking the server's output meanwhile, which a
+/// server may be waiting to write before it reads more of ours.
+fn send(c: *Conn, io: std.Io, body: []const u8, deadline: i64) Err!void {
+ const sock = c.sock;
+ c.mu.unlock(io);
+ defer c.mu.lockUncancelable(io);
+ return frame(c, io, sock, body, deadline);
+}
+
+fn frame(c: *Conn, io: std.Io, sock: c_int, body: []const u8, deadline: i64) Err!void {
if (sock < 0) return error.Dead;
+ c.write_mu.lockUncancelable(io);
+ defer releaseWrite(c, io, sock);
var hdr: [64]u8 = undefined;
const h = std.fmt.bufPrint(&hdr, "Content-Length: {d}\r\n\r\n", .{body.len}) catch return error.Protocol;
- try sockWrite(sock, h, deadline);
- try sockWrite(sock, body, deadline);
+ var started = false;
+ try sockWrite(io, sock, h, deadline, &started);
+ try sockWrite(io, sock, body, deadline, &started);
}
-fn sockWrite(sock: c_int, bytes: []const u8, deadline: i64) Err!void {
+/// The reader's answer to a server request: written now if the socket is
+/// free, else queued for the query writing (bounded; one that does not fit is
+/// dropped, and the server's request goes unanswered).
+fn answerServer(c: *Conn, io: std.Io, sock: c_int, body: []const u8) void {
+ var hdr: [64]u8 = undefined;
+ const h = std.fmt.bufPrint(&hdr, "Content-Length: {d}\r\n\r\n", .{body.len}) catch return;
+ c.replies_mu.lockUncancelable(io);
+ const half = &c.replies[c.filling];
+ const len = &c.replies_len[c.filling];
+ if (len.* + h.len + body.len <= half.len) {
+ @memcpy(half[len.*..][0..h.len], h);
+ @memcpy(half[len.* + h.len ..][0..body.len], body);
+ len.* += h.len + body.len;
+ }
+ c.replies_mu.unlock(io);
+ if (c.write_mu.tryLock()) releaseWrite(c, io, sock);
+}
+
+/// Lets the socket go, first sending what the reader queued meanwhile, and
+/// again for what it queues while that goes out.
+fn releaseWrite(c: *Conn, io: std.Io, sock: c_int) void {
+ while (true) {
+ c.replies_mu.lockUncancelable(io);
+ const sent = c.filling;
+ const n = c.replies_len[sent];
+ if (n > 0) c.filling ^= 1;
+ c.replies_mu.unlock(io);
+ if (n > 0) {
+ var started = false;
+ sockWrite(null, sock, c.replies[sent][0..n], nowMs() + reply_ms, &started) catch {};
+ c.replies_len[sent] = 0;
+ }
+ c.write_mu.unlock(io);
+ c.replies_mu.lockUncancelable(io);
+ const more = c.replies_len[c.filling] > 0;
+ c.replies_mu.unlock(io);
+ if (!more or !c.write_mu.tryLock()) return;
+ }
+}
+
+/// Writes `bytes`, `started` once any byte of their message is out. Before
+/// then, the deadline and a cancel stop it; after, the message is finished
+/// however long the server takes to read it (bounded by wedge_ms), since
+/// half of one ends the server's reading of every message after it.
+fn sockWrite(io: ?std.Io, sock: c_int, bytes: []const u8, deadline: i64, started: *bool) Err!void {
var off: usize = 0;
while (off < bytes.len) {
- const left = deadline - nowMs();
- if (left <= 0) return error.Timeout;
+ if (!started.*) {
+ if (deadline - nowMs() <= 0) return error.Timeout;
+ if (io) |cancel_io| cancel_io.checkCancel() catch return error.Canceled;
+ } else if (nowMs() - deadline > wedge_ms) return error.Dead;
var pfd = [_]libc.pollfd{.{ .fd = sock, .events = POLLOUT, .revents = 0 }};
- const pr = libc.poll(&pfd, 1, @intCast(@min(left, 1000)));
+ const pr = libc.poll(&pfd, 1, 500);
if (pr < 0) {
if (libc.errno(pr) == .INTR) continue;
return error.Dead;
@@ -2096,6 +2367,7 @@ fn sockWrite(sock: c_int, bytes: []const u8, deadline: i64) Err!void {
return error.Dead;
}
if (n == 0) return error.Dead;
+ started.* = true;
off += @intCast(n);
}
}
@@ -2318,7 +2590,7 @@ test "caller trees reverse incoming paths and merge shared callers and sites" {
try std.testing.expectEqual(@as(usize, 1), tree.roots.items.len);
try std.testing.expectEqual(@as(usize, 4), tree.nodes.items.len);
const root = tree.nodes.items[tree.roots.items[0]];
- try std.testing.expectEqualStrings("main", str(get(root.item, "name")).?);
+ try std.testing.expectEqualStrings("main", root.call.name);
try std.testing.expectEqual(@as(usize, 1), root.ranges.items.len);
const page = tree.nodes.items[root.children.items[0]];
try std.testing.expectEqual(@as(usize, 2), page.children.items.len);
@@ -2355,6 +2627,32 @@ test "caller trees reverse incoming paths and merge shared callers and sites" {
try std.testing.expect(recursive.nodes.items[1].cycle);
}
+test "test callers sort after the rest, each group by place" {
+ var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
+ defer arena_state.deinit();
+ const arena = arena_state.allocator();
+ const fixture = try std.json.parseFromSliceLeaky(std.json.Value, arena, "[{\"name\":\"test b\",\"uri\":\"file:///a.zig\",\"selectionRange\":{\"start\":{\"line\":0,\"character\":0},\"end\":{\"line\":0,\"character\":1}}},{\"name\":\"z\",\"uri\":\"file:///b.zig\",\"selectionRange\":{\"start\":{\"line\":0,\"character\":0},\"end\":{\"line\":0,\"character\":1}}},{\"name\":\"x\",\"uri\":\"file:///a_test.zig\",\"selectionRange\":{\"start\":{\"line\":0,\"character\":0},\"end\":{\"line\":0,\"character\":1}}},{\"name\":\"y\",\"uri\":\"file:///a.zig\",\"selectionRange\":{\"start\":{\"line\":5,\"character\":0},\"end\":{\"line\":5,\"character\":1}}}]", .{});
+ var tree: CallTree = .{};
+ for (items(fixture)) |item| try tree.nodes.append(arena, .{ .call = try callOf(arena, item) });
+ var order = [_]usize{ 0, 1, 2, 3 };
+ std.mem.sort(usize, &order, @as(*const CallTree, &tree), callerLess);
+ try std.testing.expectEqualSlices(usize, &.{ 3, 1, 0, 2 }, &order);
+}
+
+test "a mailbox wait is a cancelation point: a canceled worker stops waiting" {
+ const io = std.testing.io;
+ var c: Conn = .{};
+ const Waiter = struct {
+ fn run(conn: *Conn, wio: std.Io) error{Canceled}!void {
+ conn.mu.lockUncancelable(wio);
+ defer conn.mu.unlock(wio);
+ while (true) _ = try timedWait(conn, wio, nowMs() + 60_000);
+ }
+ };
+ var future = try io.concurrent(Waiter.run, .{ &c, io });
+ try std.testing.expectError(error.Canceled, future.cancel(io));
+}
+
test "callstack cross-crate paths remain resolvable without absolute path clutter" {
var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena_state.deinit();
@@ -2584,37 +2882,38 @@ test "a language with no server to start says so, not that it did not answer" {
defer arena.deinit();
var buf: [256]u8 = undefined;
var out: std.Io.Writer = .fixed(&buf);
- try query(std.testing.allocator, arena.allocator(), .{ .kind = .hover, .path = "/x/a.py", .source = "", .offset = 0 }, &out);
+ try query(std.testing.io, std.testing.allocator, arena.allocator(), .{ .kind = .hover, .path = "/x/a.py", .source = "", .offset = 0 }, &out);
try std.testing.expectEqualStrings("@none language server for .py not found\n", out.buffered());
}
test "Lspinfo before any query says a server is not started yet, not off" {
var out: std.Io.Writer.Allocating = .init(std.testing.allocator);
defer out.deinit();
- try status(.{ .kind = .status, .path = "", .source = "", .offset = 0 }, &out.writer);
+ try status(std.testing.io, .{ .kind = .status, .path = "", .source = "", .offset = 0 }, &out.writer);
try std.testing.expect(std.mem.indexOf(u8, out.written(), "not started yet (its first query starts it)") != null);
}
test "a server that failed a moment ago is said to have failed, and when it is tried again, not to be missing" {
if (getenv("PARDES_LSP_ZIG") != null) return error.SkipZigTest;
+ const io = std.testing.io;
const si = specFor("/x/a.zig").?;
const c = &conns[si];
- c.lock();
+ c.mu.lockUncancelable(io);
const was = .{ c.state, c.retry_after_ms };
c.state = .dead;
c.retry_after_ms = nowMs() + 4500;
- c.unlock();
+ c.mu.unlock(io);
defer {
- c.lock();
+ c.mu.lockUncancelable(io);
c.state = was[0];
c.retry_after_ms = was[1];
- c.unlock();
+ c.mu.unlock(io);
}
var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
defer arena.deinit();
var out: std.Io.Writer.Allocating = .init(std.testing.allocator);
defer out.deinit();
- try query(std.testing.allocator, arena.allocator(), .{ .kind = .hover, .path = "/x/a.zig", .source = "", .offset = 0 }, &out.writer);
+ try query(std.testing.io, std.testing.allocator, arena.allocator(), .{ .kind = .hover, .path = "/x/a.zig", .source = "", .offset = 0 }, &out.writer);
try std.testing.expect(std.mem.indexOf(u8, out.written(), "zls failed recently; retry in 5s") != null);
}
diff --git a/src/macos.zig b/src/macos.zig
index 50fa04fa..5d3dfec4 100644
--- a/src/macos.zig
+++ b/src/macos.zig
@@ -44,7 +44,11 @@ fn hostWatchFile(pane: u8, generation: u32, path: ?[*]const u8, path_len: usize)
const TIOCSWINSZ: c_int = @bitCast(@as(u32, if (@hasDecl(posix.T, "IOCSWINSZ")) posix.T.IOCSWINSZ else 0x80087467));
-pub const std_options: std.Options = .{ .logFn = logFn };
+// Every thread's alternate signal stack is a threadlocal that libc zeroes as
+// the thread starts, so std's 256 KiB made each 9P connection's thread cost
+// that much resident. A stack-overflow segfault on a thread still printed its
+// whole symbolized trace from 32 KiB up (16 KiB double-faulted): 64 KiB.
+pub const std_options: std.Options = .{ .logFn = logFn, .signal_stack_size = 64 * 1024 };
fn logFn(
comptime level: std.log.Level,
@@ -2419,7 +2423,7 @@ fn pipeWorker(st: *State, job: *selection_pipe.Job) anyerror!void {
}
fn lspWorker(st: *State, job: *host_io.Lsp.Job) anyerror!void {
- host_io.Lsp.work(st.gpa, job, st, deliverLspRows);
+ host_io.Lsp.work(st.io, st.gpa, job, st, deliverLspRows);
}
fn deliverLspRows(ctx: ?*anyopaque, id: u32, rows: ?[]u8) void {
@@ -2582,12 +2586,11 @@ fn reap(st: *State, pane: u8) void {
}
fn readPty(st: *State, io: std.Io, pty: std.Io.File, id: u8, gen: u32) anyerror!void {
- var read_buf: [0x10000]u8 = undefined;
- var reader = pty.readerStreaming(io, &read_buf);
+ // One buffer, read into directly: a Reader around it only added a second
+ // (and in a safe build, filled both as `undefined` on every start).
+ var buf: [0x10000]u8 = undefined;
while (true) {
- var buf: [0x10000]u8 = undefined;
- var vec = [_][]u8{&buf};
- const n = reader.interface.readVec(&vec) catch break;
+ const n = pty.readStreaming(io, &.{&buf}) catch break;
if (n == 0) break;
const bytes = st.gpa.dupe(u8, buf[0..n]) catch break;
st.inbox.pushOutput(st.gpa, io, .{ .pane = id, .gen = gen, .bytes = bytes }) catch break;
diff --git a/src/main.zig b/src/main.zig
index 64614daa..ea2db917 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -16,7 +16,11 @@ pub const std_options_debug_io: std.Io = if (is_emscripten)
else
std_options_debug_threaded_io.?.io();
-pub const std_options: std.Options = .{ .logFn = logFn };
+// Every thread's alternate signal stack is a threadlocal that libc zeroes as
+// the thread starts, so std's 256 KiB made each 9P connection's thread cost
+// that much resident. A stack-overflow segfault on a thread still printed its
+// whole symbolized trace from 32 KiB up (16 KiB double-faulted): 64 KiB.
+pub const std_options: std.Options = .{ .logFn = logFn, .signal_stack_size = 64 * 1024 };
fn logFn(
comptime level: std.log.Level,
@@ -328,7 +332,11 @@ fn webMain() !void {
// malloc otherwise. Kept on purpose: glibc's malloc was measured at least as
// fast as std.heap.smp_allocator on every scenario and faster on MuPDF's
// page-sized rasters. macos.zig makes the same choice for itself.
-fn nativeMain(init: std.process.Init) !void {
+fn nativeMain(std_init: std.process.Init) !void {
+ var init = std_init;
+ // Zig 0.17's std.start gives a safe build a SafeAllocator over the page
+ // allocator, not libc's malloc: hand the shells malloc, as above.
+ if (builtin.mode != .debug) init.gpa = std.heap.c_allocator;
var stderr_probe: [64]u8 = undefined;
_ = std.debug.lockStderr(&stderr_probe);
std.debug.unlockStderr();
diff --git a/src/memory.zig b/src/memory.zig
index 48403c55..853d641a 100644
--- a/src/memory.zig
+++ b/src/memory.zig
@@ -16,6 +16,10 @@ pub const limits = struct {
pub const pending_write_cap: usize = if (board) 0 else 4 * MiB;
pub const wrap_rows = if (board) 128 else 256;
pub const undo_max = if (board) 16 else 256;
+ /// The text a file's undo and redo steps hold together, kept by dropping
+ /// the oldest; the newest step always stays, so the bound per file is
+ /// this plus one snapshot (at most max_file_bytes).
+ pub const undo_bytes: usize = if (board) 64 * KiB else 64 * MiB;
pub const message_log = if (board) 16 else 128;
/// ranges one selection holds; helix has no limit, and a `%s` over a
/// file's words wants hundreds
@@ -23,6 +27,19 @@ pub const limits = struct {
/// /log's ring, which records whether or not anyone reads it.
pub const log_bytes: usize = if (board) 4 * KiB else 64 * KiB;
pub const max_tag_tail: usize = if (board) 512 else 4096;
+ /// Pixels one image may decode to (RGBA, 4 bytes each): checked from its
+ /// header before stb_image allocates them.
+ pub const image_decode_pixels: usize = if (board) 0 else 64 * 1024 * 1024;
+ /// What the core's per-step scratch arena and the frame arena keep
+ /// between steps: a step that needed more (a huge Callstack's sources)
+ /// gives the rest back instead of holding its high-water mark.
+ pub const scratch_kept: usize = if (board) 4 * KiB else 16 * MiB;
+ pub const frame_kept: usize = if (board) 4 * KiB else 16 * MiB;
+ /// The other open files one language query copies for its server, in
+ /// bytes: past it the rest are left out (the asked file always goes).
+ pub const lsp_snapshot_bytes: usize = if (board) 0 else 64 * MiB;
+ /// One paste, from any shell: past it, the rest is left out and said.
+ pub const max_paste_bytes: usize = if (board) 16 * KiB else 4 * MiB;
pub const host_path_cap: usize = if (board) 0 else 4095;
/// -Dembed-sources: the editor serves its own sources under /src.
pub const embedded_sources = config.embed_sources;
@@ -34,6 +51,10 @@ pub const limits = struct {
pub const tree_sitter = if (board) 0 else if (reduced_target) 4 * MiB else 16 * MiB;
pub const image = if (board) 0 else if (reduced_target) 64 * KiB else 32 * MiB;
pub const pdf = if (board) 0 else if (reduced_target or !config.mupdf) 64 * KiB else 64 * MiB;
+ /// One language query's working memory (its parsed answers, the rows
+ /// it writes): a hard bound, nothing spills. Callstack walks until it
+ /// would leave less than its rendering reserve.
+ pub const lsp_query = if (board or reduced_target) 0 else 256 * MiB;
};
};
@@ -96,6 +117,82 @@ var frame_buffer: [limits.arena.frame]u8 = @splat(0);
var tree_sitter_buffer: [limits.arena.tree_sitter]u8 = @splat(0);
var image_buffer: [limits.arena.image]u8 = @splat(0);
var pdf_buffer: [limits.arena.pdf]u8 = @splat(0);
+var lsp_query_buffer: [limits.arena.lsp_query]u8 align(std.heap.page_size_max) = @splat(0);
+var lsp_query_busy: std.atomic.Value(bool) = .init(false);
+/// What a query may leave resident of the region (giveLspQuery).
+const lsp_query_kept = 8 * MiB;
+
+/// The language query region, for the one query running; null while another
+/// holds it (the shells cancel and join a query before starting the next).
+pub fn takeLspQuery() ?[]u8 {
+ if (lsp_query_busy.swap(true, .acquire)) return null;
+ return &lsp_query_buffer;
+}
+
+/// Gives the region back after a query. A big one's touched pages go back to
+/// the system (zeroed again on their next touch, as .bss is), so one huge
+/// answer does not stay resident; a small one's stay, for the next query to
+/// reuse without faulting them in again.
+pub fn giveLspQuery(used: usize) void {
+ if (comptime builtin.os.tag == .linux) if (used > lsp_query_kept) {
+ const page = std.heap.pageSize();
+ const len = std.mem.alignForward(usize, @min(used, lsp_query_buffer.len), page);
+ std.posix.madvise(@as([*]align(std.heap.page_size_min) u8, @ptrCast(&lsp_query_buffer)), len, std.posix.MADV.DONTNEED) catch {};
+ };
+ lsp_query_busy.store(false, .release);
+}
+
+/// `n` bytes as they come: `Allocator.alloc` fills a safe build's new memory
+/// as `undefined` (0xAA), which writes, and makes resident, all of a buffer
+/// sized for the worst case: every language query wrote its 51 MB answer
+/// room, every search its 16 MiB. For buffers written before they are read.
+pub fn unfilled(allocator: Allocator, n: usize) Allocator.Error![]u8 {
+ if (n == 0) return allocator.alloc(u8, 0);
+ const ptr = allocator.rawAlloc(n, .of(u8), @returnAddress()) orelse return error.OutOfMemory;
+ return ptr[0..n];
+}
+
+/// `bytes` copied into memory `unfilled` takes: a text-sized copy (an undo
+/// snapshot) is written once, not filled first.
+pub fn dupeUnfilled(allocator: Allocator, bytes: []const u8) Allocator.Error![]u8 {
+ const out = try unfilled(allocator, bytes.len);
+ @memcpy(out, bytes);
+ return out;
+}
+
+/// Frees without the safe-build overwrite `free` does, for text-sized buffers
+/// freed on every edit.
+pub fn freeUnfilled(allocator: Allocator, bytes: []const u8) void {
+ if (bytes.len > 0) allocator.rawFree(@constCast(bytes), .of(u8), @returnAddress());
+}
+
+/// Gives libc's free memory back to the system, inside its heap too: after a
+/// big result is formatted or a big pane torn down, glibc keeps what was freed
+/// (a V8 Callstack page left 21 MiB free in the heap; this returned 20).
+/// Walks the heap, so for rare, large events only.
+pub fn trim() void {
+ if (comptime builtin.os.tag != .linux or builtin.abi.isMusl() or !builtin.link_libc) return;
+ const glibc = struct {
+ extern "c" fn malloc_trim(pad: usize) c_int;
+ };
+ _ = glibc.malloc_trim(0);
+}
+
+/// Marks a big region that is touched sparsely as not for huge pages. With
+/// transparent huge pages on `always` (a common default), touching one byte
+/// of a 2 MiB-aligned stretch makes all 2 MiB resident: the 9P runner's
+/// slots and these arenas' first pages held 45 MiB of an idle session's
+/// 71 MiB that way. Only the region given, never the whole process (a prctl
+/// would reach every shell and server pardes starts).
+pub fn sparse(region: []u8) void {
+ if (comptime builtin.os.tag != .linux) return;
+ const page = std.heap.pageSize();
+ const start = std.mem.alignForward(usize, @intFromPtr(region.ptr), page);
+ const end = std.mem.alignBackward(usize, @intFromPtr(region.ptr) + region.len, page);
+ if (end <= start) return;
+ std.posix.madvise(@ptrFromInt(start), end - start, std.posix.MADV.NOHUGEPAGE) catch {};
+}
+
var pardes_fallback: SharedStackFallback = .{ .buffer = &pardes_buffer };
var frame_fallback: SharedStackFallback = .{ .buffer = &frame_buffer };
var tree_sitter_fallback: SharedStackFallback = .{ .buffer = &tree_sitter_buffer };
@@ -118,6 +215,7 @@ pub fn init(fallback: Allocator) Allocators {
// a Debug build `fallback` is std.process.Init's gpa, a DebugAllocator
// already, and a second one checked every block twice.
const backing = if (debug_enabled) std.heap.page_allocator else fallback;
+ inline for (.{ &pardes_buffer, &frame_buffer, &tree_sitter_buffer, &image_buffer, &pdf_buffer, &lsp_query_buffer }) |buffer| sparse(buffer);
pardes_fallback.fallback_allocator = backing;
frame_fallback.fallback_allocator = backing;
tree_sitter_fallback.fallback_allocator = backing;
diff --git a/src/mini.zig b/src/mini.zig
index ce291c99..8d8ea0b2 100644
--- a/src/mini.zig
+++ b/src/mini.zig
@@ -313,7 +313,21 @@ test "Mini publishes only complete snapshots and content replacement drops metad
const dir = dir_buf[0..try tmp.dir.realPath(std.testing.io, &dir_buf)];
var path_buf: [4096]u8 = undefined;
const path = try std.fmt.bufPrint(&path_buf, "{s}/mini.txt", .{dir});
- try std.testing.checkAllAllocationFailures(std.testing.allocator, Case.run, .{path});
+ // Growth that never resizes in place: whether a resize fits where it is
+ // depends on the heap's layout, and with it how many allocations a run
+ // makes, which checkAllAllocationFailures needs to be the same each run.
+ const NoResize = struct {
+ fn resize(_: *anyopaque, _: []u8, _: std.mem.Alignment, _: usize, _: usize) bool {
+ return false;
+ }
+ fn remap(_: *anyopaque, _: []u8, _: std.mem.Alignment, _: usize, _: usize) ?[*]u8 {
+ return null;
+ }
+ };
+ const testing_vtable = std.testing.allocator.vtable;
+ const no_resize_vtable: std.mem.Allocator.VTable = .{ .alloc = testing_vtable.alloc, .resize = NoResize.resize, .remap = NoResize.remap, .free = testing_vtable.free };
+ const backing: std.mem.Allocator = .{ .ptr = std.testing.allocator.ptr, .vtable = &no_resize_vtable };
+ try std.testing.checkAllAllocationFailures(backing, Case.run, .{path});
}
test "Mini refuses a file that is no UTF-8, before its decoding could panic" {
diff --git a/src/modal.zig b/src/modal.zig
index 82f1a3a0..ad06833f 100644
--- a/src/modal.zig
+++ b/src/modal.zig
@@ -989,13 +989,77 @@ pub fn lineCount(content: []const u8) usize {
// byte offset of the start of line `row` (0-based). row may == lineCount()
// (== content.len, the end).
pub fn lineStartOffset(content: []const u8, row: usize) usize {
+ // Newlines counted 32 bytes at a time, the last block byte by byte: one
+ // indexOfScalarPos per line was a call per line, 7000 of them to find
+ // line 7000 of a source, for every cursor move, selection and language
+ // request there.
+ const block = 32;
+ const Block = @Vector(block, u8);
var off: usize = 0;
- var r: usize = 0;
- while (r < row) : (r += 1) {
- const nl = std.mem.indexOfScalarPos(u8, content, off, '\n') orelse return content.len;
- off = nl + 1;
+ var left = row;
+ if (left == 0) return 0;
+ while (off + block <= content.len) : (off += block) {
+ const chunk: Block = content[off..][0..block].*;
+ const found: usize = @popCount(@as(u32, @bitCast(chunk == @as(Block, @splat('\n')))));
+ if (found >= left) break;
+ left -= found;
}
- return off;
+ while (off < content.len) : (off += 1) if (content[off] == '\n') {
+ left -= 1;
+ if (left == 0) return off + 1;
+ };
+ return content.len;
+}
+
+test "lineStartOffset by blocks and offsetAt agree with a line at a time" {
+ var prng: std.Random.DefaultPrng = .init(0x9e3779b9);
+ const random = prng.random();
+ var buf: [300]u8 = undefined;
+ for (0..2000) |_| {
+ const len = random.uintLessThan(usize, buf.len);
+ for (buf[0..len]) |*b| b.* = if (random.uintLessThan(u8, 4) == 0) '\n' else 'a';
+ const text = buf[0..len];
+ for (0..len + 3) |row| {
+ var off: usize = 0;
+ var r: usize = 0;
+ const want = while (r < row) : (r += 1) {
+ off = (std.mem.indexOfScalarPos(u8, text, off, '\n') orelse break text.len) + 1;
+ } else off;
+ try std.testing.expectEqual(want, lineStartOffset(text, row));
+ const cursor: Cursor = .{ .row = row, .col = random.uintLessThan(usize, 6) };
+ const clamped = lineStartOffset(text, @min(row, cursorLineCount(text) - 1));
+ const end = std.mem.indexOfScalarPos(u8, text, clamped, '\n') orelse text.len;
+ try std.testing.expectEqual(clamped + graphemeStart(text[clamped..end], @min(cursor.col, end - clamped)), offsetAt(text, cursor));
+ // lineSpan, as it was: a line at a time, null past the last.
+ const span: ?LineSpan = span: {
+ if (text.len == 0) break :span null;
+ var start: usize = 0;
+ for (0..row) |_| start = (std.mem.indexOfScalarPos(u8, text, start, '\n') orelse break :span null) + 1;
+ if (start == text.len and !(row == 0 or text[text.len - 1] == '\n')) break :span null;
+ break :span .{ .start = start, .end = std.mem.indexOfScalarPos(u8, text, start, '\n') orelse text.len };
+ };
+ try std.testing.expectEqual(span, lineSpan(text, row));
+ // rangeBytes, as it was: each line looked for from the top, twice.
+ const other: Cursor = .{ .row = random.uintLessThan(usize, len + 3), .col = random.uintLessThan(usize, 6) };
+ var lo = cursor;
+ var hi = other;
+ if (hi.row < lo.row or (hi.row == lo.row and hi.col < lo.col)) std.mem.swap(Cursor, &lo, &hi);
+ const lo_line = lineSlice(text, lo.row);
+ const hi_line = lineSlice(text, hi.row);
+ const s0 = lineStartOffset(text, lo.row) + graphemeStart(lo_line, @min(lo.col, lo_line.len));
+ var e0 = lineStartOffset(text, hi.row) + graphemeStart(hi_line, @min(hi.col, hi_line.len));
+ if (e0 < text.len) e0 = nextGrapheme(text, e0);
+ const got = rangeBytes(text, cursor, other);
+ try std.testing.expectEqual(s0, got.s);
+ try std.testing.expectEqual(@max(s0, e0), got.e);
+ }
+ }
+}
+
+/// The line that starts at `start` (lineSlice's, once its start is known).
+fn lineFrom(content: []const u8, start: usize) []const u8 {
+ if (start >= content.len) return "";
+ return content[start .. std.mem.indexOfScalarPos(u8, content, start, '\n') orelse content.len];
}
// the text of line `row` (no terminator), a slice into `content`.
@@ -1011,23 +1075,29 @@ pub fn lineSlice(content: []const u8, row: usize) []const u8 {
/// A bounded scan of one line; null if the row does not exist.
pub const LineSpan = struct { start: usize, end: usize };
+/// Just past the `row`-th newline; null if the text has fewer.
+pub fn lineStartExact(content: []const u8, row: usize) ?usize {
+ const at = lineStartOffset(content, row);
+ // At the end: either the row-th newline was the last byte, or there were fewer.
+ if (at == content.len and std.mem.count(u8, content, "\n") < row) return null;
+ return at;
+}
+
pub fn lineSpan(content: []const u8, row: usize) ?LineSpan {
// Match lineCount: empty content has no lines; a trailing newline adds one.
if (content.len == 0) return null;
- var start: usize = 0;
- var r: usize = 0;
- while (r < row) : (r += 1) {
- const nl = std.mem.indexOfScalarPos(u8, content, start, '\n') orelse return null;
- start = nl + 1;
- }
- if (start > content.len) return null;
+ const start = lineStartExact(content, row) orelse return null;
if (start == content.len and !(row == 0 or content.len == 0 or content[content.len - 1] == '\n')) return null;
const end = std.mem.indexOfScalarPos(u8, content, start, '\n') orelse content.len;
return .{ .start = start, .end = end };
}
-fn spliceAlloc(alloc: std.mem.Allocator, content: []const u8, start: usize, end: usize, replacement: []const u8) ![]u8 {
- const out = try alloc.alloc(u8, content.len - (end - start) + replacement.len);
+pub fn spliceAlloc(alloc: std.mem.Allocator, content: []const u8, start: usize, end: usize, replacement: []const u8) ![]u8 {
+ // Raw: every byte is written below, where `alloc` fills a safe build's
+ // new memory first, a whole file's worth per keystroke.
+ const len = content.len - (end - start) + replacement.len;
+ if (len == 0) return alloc.alloc(u8, 0);
+ const out = (alloc.rawAlloc(len, .of(u8), @returnAddress()) orelse return error.OutOfMemory)[0..len];
@memcpy(out[0..start], content[0..start]);
@memcpy(out[start..][0..replacement.len], replacement);
@memcpy(out[start + replacement.len ..], content[end..]);
@@ -1036,13 +1106,18 @@ fn spliceAlloc(alloc: std.mem.Allocator, content: []const u8, start: usize, end:
/// insert `text` at (row, col). col is clamped to the line length.
pub fn insertAt(alloc: std.mem.Allocator, content: []const u8, c: Cursor, text: []const u8) ![]u8 {
+ const off = insertOffset(content, c);
+ return spliceAlloc(alloc, content, off, off, text);
+}
+
+/// Where insertAt puts its text: col clamped to the line, no further.
+pub fn insertOffset(content: []const u8, c: Cursor) usize {
// Only an out-of-range row requires counting the whole document.
const span = lineSpan(content, c.row) orelse blk: {
const last = lineCount(content) -| 1;
break :blk lineSpan(content, last) orelse LineSpan{ .start = content.len, .end = content.len };
};
- const off = span.start + @min(c.col, span.end - span.start);
- return spliceAlloc(alloc, content, off, off, text);
+ return span.start + @min(c.col, span.end - span.start);
}
// delete the character at (row, col). no-op if col is past the line end.
@@ -1105,12 +1180,15 @@ fn rangeBytes(content: []const u8, a: Cursor, b: Cursor) struct { s: usize, e: u
lo = b;
hi = a;
}
- const lo_line = lineSlice(content, lo.row);
- const hi_line = lineSlice(content, hi.row);
+ // Each line found once, the second from the first.
+ const lo_start = lineStartOffset(content, lo.row);
+ const hi_start = if (hi.row == lo.row) lo_start else lo_start + lineStartOffset(content[lo_start..], hi.row - lo.row);
+ const lo_line = lineFrom(content, lo_start);
+ const hi_line = lineFrom(content, hi_start);
const lo_col = graphemeStart(lo_line, @min(lo.col, lo_line.len));
const hi_col = graphemeStart(hi_line, @min(hi.col, hi_line.len));
- const s = lineStartOffset(content, lo.row) + lo_col;
- var e = lineStartOffset(content, hi.row) + hi_col;
+ const s = lo_start + lo_col;
+ var e = hi_start + hi_col;
if (e < content.len) e = nextGrapheme(content, e); // include the grapheme under the head
return .{ .s = s, .e = @max(s, e) };
}
@@ -1138,12 +1216,12 @@ pub fn clearLine(alloc: std.mem.Allocator, content: []const u8, row: usize) ![]u
// paste `text` as a new line BELOW `row`. Multiline `text` becomes several lines.
pub fn pasteLineBelow(alloc: std.mem.Allocator, content: []const u8, row: usize, text: []const u8) ![]u8 {
- const n = lineCount(content);
- const off = if (row + 1 < n) lineStartOffset(content, row + 1) else content.len;
+ // The next line's start, or the end: no whole-text line count to know which.
+ const off = lineStartExact(content, row + 1) orelse content.len;
const suffix_newline = off < content.len or (content.len > 0 and content[content.len - 1] == '\n');
const prefix_newline = !suffix_newline and off > 0;
const extra: usize = @intFromBool(suffix_newline or prefix_newline);
- const out = try alloc.alloc(u8, content.len + text.len + extra);
+ const out = try @import("memory.zig").unfilled(alloc, content.len + text.len + extra);
var write: usize = 0;
@memcpy(out[write..][0..off], content[0..off]);
write += off;
@@ -1393,8 +1471,10 @@ pub fn positionAt(text: []const u8, off: usize) Cursor {
/// (row, col) -> clamped gap offset; col == line length lands ON the '\n'
pub fn offsetAt(text: []const u8, c: Cursor) usize {
- const row = @min(c.row, cursorLineCount(text) - 1);
- const s = lineStartOffset(text, row);
+ // A row past the last is the last: found back from the end, where
+ // counting every line of the text to clamp it cost a pass over all of it.
+ var s = lineStartOffset(text, c.row);
+ if (s == text.len) s = if (std.mem.lastIndexOfScalar(u8, text, '\n')) |nl| nl + 1 else 0;
// lineEndOffset(text, row) inlined: it starts by walking to `row` again,
// and we are already standing there
const e = std.mem.indexOfScalarPos(u8, text, s, '\n') orelse text.len;
@@ -1783,15 +1863,6 @@ test "selection textobjects distinguish words and paragraph boundaries" {
try std.testing.expectEqual(@as(usize, 7), r.head);
}
-/// leading-whitespace visual width (tab -> next multiple of INDENT_W)
-pub fn indentWidth(line: []const u8) usize {
- var w: usize = 0;
- for (line) |ch| {
- if (ch == ' ') w += 1 else if (ch == '\t') w = (w / INDENT_W + 1) * INDENT_W else break;
- }
- return w;
-}
-
/// A line's indent as it is, tabs and spaces both, as acme's autoindent
/// copies it: what o/O/insert-newline give the new line.
pub fn indentText(line: []const u8) []const u8 {
diff --git a/src/mouse.zig b/src/mouse.zig
index 76c65a16..eeb987b2 100644
--- a/src/mouse.zig
+++ b/src/mouse.zig
@@ -1114,7 +1114,9 @@ fn mirrorTtySelection(p: *Pardes, pane: *Pane) void {
/// second selects what edit.doubleClickRange says, from the caret the click
/// left. A plain click still puts the caret on its cell.
fn doubleClick(p: *Pardes, id: usize, t: *panes.Text, on_tag: bool, row: i32, col: i32) void {
- const now = clockMs();
+ // The host's clock, which every host keeps (a libc clock is no clock on
+ // the web or the board) and a test's virtual one replaces.
+ const now: i64 = @intCast(p.now_ns / std.time.ns_per_ms);
const prev = p.last_click;
p.last_click = .{ .id = id, .on_tag = on_tag, .row = row, .col = col, .ms = now };
const c = prev orelse return;
@@ -1160,13 +1162,6 @@ fn sweepPoint(p: *Pardes, pane: *panes.Pane, r: i32, c: i32) ?modal.Cursor {
return .{ .row = @intCast(w.line), .col = @intCast(@max(0, col)) };
}
-fn clockMs() i64 {
- if (comptime !pardes.hosted) return 0;
- var ts: std.c.timespec = undefined;
- if (std.c.clock_gettime(.MONOTONIC, &ts) != 0) return 0;
- return @as(i64, ts.sec) * 1000 + @divTrunc(@as(i64, ts.nsec), 1_000_000);
-}
-
fn dragRelease(p: *Pardes, button: Mouse.Button) void {
// A different button's release belongs to a chord or another host
// stream; only the button which began this gesture may end it.
diff --git a/src/ninep/addr.zig b/src/ninep/addr.zig
index 86d2d49e..7753c94d 100644
--- a/src/ninep/addr.zig
+++ b/src/ninep/addr.zig
@@ -239,21 +239,15 @@ pub const Addr = struct {
k = @intFromBool(a.text[p] == '\n');
p += 1;
}
- while (k < n) {
- if (p >= nc) {
+ if (k < n) {
+ p = nthLineAfter(a.text, p, n - k) orelse {
a.err = e_range;
return null;
- }
- if (a.text[p] == '\n') k += 1;
- p += 1;
+ };
}
p1 = p;
}
- while (p < nc) {
- const ch = a.text[p];
- p += 1;
- if (ch == '\n') break;
- }
+ p = if (std.mem.indexOfScalarPos(u8, a.text, p, '\n')) |nl| nl + 1 else nc;
return .{ .q0 = clip(p1), .q1 = clip(p) };
}
@@ -678,3 +672,31 @@ test "a line just past the last newline is an empty one there, as sam's lineaddr
try testing.expectEqual(Status.ok, th.wr(p, Node.of(th.serialOf(p), .ctl), "Edit 1i/header/\n").reply.status);
try testing.expectEqualStrings("header", p.panes[0].?.file.?.content);
}
+
+/// Just past the `count`-th newline at or after `from`; null if the text has
+/// fewer. Counted a block at a time (modal.lineStartOffset), where a byte at
+/// a time made `echo 7000 > addr` walk every byte above line 7000.
+fn nthLineAfter(text: []const u8, from: usize, count: usize) ?usize {
+ return from + (modal.lineStartExact(text[from..], count) orelse return null);
+}
+
+test "nthLineAfter finds what a byte at a time finds" {
+ var prng: std.Random.DefaultPrng = .init(0x51ab);
+ const random = prng.random();
+ var buf: [200]u8 = undefined;
+ for (0..3000) |_| {
+ const len = random.uintLessThan(usize, buf.len);
+ for (buf[0..len]) |*b| b.* = if (random.uintLessThan(u8, 3) == 0) '\n' else 'x';
+ const text = buf[0..len];
+ const from = random.uintLessThan(usize, len + 1);
+ const count = 1 + random.uintLessThan(usize, 40);
+ var p = from;
+ var k: usize = 0;
+ const want: ?usize = while (k < count) {
+ if (p >= text.len) break null;
+ if (text[p] == '\n') k += 1;
+ p += 1;
+ } else p;
+ try std.testing.expectEqual(want, nthLineAfter(text, from, count));
+ }
+}
diff --git a/src/ninep/ctl.zig b/src/ninep/ctl.zig
index 733d9c8e..480c1dc7 100644
--- a/src/ninep/ctl.zig
+++ b/src/ninep/ctl.zig
@@ -4684,6 +4684,10 @@ test "what a /pager open writes after its directory is the text: plain in the bo
// An edit drops the colours (pager.zig's ponytail).
try testing.expectEqual(Status.ok, call(p, .{ .tag = 6, .op = .write, .node = Node.of(pn.serial, .body), .data = "more\n" }).reply.status);
try testing.expectEqual(@as(usize, 0), f.pager_spans.len);
+ // Undone back to the paged text: its colours come back with it.
+ panes.File.undo(p, pn);
+ try testing.expectEqualStrings("red /a\nNext\n", f.content);
+ try testing.expectEqual(@as(usize, 2), f.pager_spans.len);
// PagerColor off, and an open closed with no read: the same text, plain,
// in at the editor's next step (a close through a mount never waits).
diff --git a/src/panes.zig b/src/panes.zig
index 7ce85419..b535993e 100644
--- a/src/panes.zig
+++ b/src/panes.zig
@@ -133,6 +133,9 @@ pub const Pane = struct {
/// Its pty is still open: a job the command left in the background may
/// be printing to it, and a reuse would hang it up.
command_pty: bool = false,
+ /// Its child pages as a terminal's does (`pardes -`, a +Pager), not
+ /// through cat: Look's `git show` of a commit (look.lookCommit).
+ command_pages: bool = false,
/// The shell a terminal runs when it is not the configured one (`Tty
/// fish`), owned.
shell: ?[]u8 = null,
diff --git a/src/pardes.zig b/src/pardes.zig
index aaa9d177..c2a3ba21 100644
--- a/src/pardes.zig
+++ b/src/pardes.zig
@@ -478,6 +478,7 @@ pub const Loc = struct {
};
test {
+ _ = @import("modal.zig");
_ = @import("tagline.zig");
_ = @import("hunks.zig");
_ = @import("builtins_json.zig");
@@ -4645,6 +4646,10 @@ pub const Pardes = struct {
/// The last query asked (Lspwhy explains it): its kind, argument, and
/// the pane and place it was asked at.
lsp_last: ?struct { kind: lsp.Kind, arg: Effect.Buf(128), serial: u32, offset: u32 } = null,
+ /// The Callstack page `+Callstack` shows stopped short: its file's pane,
+ /// the place it was asked at, and the direct caller the next page starts
+ /// at. Callstack run in `+Callstack` asks for it.
+ callstack_more: ?struct { serial: u32, offset: u32, next: Effect.Buf(128) } = null,
lsp_wait: ?struct {
id: u32,
kind: lsp.Kind,
@@ -5168,10 +5173,13 @@ pub const Pardes = struct {
}
fn reapPanes(p: *Pardes) void {
+ var reaped = false;
for (&p.retired_panes.previous) |*slot| if (slot.*) |pane| {
p.teardownPane(pane);
slot.* = null;
+ reaped = true;
};
+ if (reaped) memory.trim();
p.retired_panes.previous = p.retired_panes.current;
p.retired_panes.current = @splat(null);
}
@@ -5544,7 +5552,7 @@ pub const Pardes = struct {
p.invalidate();
look.invalidateLookHover(p, id);
const applied = p.applyWatchedFileChanged(id, bytes);
- _ = p.scratch.reset(.retain_capacity);
+ _ = p.scratch.reset(.{ .retain_with_limit = memory.limits.scratch_kept });
p.sync();
return applied;
}
@@ -6000,7 +6008,7 @@ pub const Pardes = struct {
// A pty streaming into an unwatched session spent most of its time
// drawing what nobody looked at.
if (v.watched) |f| if (!f(h.ctx)) return;
- _ = p.frame_arena.reset(.retain_capacity);
+ _ = p.frame_arena.reset(.{ .retain_with_limit = memory.limits.frame_kept });
const surface = try p.render(p.frame_arena.allocator());
if (v.present) |f| f(h.ctx, surface);
// Settled before post_present: a shell ticks there, and what that
@@ -6202,7 +6210,7 @@ pub const Pardes = struct {
look.advanceLookHover(p);
},
}
- _ = p.scratch.reset(.retain_capacity);
+ _ = p.scratch.reset(.{ .retain_with_limit = memory.limits.scratch_kept });
p.sync();
p.fsReport();
ctlfs.events.announce(p);
@@ -6777,6 +6785,19 @@ pub const Pardes = struct {
pub const SavePath = Effect.Buf(effect_path_cap);
pub fn lspRequest(p: *Pardes, asked: usize, kind: lsp.Kind, arg_in: []const u8) void {
+ p.lspRequestAt(asked, kind, arg_in, null);
+ }
+
+ /// The next page of the Callstack `+Callstack` shows, asked where the
+ /// first was.
+ pub fn callstackMore(p: *Pardes, from: usize) void {
+ const more = p.callstack_more orelse return p.reportFailure(from, "Callstack: this is the last page; run it in a file to start again");
+ const id = p.paneBySerial(more.serial) orelse return p.reportFailure(from, "Callstack: the file it was asked in is closed");
+ p.lspRequestAt(id, .callstack, more.next.slice(), more.offset);
+ }
+
+ /// `lspRequest` at byte `at` of the pane's file rather than its cursor.
+ fn lspRequestAt(p: *Pardes, asked: usize, kind: lsp.Kind, arg_in: []const u8, at_byte: ?u32) void {
var arg = arg_in;
if (!normal.multiOnce(p)) return; // one question per keystroke, from the primary
// Lspwhy narrates the last query where it was asked -- that pane's
@@ -6800,7 +6821,7 @@ pub const Pardes = struct {
(!zig_buf and std.mem.indexOfAny(u8, arg, " \t\r\n\"\\") != null))
return p.reportFailure(id, std.fmt.bufPrint(&said, "Rename: {s} is no name", .{arg}) catch "Rename: no name");
}
- var off = if (pane.file) |f| modal.offsetAt(f.content, .{
+ var off = if (at_byte) |at| @min(at, if (pane.file) |f| f.content.len else 0) else if (pane.file) |f| modal.offsetAt(f.content, .{
.row = @intCast(@max(0, pane.body.cur_row)),
.col = @intCast(@max(0, pane.body.cur_col)),
}) else 0;
@@ -7089,13 +7110,24 @@ pub const Pardes = struct {
}
const dir = if (pane.file) |f| panes.Dir.ofName(f.path) else pane.cwdSlice();
- const content = p.gpa.dupe(u8, rows) catch return;
+ // A Callstack page that stops short ends in its marker: said as a
+ // row naming the word that shows the next page, and kept.
+ if (w.kind == .callstack) p.callstack_more = null;
+ const marker = if (w.kind == .callstack) std.mem.lastIndexOf(u8, rows, lsp.callstack_more) else null;
+ const content = if (marker) |at| more: {
+ var fields = std.mem.tokenizeAny(u8, rows[at + lsp.callstack_more.len ..], " \n");
+ const next = fields.next() orelse "";
+ const shown = fields.next() orelse "?";
+ if (p.lsp_last) |last| p.callstack_more = .{ .serial = w.serial, .offset = last.offset, .next = .from(next) };
+ break :more std.fmt.allocPrint(p.gpa, "{s}… {s} callers on this page, more after them: Callstack here shows the next page\n", .{ rows[0..at], shown }) catch return;
+ } else p.gpa.dupe(u8, rows) catch return;
const serial_before = p.next_serial;
p.fs.refilled = null;
panes.Output.fillResults(p, w.pane, dir, from, w.arg.slice(), content, null) catch |err| {
p.reportError(w.pane, "language response", err);
return;
};
+ if (rows.len >= 1 << 20) memory.trim();
// What a 9P write that asked it answers: the pane the rows are in
// (a multi-file Rename's preview, Lspinfo's +Lsp), made or filled
// again, not the pane it was asked from.
diff --git a/src/regexp.zig b/src/regexp.zig
index 4cbca57e..6d281859 100644
--- a/src/regexp.zig
+++ b/src/regexp.zig
@@ -283,7 +283,10 @@ pub const Regex = struct {
/// its top level and every branch starts with `^`; null when it is not
/// one, or no branch does.
fn anchoredAlternation(pat: []const u8, out: *[5 * max_ops + 2]u8) error{ Bad, Mixed }!?[]const u8 {
- var bars: [16]usize = undefined;
+ // No rewrite is longer than `out`, so neither is any pattern it
+ // takes, nor its count of bars.
+ if (pat.len > out.len) return error.Bad;
+ var bars: [5 * max_ops + 2]u16 = undefined;
var n: usize = 0;
var depth: usize = 0;
var in_class = false;
@@ -301,8 +304,7 @@ pub const Regex = struct {
} else if (c == ')') {
depth -|= 1;
} else if (c == '|' and depth == 0) {
- if (n == bars.len) return error.Bad;
- bars[n] = i;
+ bars[n] = @intCast(i);
n += 1;
}
}
@@ -518,6 +520,9 @@ test "a ^ after | anchors that branch: ^def|^ finds a line that starts either w
try std.testing.expectError(error.Mixed, Regex.compile("^def|x"));
var plain = try Regex.compile("a|b");
try std.testing.expectEqual(@as(usize, 7), (try plain.find(text, 0, text.len, text.len)).?.start);
+ // Seventeen branches and more are a pattern like any other.
+ var many = try Regex.compile("q|r|s|t|u|v|w|x|y|z|k|l|m|n|o|p|j|b");
+ try std.testing.expectEqual(@as(usize, 0), (try many.find(text, 0, text.len, text.len)).?.start);
}
test "a quoted backslash before n is no newline, and a class ends where mvzr ends it" {
diff --git a/src/sam_edit.zig b/src/sam_edit.zig
index f6253c89..94b76816 100644
--- a/src/sam_edit.zig
+++ b/src/sam_edit.zig
@@ -259,6 +259,10 @@ fn fail(why: *Why, comptime fmt: []const u8, args: anytype) Failure {
// ---- parsing: edit.c ----
+/// Commands one Edit may nest, loops (`x`, `y`, `g`, `v`, `X`, `Y`) and
+/// braces together: each level is a stack frame holding a compiled regex.
+pub const max_nest = 32;
+
const Parser = struct {
arena: std.mem.Allocator,
src: []const u8,
@@ -271,6 +275,9 @@ const Parser = struct {
open_text: bool = false,
/// The address being read had a `,` after a `"re"`.
file_comma: bool = false,
+ /// Commands open around the one being read, braces and loops alike:
+ /// each is a frame of `parse` and later of `execIn`, so it is bounded.
+ depth: u8 = 0,
why: *Why,
fn getch(ps: *Parser) ?u8 {
@@ -460,6 +467,9 @@ const Parser = struct {
/// edit.c:467, parsecmd.
fn parse(ps: *Parser, nest: u32) Failure!?*Cmd {
+ if (ps.depth >= max_nest) return fail(ps.why, "commands nested more than {d} deep", .{max_nest});
+ ps.depth += 1;
+ defer ps.depth -= 1;
var file_re: ?[]const u8 = null;
ps.file_comma = false;
const a = try ps.address(&file_re);
@@ -1163,6 +1173,11 @@ test "an Edit that fails halfway changes nothing, and says why in acme's words"
.{ "e /tmp/x", "can't open /tmp/x: no files here" },
.{ "\"zz\" p", "no file matches \"zz\"" },
.{ ",s/(a)/\\1/", "no \\1: mvzr keeps no submatches" },
+ .{ comptime deep: {
+ var loops: []const u8 = "";
+ for (0..40) |_| loops = loops ++ ",x/a/";
+ break :deep loops ++ "d";
+ }, "commands nested more than 32 deep" },
.{ "1 m 1,2", "move overlaps itself" },
.{ ",x/(^|\\n)foo/d", "bad regular expression: in a pattern with \\n, ^ can only come first and $ only just before a \\n" },
}) |c| {
diff --git a/src/selection_pipe.zig b/src/selection_pipe.zig
index c3e5e3a6..229b3d67 100644
--- a/src/selection_pipe.zig
+++ b/src/selection_pipe.zig
@@ -401,7 +401,7 @@ pub fn runIn(
},
};
child.stdin = null; // writer_context owns and closes this endpoint
- var writer: ?std.Thread = std.Thread.spawn(.{}, writeInput, .{writer_context}) catch {
+ var writer: ?std.Io.Future(void) = io.concurrent(writeInput, .{writer_context}) catch {
writer_context.file.close(io);
gpa.free(writer_context.input);
gpa.destroy(writer_context);
@@ -410,8 +410,9 @@ pub fn runIn(
};
// On every early return (a timeout, a ceiling) the answer goes at once:
// the group is killed and the shell left to be reaped elsewhere
- // (abandon), and the writer, which owns its input, let go.
- defer if (writer) |thread| thread.detach();
+ // (abandon), and the writer's write canceled (it closes and frees what
+ // it owns as it ends).
+ defer if (writer) |*w| w.cancel(io);
defer if (child.id != null) abandonNow(io, &child, pid);
defer if (token != 0) Running.remove(pid);
if (token != 0 and !Running.add(token, pid)) return fail.k(.signal);
@@ -443,7 +444,9 @@ pub fn runIn(
multi_reader.checkAnyError() catch return fail.k(.io);
if (token != 0) Running.remove(pid);
const term = child.wait(io) catch return fail.k(.io);
- writer.?.join();
+ // A cancel of this job reaches the write too: a grandchild that keeps
+ // stdin open and never reads holds no worker.
+ writer.?.await(io);
writer = null;
const stdout = multi_reader.toOwnedSlice(0) catch return fail.k(.io);
diff --git a/src/surface.zig b/src/surface.zig
index e67cf21c..d6ec016d 100644
--- a/src/surface.zig
+++ b/src/surface.zig
@@ -533,11 +533,6 @@ pub const Surface = struct {
return s.cell_diffs[@as(usize, y) * s.cols + x].changed();
}
- pub fn panelCellDiff(s: *const Surface, x: u16, y: u16) PanelCellDiff {
- if (!s.hasPanelDiff() or x >= s.cols or y >= s.rows) return .unchanged;
- return s.cell_diffs[@as(usize, y) * s.cols + x];
- }
-
pub fn at(s: *Surface, x: u16, y: u16) *Cell {
std.debug.assert(x < s.cols and y < s.rows);
return &s.cells[@as(usize, y) * s.cols + x];
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" {
diff --git a/src/tty/tty.zig b/src/tty/tty.zig
index 4cd1bc9a..afc0dbf0 100644
--- a/src/tty/tty.zig
+++ b/src/tty/tty.zig
@@ -34,6 +34,8 @@ var kitty_shm = std.atomic.Value(bool).init(false);
var kitty_shm_probing = std.atomic.Value(bool).init(false);
const kitty_shm_probe_id = 0x7fff_fff1;
var kitty_shm_serial: u32 = 0;
+/// Transmissions an unread shm segment outlives before it is removed.
+const kitty_shm_window = 64;
fn kittyShmName(buf: []u8, n: u32) ![:0]const u8 {
return std.fmt.bufPrintSentinel(buf, "/pardes-{d}-{d}", .{ libc.getpid(), n }, 0);
@@ -1787,6 +1789,13 @@ const Shell = struct {
if (!s.kitty.contains(key) and vx.caps.kitty_graphics and kitty_shm.load(.acquire)) shm: {
var buf: [64]u8 = undefined;
kitty_shm_serial +%= 1;
+ // Bounded: a segment this many transmissions old was never
+ // read (a terminal reads one as its command arrives), and a
+ // tmpfs holds it in memory until it goes.
+ if (kitty_shm_serial > kitty_shm_window) {
+ var old_buf: [64]u8 = undefined;
+ if (kittyShmName(&old_buf, kitty_shm_serial - kitty_shm_window)) |old| _ = libc.shm_unlink(old) else |_| {}
+ }
const name = kittyShmName(&buf, kitty_shm_serial) catch break :shm;
if (!kittyShmWrite(name, place.rgba)) break :shm;
if (vx.transmitLocalImagePath(s.gpa, s.tty.writer(), name, @intCast(place.iw), @intCast(place.ih), .shared_mem, .rgba) catch null) |handle|
@@ -2010,7 +2019,7 @@ const Shell = struct {
old.future.cancel(s.io) catch {};
s.lsp_task = null;
}
- const future = s.io.concurrent(lspWorker, .{ s.lsp_gpa, job, s.loop }) catch |err| {
+ const future = s.io.concurrent(lspWorker, .{ s.io, s.lsp_gpa, job, s.loop }) catch |err| {
job.free(s.lsp_gpa);
s.core.update(.{ .lsp_resp = .{ .id = req.id, .rows = null } });
return s.core.reportError(req.pane, "lsp", err);
@@ -2144,9 +2153,9 @@ fn requestClipboard(vx: *vaxis.Vaxis, tty: *vaxis.Tty) void {
vx.requestSystemClipboard(tty.writer()) catch {};
}
-fn lspWorker(allocator: std.mem.Allocator, job: *host_io.Lsp.Job, loop: *Loop) anyerror!void {
+fn lspWorker(io: std.Io, allocator: std.mem.Allocator, job: *host_io.Lsp.Job, loop: *Loop) anyerror!void {
var sink: LspRowSink = .{ .allocator = allocator, .loop = loop };
- host_io.Lsp.work(allocator, job, &sink, LspRowSink.take);
+ host_io.Lsp.work(io, allocator, job, &sink, LspRowSink.take);
}
const LspRowSink = struct {
@@ -2185,23 +2194,30 @@ fn watchFiles(io: std.Io, fd: c_int, loop: *Loop) anyerror!void {
return;
}
const file: std.Io.File = .{ .handle = fd, .flags = .{ .nonblocking = false } };
- var read_buf: [4096]u8 = undefined;
- var reader = file.readerStreaming(io, &read_buf);
+ // One buffer, read into directly: a Reader around it only added a second
+ // (and in a safe build, filled both as `undefined` on every start).
+ var buf: [4096]u8 = undefined;
while (true) {
- var buf: [4096]u8 = undefined;
- var vec = [_][]u8{&buf};
- const n = reader.interface.readVec(&vec) catch break;
+ const n = file.readStreaming(io, &.{&buf}) catch break;
if (n == 0) break;
loop.postEvent(.files_changed) catch break;
}
}
fn winchWatch(loop: *Loop, vx: *vaxis.Vaxis, tty: *vaxis.Tty) void {
+ winchWatchUntil(loop, vx, tty, null);
+}
+
+/// A SIGWINCH watcher that ends: `stop` set, then a SIGWINCH sent to its
+/// thread, wakes its sigwait and it returns, so whoever owns `loop` can join
+/// it before the loop goes (attachSession's loop is on its stack).
+fn winchWatchUntil(loop: *Loop, vx: *vaxis.Vaxis, tty: *vaxis.Tty, stop: ?*const std.atomic.Value(bool)) void {
var set = posix.sigemptyset();
posix.sigaddset(&set, posix.SIG.WINCH);
while (true) {
var sig: c_int = 0;
if (libc.sigwait(&set, &sig) != 0) continue;
+ if (stop) |flag| if (flag.load(.acquire)) return;
if (vx.state.in_band_resize) continue; // terminal reports via CSI 48
const ws = tty.getWinsize() catch continue;
loop.postEvent(.{ .winsize = ws }) catch {};
@@ -2285,12 +2301,11 @@ fn wakeFs(ctx: ?*anyopaque) void {
}
fn readPty(io: std.Io, gpa: std.mem.Allocator, pty: std.Io.File, id: usize, gen: u32, loop: *Loop) anyerror!void {
- var read_buf: [0x10000]u8 = undefined;
- var reader = pty.readerStreaming(io, &read_buf);
+ // One buffer, read into directly: a Reader around it only added a second
+ // (and in a safe build, filled both as `undefined` on every start).
+ var buf: [0x10000]u8 = undefined;
while (true) {
- var buf: [0x10000]u8 = undefined;
- var vec = [_][]u8{&buf};
- const n = reader.interface.readVec(&vec) catch break;
+ const n = pty.readStreaming(io, &.{&buf}) catch break;
if (n == 0) break;
const bytes = try gpa.dupe(u8, buf[0..n]);
loop.postEvent(.{ .pty_read = .{ .id = id, .gen = gen, .bytes = bytes } }) catch {
@@ -2301,7 +2316,7 @@ fn readPty(io: std.Io, gpa: std.mem.Allocator, pty: std.Io.File, id: usize, gen:
_ = loop.tryPostEvent(.{ .pty_eof = .{ .id = id, .gen = gen } }) catch {};
}
-const max_paste_bytes: usize = 4 << 20;
+const max_paste_bytes: usize = pardes.memory.limits.max_paste_bytes;
fn pasteBytes(key: vaxis.Key) []const u8 {
const text = key.text orelse "";
@@ -3023,7 +3038,13 @@ fn attachSession(init: std.process.Init, name: []const u8, tty: *vaxis.Tty, vx:
startInput(&loop, &input_cache) catch |err| return .{ .lost = err };
defer stopInput(&loop);
- (std.Thread.spawn(.{}, winchWatch, .{ &loop, vx, tty }) catch |err| return .{ .lost = err }).detach();
+ var winch_stop: std.atomic.Value(bool) = .init(false);
+ const winch = std.Thread.spawn(.{}, winchWatchUntil, .{ &loop, vx, tty, &winch_stop }) catch |err| return .{ .lost = err };
+ defer {
+ winch_stop.store(true, .release);
+ _ = libc.pthread_kill(winch.getHandle(), posix.SIG.WINCH);
+ winch.join();
+ }
vx.queryTerminalSend(tty.writer()) catch {};
return attachLoop(&a);
diff --git a/test/lspbench.zig b/test/lspbench.zig
index d0e25aee..08df9f4c 100644
--- a/test/lspbench.zig
+++ b/test/lspbench.zig
@@ -110,8 +110,13 @@ test "lspbench options reject unknown flags and multiple roots before probing" {
try std.testing.expectError(error.MultipleRoots, Options.parse(&.{ "first", "--check", "second" }));
}
+/// The process's Io, for the queries: their waits are woken by the client's
+/// reader threads, which a single-threaded Io cannot be.
+var query_io: std.Io = undefined;
+
pub fn main(init: std.process.Init) !void {
const gpa = std.heap.page_allocator;
+ query_io = init.io;
const args = try init.minimal.args.toSlice(init.arena.allocator());
if (args.len > 1 and std.mem.eql(u8, args[1], "probe")) return probeCommand(init);
@@ -171,13 +176,19 @@ fn checkResults(results: []const Result, required: usize) !void {
for (results) |r| if (r.empty or !r.correct) return error.IncorrectProbe;
}
-fn runOnce(gpa: std.mem.Allocator, req: lsp.Req, expected: []const u8, r: *Result) !u64 {
- var arena: std.heap.ArenaAllocator = .init(gpa);
- defer arena.deinit();
+fn runOnce(gpa: std.mem.Allocator, req_in: lsp.Req, expected: []const u8, r: *Result) !u64 {
+ // The editor's own path (host_io.Lsp.work): the query in the fixed
+ // region reserved at startup, not a heap arena that maps its memory anew.
+ const memory = @import("pardes").memory;
+ const region = memory.takeLspQuery() orelse return error.QueryRegionBusy;
+ var arena: std.heap.FixedBufferAllocator = .init(region);
+ defer memory.giveLspQuery(arena.end_index);
+ var req = req_in;
+ req.budget = &arena;
var out: std.Io.Writer.Allocating = .init(gpa);
defer out.deinit();
const t0 = nowNs();
- try lsp.query(gpa, arena.allocator(), req, &out.writer);
+ try lsp.query(query_io, gpa, arena.allocator(), req, &out.writer);
const ns = nowNs() -| t0;
r.accept(out.written(), expected);
return ns / 1000;
@@ -341,6 +352,7 @@ extern "c" fn usleep(usec: c_uint) c_int;
/// [--reps N] [--warm S]`, rows on stdout, the timing on stderr.
fn probeCommand(init: std.process.Init) !void {
const gpa = std.heap.page_allocator;
+ query_io = init.io;
const arena = init.arena.allocator();
const io = std.Io.Threaded.global_single_threaded.io();
@@ -431,7 +443,7 @@ fn probeCommand(init: std.process.Init) !void {
var scratch: std.heap.ArenaAllocator = .init(gpa);
defer scratch.deinit();
const t0 = nowUs();
- try lsp.query(gpa, scratch.allocator(), .{
+ try lsp.query(query_io, gpa, scratch.allocator(), .{
.kind = kind,
.path = path,
.source = source,
diff --git a/test/panes.zig b/test/panes.zig
index e98e3a54..1460b355 100644
--- a/test/panes.zig
+++ b/test/panes.zig
@@ -1913,9 +1913,6 @@ test "terminal output keeps following new rows after scrollback eviction" {
try std.testing.expectEqualStrings("f", effect.write.bytes.slice());
try std.testing.expect(p.nextEffect() == null);
}
- const replay = &pane.terminal.?.replay;
- try std.testing.expectEqual(replay.bytes.len, replay.len);
- try std.testing.expect(replay.head > 0);
}
test "terminal edit stays on its surviving row when old scrollback is evicted" {
diff --git a/test/perf-baseline-gui-debug.json b/test/perf-baseline-gui-debug.json
index ffcd678f..a41c92b2 100644
--- a/test/perf-baseline-gui-debug.json
+++ b/test/perf-baseline-gui-debug.json
@@ -1 +1 @@
-{"harness":"15bee9f100e5ef64","build":{"compiler":"0.17.0","target":"x86_64-linux.5.10...7.2-gnu.2.38","cpu":"x86_64","driver_optimize":"fast","core_optimize":"debug","c_optimize":"fast","terminal_optimize":"safe","platform":"gui","grammars":"full","mupdf":true,"jpx":true,"tracy":false,"quic":false,"theme_animation":true,"terminal_simd":true,"prebuilt_shaders":false},"cols":120,"rows":40,"reps":10,"only":"medium","fixtures":[{"name":"small","lines":1000,"cols":60,"bytes":62694},{"name":"medium","lines":50000,"cols":60,"bytes":3201944},{"name":"large","lines":300000,"cols":60,"bytes":19464444},{"name":"longline","lines":400,"cols":8000,"bytes":3200400},{"name":"esp32p4","lines":12,"cols":240,"bytes":2892}],"cells":[{"op":"open","fixture":"medium","min_us":1744,"med_us":1832,"p90_us":2468,"max_us":2524},{"op":"render","fixture":"medium","min_us":88,"med_us":97,"p90_us":114,"max_us":115},{"op":"key-down","fixture":"medium","min_us":95,"med_us":98,"p90_us":104,"max_us":105},{"op":"key-right","fixture":"medium","min_us":92,"med_us":96,"p90_us":98,"max_us":105},{"op":"page-down","fixture":"medium","min_us":91,"med_us":95,"p90_us":97,"max_us":105},{"op":"wheel","fixture":"medium","min_us":87,"med_us":93,"p90_us":99,"max_us":100},{"op":"edit-char","fixture":"medium","min_us":1241,"med_us":1459,"p90_us":1691,"max_us":1724},{"op":"edit-twin","fixture":"medium","min_us":2592,"med_us":3003,"p90_us":3481,"max_us":3503},{"op":"body-2m","fixture":"medium","min_us":4576,"med_us":8262,"p90_us":15424,"max_us":17259},{"op":"body-appends","fixture":"medium","min_us":152003,"med_us":227268,"p90_us":272872,"max_us":326510},{"op":"deep-sel","fixture":"medium","min_us":82,"med_us":83,"p90_us":90,"max_us":93}]}
+{"harness":"442f274a5da9136c","build":{"compiler":"0.17.0","target":"x86_64-linux.5.10...7.2-gnu.2.38","cpu":"x86_64","driver_optimize":"fast","core_optimize":"debug","c_optimize":"fast","terminal_optimize":"safe","platform":"gui","grammars":"full","mupdf":true,"jpx":true,"tracy":false,"quic":false,"theme_animation":true,"terminal_simd":true,"prebuilt_shaders":false},"cols":120,"rows":40,"reps":10,"only":"medium","fixtures":[{"name":"small","lines":1000,"cols":60,"bytes":62694},{"name":"medium","lines":50000,"cols":60,"bytes":3201944},{"name":"large","lines":300000,"cols":60,"bytes":19464444},{"name":"longline","lines":400,"cols":8000,"bytes":3200400},{"name":"esp32p4","lines":12,"cols":240,"bytes":2892}],"cells":[{"op":"open","fixture":"medium","min_us":2253,"med_us":2626,"p90_us":3065,"max_us":3090},{"op":"render","fixture":"medium","min_us":100,"med_us":103,"p90_us":103,"max_us":110},{"op":"key-down","fixture":"medium","min_us":102,"med_us":103,"p90_us":105,"max_us":113},{"op":"key-right","fixture":"medium","min_us":98,"med_us":104,"p90_us":108,"max_us":113},{"op":"page-down","fixture":"medium","min_us":103,"med_us":104,"p90_us":111,"max_us":114},{"op":"wheel","fixture":"medium","min_us":98,"med_us":100,"p90_us":102,"max_us":108},{"op":"edit-char","fixture":"medium","min_us":1251,"med_us":1940,"p90_us":2652,"max_us":3041},{"op":"edit-twin","fixture":"medium","min_us":2779,"med_us":3177,"p90_us":3366,"max_us":3657},{"op":"body-2m","fixture":"medium","min_us":5812,"med_us":11423,"p90_us":13681,"max_us":13758},{"op":"body-appends","fixture":"medium","min_us":153898,"med_us":241075,"p90_us":284518,"max_us":305761},{"op":"deep-sel","fixture":"medium","min_us":86,"med_us":91,"p90_us":94,"max_us":122}]}
diff --git a/test/perf-baseline-tty-debug.json b/test/perf-baseline-tty-debug.json
index b8e534c4..dc37e033 100644
--- a/test/perf-baseline-tty-debug.json
+++ b/test/perf-baseline-tty-debug.json
@@ -1 +1 @@
-{"harness":"15bee9f100e5ef64","build":{"compiler":"0.17.0","target":"x86_64-linux.5.10...7.2-gnu.2.38","cpu":"x86_64","driver_optimize":"fast","core_optimize":"debug","c_optimize":"fast","terminal_optimize":"safe","platform":"tty","grammars":"full","mupdf":true,"jpx":true,"tracy":false,"quic":false,"theme_animation":true,"terminal_simd":true,"prebuilt_shaders":false},"cols":120,"rows":40,"reps":10,"only":"medium","fixtures":[{"name":"small","lines":1000,"cols":60,"bytes":62694},{"name":"medium","lines":50000,"cols":60,"bytes":3201944},{"name":"large","lines":300000,"cols":60,"bytes":19464444},{"name":"longline","lines":400,"cols":8000,"bytes":3200400},{"name":"esp32p4","lines":12,"cols":240,"bytes":2892}],"cells":[{"op":"open","fixture":"medium","min_us":1747,"med_us":1912,"p90_us":2150,"max_us":2247},{"op":"render","fixture":"medium","min_us":89,"med_us":95,"p90_us":102,"max_us":104},{"op":"key-down","fixture":"medium","min_us":97,"med_us":101,"p90_us":107,"max_us":133},{"op":"key-right","fixture":"medium","min_us":93,"med_us":104,"p90_us":109,"max_us":112},{"op":"page-down","fixture":"medium","min_us":92,"med_us":96,"p90_us":106,"max_us":108},{"op":"wheel","fixture":"medium","min_us":90,"med_us":92,"p90_us":96,"max_us":96},{"op":"edit-char","fixture":"medium","min_us":1167,"med_us":1345,"p90_us":1483,"max_us":1627},{"op":"edit-twin","fixture":"medium","min_us":2319,"med_us":2921,"p90_us":3425,"max_us":3539},{"op":"body-2m","fixture":"medium","min_us":4333,"med_us":7752,"p90_us":15941,"max_us":17192},{"op":"body-appends","fixture":"medium","min_us":149149,"med_us":234177,"p90_us":285302,"max_us":295516},{"op":"deep-sel","fixture":"medium","min_us":83,"med_us":88,"p90_us":99,"max_us":119}]}
+{"harness":"442f274a5da9136c","build":{"compiler":"0.17.0","target":"x86_64-linux.5.10...7.2-gnu.2.38","cpu":"x86_64","driver_optimize":"fast","core_optimize":"debug","c_optimize":"fast","terminal_optimize":"safe","platform":"tty","grammars":"full","mupdf":true,"jpx":true,"tracy":false,"quic":false,"theme_animation":true,"terminal_simd":true,"prebuilt_shaders":false},"cols":120,"rows":40,"reps":10,"only":"medium","fixtures":[{"name":"small","lines":1000,"cols":60,"bytes":62694},{"name":"medium","lines":50000,"cols":60,"bytes":3201944},{"name":"large","lines":300000,"cols":60,"bytes":19464444},{"name":"longline","lines":400,"cols":8000,"bytes":3200400},{"name":"esp32p4","lines":12,"cols":240,"bytes":2892}],"cells":[{"op":"open","fixture":"medium","min_us":2181,"med_us":2495,"p90_us":2621,"max_us":2660},{"op":"render","fixture":"medium","min_us":96,"med_us":98,"p90_us":102,"max_us":112},{"op":"key-down","fixture":"medium","min_us":101,"med_us":103,"p90_us":107,"max_us":108},{"op":"key-right","fixture":"medium","min_us":100,"med_us":112,"p90_us":118,"max_us":119},{"op":"page-down","fixture":"medium","min_us":97,"med_us":101,"p90_us":105,"max_us":107},{"op":"wheel","fixture":"medium","min_us":98,"med_us":100,"p90_us":108,"max_us":110},{"op":"edit-char","fixture":"medium","min_us":1377,"med_us":1842,"p90_us":2336,"max_us":2418},{"op":"edit-twin","fixture":"medium","min_us":2655,"med_us":3200,"p90_us":3321,"max_us":3660},{"op":"body-2m","fixture":"medium","min_us":5420,"med_us":10753,"p90_us":12826,"max_us":15385},{"op":"body-appends","fixture":"medium","min_us":153569,"med_us":232519,"p90_us":281625,"max_us":309036},{"op":"deep-sel","fixture":"medium","min_us":91,"med_us":98,"p90_us":111,"max_us":111}]}
diff --git a/test/perf-baseline-tty-fast.json b/test/perf-baseline-tty-fast.json
index 46125349..bd8f32dc 100644
--- a/test/perf-baseline-tty-fast.json
+++ b/test/perf-baseline-tty-fast.json
@@ -1 +1 @@
-{"harness":"15bee9f100e5ef64","build":{"compiler":"0.17.0","target":"x86_64-linux.5.10...7.2-gnu.2.38","cpu":"x86_64","driver_optimize":"fast","core_optimize":"fast","c_optimize":"fast","terminal_optimize":"fast","platform":"tty","grammars":"full","mupdf":true,"jpx":true,"tracy":false,"quic":false,"theme_animation":true,"terminal_simd":true,"prebuilt_shaders":false},"cols":120,"rows":40,"reps":10,"only":"medium","fixtures":[{"name":"small","lines":1000,"cols":60,"bytes":62694},{"name":"medium","lines":50000,"cols":60,"bytes":3201944},{"name":"large","lines":300000,"cols":60,"bytes":19464444},{"name":"longline","lines":400,"cols":8000,"bytes":3200400},{"name":"esp32p4","lines":12,"cols":240,"bytes":2892}],"cells":[{"op":"open","fixture":"medium","min_us":1904,"med_us":2040,"p90_us":2290,"max_us":2600},{"op":"render","fixture":"medium","min_us":80,"med_us":83,"p90_us":88,"max_us":93},{"op":"key-down","fixture":"medium","min_us":81,"med_us":87,"p90_us":93,"max_us":109},{"op":"key-right","fixture":"medium","min_us":79,"med_us":82,"p90_us":86,"max_us":96},{"op":"page-down","fixture":"medium","min_us":79,"med_us":83,"p90_us":89,"max_us":93},{"op":"wheel","fixture":"medium","min_us":77,"med_us":79,"p90_us":82,"max_us":83},{"op":"edit-char","fixture":"medium","min_us":1139,"med_us":1338,"p90_us":1453,"max_us":1578},{"op":"edit-twin","fixture":"medium","min_us":2515,"med_us":2776,"p90_us":2879,"max_us":2907},{"op":"body-2m","fixture":"medium","min_us":4832,"med_us":7650,"p90_us":15076,"max_us":15371},{"op":"body-appends","fixture":"medium","min_us":165796,"med_us":240881,"p90_us":284919,"max_us":292573},{"op":"deep-sel","fixture":"medium","min_us":73,"med_us":75,"p90_us":83,"max_us":93}]}
+{"harness":"442f274a5da9136c","build":{"compiler":"0.17.0","target":"x86_64-linux.5.10...7.2-gnu.2.38","cpu":"x86_64","driver_optimize":"fast","core_optimize":"fast","c_optimize":"fast","terminal_optimize":"fast","platform":"tty","grammars":"full","mupdf":true,"jpx":true,"tracy":false,"quic":false,"theme_animation":true,"terminal_simd":true,"prebuilt_shaders":false},"cols":120,"rows":40,"reps":10,"only":"medium","fixtures":[{"name":"small","lines":1000,"cols":60,"bytes":62694},{"name":"medium","lines":50000,"cols":60,"bytes":3201944},{"name":"large","lines":300000,"cols":60,"bytes":19464444},{"name":"longline","lines":400,"cols":8000,"bytes":3200400},{"name":"esp32p4","lines":12,"cols":240,"bytes":2892}],"cells":[{"op":"open","fixture":"medium","min_us":2283,"med_us":2611,"p90_us":2812,"max_us":2917},{"op":"render","fixture":"medium","min_us":89,"med_us":97,"p90_us":105,"max_us":119},{"op":"key-down","fixture":"medium","min_us":88,"med_us":95,"p90_us":100,"max_us":116},{"op":"key-right","fixture":"medium","min_us":90,"med_us":99,"p90_us":103,"max_us":106},{"op":"page-down","fixture":"medium","min_us":86,"med_us":90,"p90_us":96,"max_us":97},{"op":"wheel","fixture":"medium","min_us":85,"med_us":91,"p90_us":94,"max_us":101},{"op":"edit-char","fixture":"medium","min_us":1229,"med_us":1823,"p90_us":1874,"max_us":2101},{"op":"edit-twin","fixture":"medium","min_us":2196,"med_us":2745,"p90_us":2928,"max_us":2972},{"op":"body-2m","fixture":"medium","min_us":5606,"med_us":10369,"p90_us":14063,"max_us":14406},{"op":"body-appends","fixture":"medium","min_us":155867,"med_us":237195,"p90_us":289128,"max_us":306283},{"op":"deep-sel","fixture":"medium","min_us":82,"med_us":84,"p90_us":86,"max_us":91}]}
diff --git a/test/perf.zig b/test/perf.zig
index 7662d028..ab284739 100644
--- a/test/perf.zig
+++ b/test/perf.zig
@@ -665,8 +665,6 @@ fn measureTerm(op: TermOp, fx: TermFixture, reps: usize) !Cell {
.row = pane.body.cur_row,
.col = pane.body.cur_col,
.edit_len = if (pane.ovl) |overlay| overlay.text.len else 0,
- .replay_head = state.replay.head,
- .replay_len = state.replay.len,
.cols = pane.cols,
.rows = pane.rows,
};
@@ -689,22 +687,11 @@ fn measureTerm(op: TermOp, fx: TermFixture, reps: usize) !Cell {
_ = try frame(core);
const dt = nowNs() -| t0;
switch (op) {
- .render => if (pane.body.cur_row != before.row or pane.body.cur_col != before.col or
- state.replay.head != before.replay_head or state.replay.len != before.replay_len)
+ .render => if (pane.body.cur_row != before.row or pane.body.cur_col != before.col)
return error.RenderChangedTerminal,
- .output => {
- const capacity = state.replay.bytes.len;
- if (term_chunk.len == 0 or term_chunk.len >= capacity) return error.InvalidOutputFixture;
- const overflow = term_chunk.len -| (capacity - before.replay_len);
- if (state.replay.len != @min(capacity, before.replay_len + term_chunk.len) or
- state.replay.head != (before.replay_head + overflow) % capacity)
- return error.OutputWasNotRecorded;
- const start = (state.replay.head + state.replay.len - term_chunk.len) % capacity;
- const first = @min(term_chunk.len, capacity - start);
- if (!std.mem.eql(u8, term_chunk[0..first], state.replay.bytes[start..][0..first]) or
- !std.mem.eql(u8, term_chunk[first..], state.replay.bytes[0 .. term_chunk.len - first]))
- return error.WrongTerminalOutput;
- },
+ // What the output did to the screen is the snapshot suite's to
+ // check; here it is timed.
+ .output => if (term_chunk.len == 0) return error.InvalidOutputFixture,
.resize_rows => if (pane.rows == before.rows or pane.cols != before.cols or
state.vt.screens.active.pages.rows != pane.rows) return error.TerminalDidNotResize,
.resize_cols => if (pane.cols == before.cols or pane.rows != before.rows or