summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-09 03:29:30 -0300
committerGabriel Schneider <[email protected]>2026-11-09 03:30:49 -0300
commit84c8209d02f6830db861c3a8dde0c710c88075f0 (patch)
tree10f77e3ab1becb5a0af4de152bb8d8e0e9ee0f03 /src
parent446292e15d56c9c248dae5d6fde1be3a83ade82e (diff)
downloadpardes-84c8209d02f6830db861c3a8dde0c710c88075f0.tar.gz
pardes-84c8209d02f6830db861c3a8dde0c710c88075f0.zip
idioms: the edit surface fails by name: the undo history (Journal.mark, Text.remember and step, File's, terminal's and edit's pushUndo and undoStep) returns error{OutOfMemory} instead of dropping an undo point, setEditText, enterInsert and insertTab return edit.Error with try where they reported each failure, Registers.put and setYank return error{OutOfMemory} instead of losing a yank, and their other-file callers decide (try under edit.Error, said on the pane by Undo, Redo, Pipe, Edit, Query, keys, look, completion, Incl and Plumb, ENOMEM or null where a 9P write answers, Ask's false); ctl.get and getFile return GetError (fs.ReadError, now named at fs.zig's surface, and InvalidName) for the *anyerror out-parameter and errno, the 9P get, Get and Edit's e mapping it as before; the OOM undo test pins the error; perf.zig's try relabels its harness hash, the three baselines re-keyed to it (their numbers the base's)
Co-Authored-By: Claude Fable 5.1 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNAtZenFv4weoMD3cge
Diffstat (limited to 'src')
-rw-r--r--src/Core.zig2
-rw-r--r--src/File.zig46
-rw-r--r--src/Pipe.zig10
-rw-r--r--src/Places.zig2
-rw-r--r--src/Query.zig6
-rw-r--r--src/Registers.zig27
-rw-r--r--src/Text.zig21
-rw-r--r--src/builtins.zig35
-rw-r--r--src/edit.zig168
-rw-r--r--src/edit_cmd.zig12
-rw-r--r--src/file_watch.zig2
-rw-r--r--src/fs.zig8
-rw-r--r--src/keys.zig4
-rw-r--r--src/look.zig4
-rw-r--r--src/lsp/Ask.zig7
-rw-r--r--src/mouse.zig6
-rw-r--r--src/ninep/cols.zig4
-rw-r--r--src/ninep/ctl.zig77
-rw-r--r--src/ninep/pane.zig9
-rw-r--r--src/normal.zig4
-rw-r--r--src/rollback.zig4
-rw-r--r--src/terminal.zig8
22 files changed, 237 insertions, 229 deletions
diff --git a/src/Core.zig b/src/Core.zig
index 8aecea53..6c5f5470 100644
--- a/src/Core.zig
+++ b/src/Core.zig
@@ -3232,7 +3232,7 @@ test "a host with no methods at all is a complete in-process pardes" {
try std.testing.expectEqual(before, p.panes[0].?.terminal.?.vt.screens.active.cursor.y);
// the clipboard round-trips through the in-process one
- p.registers.put(gpa, '+', "copied", 0, 1, true);
+ try p.registers.put(gpa, '+', "copied", 0, 1, true);
p.perform(.set_clipboard);
try std.testing.expectEqualStrings("copied", p.fallback.clipboard.items);
diff --git a/src/File.zig b/src/File.zig
index 82661c6d..90711c9a 100644
--- a/src/File.zig
+++ b/src/File.zig
@@ -1245,20 +1245,20 @@ pub fn restoreSnap(pane: *Pane, f: *State, snap: Text.Place) void {
/// An undo step's edge, made before an edit (Text.Journal.mark): the edits
/// after it are one step back to the pane's place now.
-pub fn pushUndo(p: *Pardes, pane: *Pane) void {
+pub fn pushUndo(p: *Pardes, pane: *Pane) error{OutOfMemory}!void {
const f = if (pane.file) |*file| file else return;
- f.history.journal.mark(p.gpa, f.content, placeOf(pane, f));
+ try f.history.journal.mark(p.gpa, f.content, placeOf(pane, f));
}
/// Undo (back) or redo one step: its edits turned round in the text, and the
/// place and name it began at (or, redone, was undone from) back.
-pub fn undoStep(p: *Pardes, pane: *Pane, back: bool) void {
+pub fn undoStep(p: *Pardes, pane: *Pane, back: bool) error{OutOfMemory}!void {
const f = if (pane.file) |*file| file else return;
const j = &f.history.journal;
if (if (back) j.done == 0 else j.done == j.steps.items.len) return;
const at = if (back) j.done - 1 else j.done;
const now = placeOf(pane, f);
- if (!turn(p, f, at, back)) return;
+ if (!turn(p, f, at, back)) return error.OutOfMemory;
const s = &j.steps.items[at];
if (back) {
s.after = now;
@@ -1439,8 +1439,8 @@ pub fn changed(p: *Pardes, id: u8, bytes: []const u8) void {
// Logged as the dirty case is, with what became of it.
var rec: [32]u8 = undefined;
pardes.ctlfs.events.notePath(p, "changed", std.fmt.bufPrint(&rec, "{d} reloaded", .{pane.serial}) catch unreachable); // a u32 fits 32
+ pushUndo(p, pane) catch |err| return p.reportError(id, "reload", err);
const new = p.gpa.dupe(u8, bytes) catch |err| return p.reportError(id, "reload", err);
- pushUndo(p, pane);
setContent(p, f, new);
f.saved_revision = f.revision;
restoreSnap(pane, f, .{ .cur_row = pane.body.cur_row, .cur_col = pane.body.cur_col, .vsel = pane.body.vsel });
@@ -2515,7 +2515,7 @@ test "undo and redo walk back and forth through every step of random edits, join
for (0..80) |_| {
const was = j.done;
try texts.append(gpa, try gpa.dupe(u8, f.content));
- pushUndo(p, pane);
+ try pushUndo(p, pane);
// A step that changed nothing goes on, its edge where it was.
if (j.done == was) gpa.free(texts.pop().?);
// Up to six edits: most where the last ended, as typing goes on.
@@ -2535,11 +2535,11 @@ test "undo and redo walk back and forth through every step of random edits, join
var k = texts.items.len - 1;
while (k > 0) {
k -= 1;
- undoStep(p, pane, true);
+ try undoStep(p, pane, true);
try std.testing.expectEqualStrings(texts.items[k], f.content);
}
for (texts.items[1..]) |t| {
- undoStep(p, pane, false);
+ try undoStep(p, pane, false);
try std.testing.expectEqualStrings(t, f.content);
}
}
@@ -2559,42 +2559,42 @@ test "a text replaced whole keeps its old buffer for its undo, swapped back and
defer for (texts) |t| gpa.free(t);
setContent(p, f, try gpa.dupe(u8, texts[0]));
const first = f.content.ptr;
- pushUndo(p, pane);
+ try pushUndo(p, pane);
setContent(p, f, try gpa.dupe(u8, texts[1]));
// The old buffer itself, kept: no byte of it copied, none counted.
const e = j.entries.items[j.entries.items.len - 1];
try std.testing.expect(e.swap and e.removed.ptr == first);
try std.testing.expectEqual(@as(usize, @sizeOf(Text.Entry)), j.bytes);
const second = f.content.ptr;
- undoStep(p, pane, true);
+ try undoStep(p, pane, true);
try std.testing.expect(f.content.ptr == first);
try std.testing.expectEqualStrings(texts[0], f.content);
- undoStep(p, pane, false);
+ try undoStep(p, pane, false);
try std.testing.expect(f.content.ptr == second);
try std.testing.expectEqualStrings(texts[1], f.content);
// A third and a fourth: two swaps kept, the steps before them gone, said.
for (texts[2..4]) |t| {
- pushUndo(p, pane);
+ try pushUndo(p, pane);
setContent(p, f, try gpa.dupe(u8, t));
}
try std.testing.expectEqual(@as(usize, 2), j.done);
try std.testing.expect(std.mem.indexOf(u8, pane.msg[0..pane.msg_len], "undo keeps the last two texts replaced whole") != null);
- undoStep(p, pane, true);
- undoStep(p, pane, true);
+ try undoStep(p, pane, true);
+ try undoStep(p, pane, true);
try std.testing.expectEqualStrings(texts[1], f.content);
- undoStep(p, pane, true);
+ try undoStep(p, pane, true);
try std.testing.expectEqualStrings(texts[1], f.content);
// A body emptied and written again on one open (a shell's >): its undo
// swaps the old text back and folds the step into one swap the other way.
- pushUndo(p, pane);
+ try pushUndo(p, pane);
try std.testing.expect(replace(p, f, 0, f.content.len, ""));
try std.testing.expect(replace(p, f, 0, 0, "fresh\n"));
- undoStep(p, pane, true);
+ try undoStep(p, pane, true);
try std.testing.expectEqualStrings(texts[1], f.content);
try std.testing.expectEqual(@as(usize, 1), j.steps.items[j.done].n);
- undoStep(p, pane, false);
+ try undoStep(p, pane, false);
try std.testing.expectEqualStrings("fresh\n", f.content);
- undoStep(p, pane, true);
+ try undoStep(p, pane, true);
try std.testing.expectEqualStrings(texts[1], f.content);
}
@@ -2614,10 +2614,10 @@ test "undo keeps its steps within a byte bound, the newest always" {
defer gpa.free(text);
for (0..8) |i| {
@memset(text, 'a' + @as(u8, @intCast(i)));
- pushUndo(p, pane);
+ try pushUndo(p, pane);
try std.testing.expect(replace(p, f, step / 2, step, text));
}
- pushUndo(p, pane);
+ try pushUndo(p, pane);
const j = &f.history.journal;
try std.testing.expect(j.done > 0 and j.done < 8);
try std.testing.expect(j.bytes <= limits.undo_bytes + step + @sizeOf(Text.Entry));
@@ -2627,11 +2627,11 @@ test "undo keeps its steps within a byte bound, the newest always" {
sum += Text.Journal.held(e);
}
try std.testing.expectEqual(sum, j.bytes);
- undoStep(p, pane, true);
+ try undoStep(p, pane, true);
try std.testing.expectEqual(text[0], f.content[step / 2]);
// Back as far as the bound kept: each step's middle whole again.
while (j.done > 0) {
- undoStep(p, pane, true);
+ try undoStep(p, pane, true);
try std.testing.expect(std.mem.allEqual(u8, f.content[step / 2 ..][0..step], f.content[step / 2]));
}
}
diff --git a/src/Pipe.zig b/src/Pipe.zig
index 8c25a797..10967a3c 100644
--- a/src/Pipe.zig
+++ b/src/Pipe.zig
@@ -314,9 +314,13 @@ pub fn pipeResponse(
}
// One async request is one history transaction, even at 64 cursors.
- edit.pushUndo(p, t);
- edit.setEditText(p, t, replacement);
- t.setRanges(edit.flatSurface(p, t) catch return, new_ranges[0..n], &.{}, wait.primary, wait.explicit);
+ edit.pushUndo(p, t) catch |err| {
+ p.gpa.free(replacement);
+ return p.reportError(wait.pane, "pipe", err);
+ };
+ edit.setEditText(p, t, replacement) catch |err| return p.reportError(wait.pane, "pipe", err);
+ const now = edit.flatSurface(p, t) catch |err| return p.reportError(wait.pane, "pipe", err);
+ t.setRanges(now, new_ranges[0..n], &.{}, wait.primary, wait.explicit);
t.select = false;
t.show();
}
diff --git a/src/Places.zig b/src/Places.zig
index ddbbc271..6aab0684 100644
--- a/src/Places.zig
+++ b/src/Places.zig
@@ -810,7 +810,7 @@ test "places: * finds them all, n and N step them round the end silently, an edi
try std.testing.expectEqual(before.start + 6, set.hits.items[3].start);
try std.testing.expectEqual(@as(?usize, 3), set.current);
// Another `/` register (an `s`, a search elsewhere): n is helix's again.
- p.registers.put(p.gpa, '/', "gamma", 0, 1, true);
+ try p.registers.put(p.gpa, '/', "gamma", 0, 1, true);
try std.testing.expect(!set.answersN(p, pane));
}
diff --git a/src/Query.zig b/src/Query.zig
index b1424968..301d3334 100644
--- a/src/Query.zig
+++ b/src/Query.zig
@@ -343,7 +343,7 @@ pub fn toLineOne(p: *Pardes, id: usize) void {
t.nsel = 0;
t.cur_pinned = true;
rp.query.?.seen_row = 0;
- edit.enterInsert(p, t, .line_end, 1);
+ edit.enterInsert(p, t, .line_end, 1) catch |err| return p.reportError(id, "query", err);
showCurrent(rp);
}
@@ -1805,8 +1805,8 @@ pub fn land(p: *Pardes, id: usize, row: ?usize) void {
if (set.literal) {
var escaped: std.ArrayList(u8) = .empty;
normal.appendSearchLiteral(&escaped, p.scratch.allocator(), set.pattern) catch |err| return p.reportError(id, "search", err);
- p.registers.put(p.gpa, '/', escaped.items, 0, 1, true);
- } else p.registers.put(p.gpa, '/', set.pattern, 0, 1, true);
+ p.registers.put(p.gpa, '/', escaped.items, 0, 1, true) catch |err| return p.reportError(id, "search", err);
+ } else p.registers.put(p.gpa, '/', set.pattern, 0, 1, true) catch |err| return p.reportError(id, "search", err);
p.registers.last_search = '/';
set.provenance = .search;
}
diff --git a/src/Registers.zig b/src/Registers.zig
index 6df7401d..8019d9dc 100644
--- a/src/Registers.zig
+++ b/src/Registers.zig
@@ -57,20 +57,15 @@ pub fn value(r: *Registers, name: u21, i: usize) ?[]const u8 {
/// Store value `i` of `n`. `fresh` starts the register over with `n` empty
/// values; the replay across ranges passes it on its first pass only, so
/// every range fills its own slot.
-pub fn put(r: *Registers, gpa: std.mem.Allocator, name: u21, bytes: []const u8, i: usize, n: usize, fresh: bool) void {
- const copy = gpa.dupe(u8, bytes) catch return;
+pub fn put(r: *Registers, gpa: std.mem.Allocator, name: u21, bytes: []const u8, i: usize, n: usize, fresh: bool) error{OutOfMemory}!void {
+ const copy = try gpa.dupe(u8, bytes);
+ errdefer gpa.free(copy);
const reg = r.get(name) orelse blk: {
- r.list.append(gpa, .{ .name = name, .values = &.{} }) catch {
- gpa.free(copy);
- return;
- };
+ try r.list.append(gpa, .{ .name = name, .values = &.{} });
break :blk &r.list.items[r.list.items.len - 1];
};
// A new array, the old one's values moved into it but value `i`.
- const values = gpa.alloc([]u8, n) catch {
- gpa.free(copy);
- return;
- };
+ const values = try gpa.alloc([]u8, n);
const keep = !fresh and reg.values.len == n;
for (values, 0..) |*v, j| v.* = if (keep and j != i) reg.values[j] else &.{};
values[i] = copy;
@@ -103,13 +98,13 @@ test "a register holds a value per range and joins them for one-text readers" {
defer r.deinit(gpa);
try std.testing.expect(r.value(default, 0) == null);
// a replay fills the last range first
- r.put(gpa, default, "two", 1, 2, true);
- r.put(gpa, default, "one\n", 0, 2, false);
+ try r.put(gpa, default, "two", 1, 2, true);
+ try r.put(gpa, default, "one\n", 0, 2, false);
try std.testing.expectEqualStrings("one\n", r.value(default, 0).?);
try std.testing.expectEqualStrings("two", r.value(default, 1).?);
try std.testing.expectEqualStrings("two", r.value(default, 5).?);
try std.testing.expectEqualStrings("one\ntwo", r.text(gpa, default).?);
- r.put(gpa, 'a', "x", 0, 1, true);
+ try r.put(gpa, 'a', "x", 0, 1, true);
try std.testing.expectEqualStrings("x", r.text(gpa, 'a').?);
try std.testing.expectEqualStrings("one\ntwo", r.text(gpa, default).?);
}
@@ -117,9 +112,9 @@ test "a register holds a value per range and joins them for one-text readers" {
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);
+ try r.put(std.testing.allocator, default, "one", 0, 2, true);
+ try r.put(std.testing.allocator, default, "two", 1, 2, false);
+ try 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);
diff --git a/src/Text.zig b/src/Text.zig
index 6d0e28c9..650caea1 100644
--- a/src/Text.zig
+++ b/src/Text.zig
@@ -761,14 +761,15 @@ pub const Journal = struct {
/// an undo takes back to `place`. None when the last step changed
/// nothing, its edits undone giving `text` as it is: that step goes on,
/// its place kept, as a snapshot equal to the text was none.
- pub fn mark(j: *Journal, gpa: std.mem.Allocator, text: []const u8, place: Place) void {
+ pub fn mark(j: *Journal, gpa: std.mem.Allocator, text: []const u8, place: Place) error{OutOfMemory}!void {
if (j.done > 0) {
const top = j.steps.items[j.done - 1];
- if (top.before.gen == place.gen and unchanged(gpa, j.entries.items[top.first..][0..top.n], text)) return;
+ if (top.before.gen == place.gen and try unchanged(gpa, j.entries.items[top.first..][0..top.n], text)) return;
}
+ try j.steps.ensureUnusedCapacity(gpa, 1);
j.dropRedo(gpa);
if (j.steps.items.len == memory.limits.undo_max) j.dropOldest(gpa);
- j.steps.append(gpa, .{ .first = j.entries.items.len, .before = place }) catch return;
+ j.steps.appendAssumeCapacity(.{ .first = j.entries.items.len, .before = place });
j.done = j.steps.items.len;
}
@@ -914,7 +915,7 @@ pub const Journal = struct {
/// Whether undoing `entries` gives `text` back as it is. Only the stretch
/// they fell in is undone, in a copy: before their lowest offset nothing
/// changed, nor after the furthest end any reached.
-fn unchanged(gpa: std.mem.Allocator, entries: []const Entry, text: []const u8) bool {
+fn unchanged(gpa: std.mem.Allocator, entries: []const Entry, text: []const u8) error{OutOfMemory}!bool {
if (entries.len == 0) return true;
var grown: isize = 0;
for (entries) |e| grown += @as(isize, @intCast(e.ins)) - @as(isize, @intCast(e.removed.len));
@@ -929,12 +930,12 @@ fn unchanged(gpa: std.mem.Allocator, entries: []const Entry, text: []const u8) b
}
var window: std.ArrayList(u8) = .empty;
defer window.deinit(gpa);
- window.appendSlice(gpa, text[lo..hi]) catch return false;
+ try window.appendSlice(gpa, text[lo..hi]);
var i = entries.len;
while (i > 0) {
i -= 1;
const e = entries[i];
- window.replaceRange(gpa, e.off - lo, e.ins, e.removed) catch return false;
+ try window.replaceRange(gpa, e.off - lo, e.ins, e.removed);
}
return std.mem.eql(u8, window.items, text[lo..hi]);
}
@@ -952,14 +953,14 @@ fn pushHistory(gpa: std.mem.Allocator, slots: []terminal.Snapshot, len: *usize,
/// Record an edit buffer (a terminal's overlay, a tag's own text) as it
/// stands before an edit, once per change of it, and forget what could have
/// been redone. Null is a buffer not made yet.
-pub fn remember(t: *Text, gpa: std.mem.Allocator, current: ?terminal.EditBuffer) void {
+pub fn remember(t: *Text, gpa: std.mem.Allocator, current: ?terminal.EditBuffer) error{OutOfMemory}!void {
if (t.ed_undo_len > 0) {
const top = t.ed_undo[t.ed_undo_len - 1];
const same = if (top.ovl) |overlay| if (current) |now| overlay.row == now.row and
overlay.rows == now.rows and std.mem.eql(u8, overlay.text, now.text) else false else current == null;
if (same) return;
}
- const copy: ?terminal.EditBuffer = if (current) |now| .{ .row = now.row, .rows = now.rows, .text = gpa.dupe(u8, now.text) catch return } else null;
+ const copy: ?terminal.EditBuffer = if (current) |now| .{ .row = now.row, .rows = now.rows, .text = try gpa.dupe(u8, now.text) } else null;
pushHistory(gpa, &t.ed_undo, &t.ed_undo_len, .{ .ovl = copy, .cur_row = t.cur_row, .cur_col = t.cur_col, .vsel = t.vsel });
for (t.ed_redo[0..t.ed_redo_len]) |item| if (item.ovl) |overlay| gpa.free(overlay.text);
t.ed_redo_len = 0;
@@ -969,13 +970,13 @@ pub fn remember(t: *Text, gpa: std.mem.Allocator, current: ?terminal.EditBuffer)
/// other history and the state to return to comes back, its cursor and
/// selection already restored here. The caller installs its buffer, which
/// it then owns. Null when there is nothing to step to.
-pub fn step(t: *Text, gpa: std.mem.Allocator, current: ?terminal.EditBuffer, back: bool) ?terminal.Snapshot {
+pub fn step(t: *Text, gpa: std.mem.Allocator, current: ?terminal.EditBuffer, back: bool) error{OutOfMemory}!?terminal.Snapshot {
const from, const from_len, const to, const to_len = if (back)
.{ &t.ed_undo, &t.ed_undo_len, &t.ed_redo, &t.ed_redo_len }
else
.{ &t.ed_redo, &t.ed_redo_len, &t.ed_undo, &t.ed_undo_len };
if (from_len.* == 0) return null;
- const copy: ?terminal.EditBuffer = if (current) |now| .{ .row = now.row, .rows = now.rows, .text = gpa.dupe(u8, now.text) catch return null } else null;
+ const copy: ?terminal.EditBuffer = if (current) |now| .{ .row = now.row, .rows = now.rows, .text = try gpa.dupe(u8, now.text) } else null;
pushHistory(gpa, to, to_len, .{ .ovl = copy, .cur_row = t.cur_row, .cur_col = t.cur_col, .vsel = t.vsel });
from_len.* -= 1;
const back_to = from[from_len.*];
diff --git a/src/builtins.zig b/src/builtins.zig
index 2e8397e6..e021dd6b 100644
--- a/src/builtins.zig
+++ b/src/builtins.zig
@@ -843,7 +843,6 @@ pub const Get = struct {
return panes.Dir.show(c.p, c.id, c.id);
}
if (!panes.Output.fileTraits(f.output).saves) return c.p.reportFailure(c.id, "Get: only a file pane takes it");
- var failed: anyerror = error.Unexpected;
var home_buf: [4096]u8 = undefined;
const path = if (typed.len == 0) c.pane.file.?.path else std.Io.Dir.path.resolvePosix(c.p.scratch.allocator(), &.{ Pardes.paneDir(c.pane), @import("fs.zig").expandHome(typed, &home_buf) }) catch |err| return c.p.reportError(c.id, "Get", err);
// A file that is not there, or a directory, is said before unsaved
@@ -855,13 +854,13 @@ pub const Get = struct {
return c.p.reportFailure(c.id, said.print("Get: {s}: {s}", .{ path[0..@min(path.len, 256)], if (kind == null) "no such file" else "is a directory" }));
};
if (ctl.getRefused(c.p, c.pane, "Get")) |said| return c.p.reportFailure(c.id, said);
- const errno = if (typed.len == 0) ctl.get(c.p, c.pane, &failed) else ctl.getFile(c.p, c.pane, path, &failed);
- if (errno != 0) {
+ const got = if (typed.len == 0) ctl.get(c.p, c.pane) else ctl.getFile(c.p, c.pane, path);
+ got catch |err| {
var said: pardes.Kind.Buf(400) = .{};
var words: [128]u8 = undefined;
- const why = if (failed == error.FileNotFound) "no such file" else pardes.Messages.errorWords(failed, &words);
+ const why = if (err == error.FileNotFound) "no such file" else pardes.Messages.errorWords(err, &words);
c.p.reportFailure(c.id, said.print("Get: {s}: {s}", .{ path[0..@min(path.len, 256)], why }));
- }
+ };
}
};
@@ -923,8 +922,11 @@ pub const Incl = struct {
for (p.incl.items) |dir| {
if (std.mem.eql(u8, dir, full)) break;
} else {
- const copy = p.gpa.dupe(u8, full) catch return;
- p.incl.append(p.gpa, copy) catch return p.gpa.free(copy);
+ const copy = p.gpa.dupe(u8, full) catch |err| return p.reportError(c.id, "Incl", err);
+ p.incl.append(p.gpa, copy) catch |err| {
+ p.gpa.free(copy);
+ return p.reportError(c.id, "Incl", err);
+ };
}
}
if (typed.len > 0) return;
@@ -958,19 +960,20 @@ pub const Plumb = struct {
return p.reportFailure(c.id, std.fmt.bufPrint(&said, "Plumb: {s}", .{why}) catch "Plumb: invalid rule");
// One blank between words, as the list shows it.
var rule: std.ArrayList(u8) = .empty;
+ defer rule.deinit(p.gpa);
var words = std.mem.tokenizeAny(u8, typed, " \t");
while (words.next()) |w| {
- if (rule.items.len > 0) rule.append(p.gpa, ' ') catch return rule.deinit(p.gpa);
- rule.appendSlice(p.gpa, w) catch return rule.deinit(p.gpa);
+ if (rule.items.len > 0) rule.append(p.gpa, ' ') catch |err| return p.reportError(c.id, "Plumb", err);
+ rule.appendSlice(p.gpa, w) catch |err| return p.reportError(c.id, "Plumb", err);
}
- const owned = rule.toOwnedSlice(p.gpa) catch return rule.deinit(p.gpa);
- p.plumb.append(p.gpa, owned) catch return p.gpa.free(owned);
+ p.plumb.ensureUnusedCapacity(p.gpa, 1) catch |err| return p.reportError(c.id, "Plumb", err);
+ p.plumb.appendAssumeCapacity(rule.toOwnedSlice(p.gpa) catch |err| return p.reportError(c.id, "Plumb", err));
return;
}
var list: std.Io.Writer.Allocating = .init(p.scratch.allocator());
- list.writer.writeAll("Plumb:") catch return;
- for (p.plumb.items, 0..) |rule, i| list.writer.print("{s} {s}", .{ if (i == 0) "" else ";", rule }) catch return;
- if (p.plumb.items.len == 0) list.writer.writeAll(" none") catch return;
+ list.writer.writeAll("Plumb:") catch |err| return p.reportError(c.id, "Plumb", err);
+ for (p.plumb.items, 0..) |rule, i| list.writer.print("{s} {s}", .{ if (i == 0) "" else ";", rule }) catch |err| return p.reportError(c.id, "Plumb", err);
+ if (p.plumb.items.len == 0) list.writer.writeAll(" none") catch |err| return p.reportError(c.id, "Plumb", err);
p.setMessage(c.id, list.written());
}
};
@@ -1137,7 +1140,7 @@ pub const Undo = struct {
pub fn run(c: Ctx) void {
if (@import("edit_cmd.zig").busyOn(c.p, c.id)) return c.p.reportFailure(c.id, "Undo: " ++ @import("edit_cmd.zig").e_busy);
if (c.pane.file) |f| if (f.history.journal.done == 0) return c.p.setMessage(c.id, "Undo: nothing to undo");
- edit.undoStep(c.p, &c.pane.body, true);
+ edit.undoStep(c.p, &c.pane.body, true) catch |err| c.p.reportError(c.id, "Undo", err);
}
};
@@ -1146,7 +1149,7 @@ pub const Redo = struct {
pub fn run(c: Ctx) void {
if (@import("edit_cmd.zig").busyOn(c.p, c.id)) return c.p.reportFailure(c.id, "Redo: " ++ @import("edit_cmd.zig").e_busy);
if (c.pane.file) |f| if (f.history.journal.done == f.history.journal.steps.items.len) return c.p.setMessage(c.id, "Redo: nothing to redo");
- edit.undoStep(c.p, &c.pane.body, false);
+ edit.undoStep(c.p, &c.pane.body, false) catch |err| c.p.reportError(c.id, "Redo", err);
}
};
diff --git a/src/edit.zig b/src/edit.zig
index 5b2630fb..a458a034 100644
--- a/src/edit.zig
+++ b/src/edit.zig
@@ -35,14 +35,14 @@ pub const Error = error{ OutOfMemory, WriteFailed, UnknownPoint };
/// names (`"<reg>`), the default one otherwise. `_` swallows it, and the
/// registers computed from the editor (`#`, `.`, `%`) cannot be written.
/// `+` and `*` are the system clipboard: the value is sent there too.
-pub fn setYank(p: *Pardes, text: []const u8) void {
+pub fn setYank(p: *Pardes, text: []const u8) error{OutOfMemory}!void {
var name: u21 = if (p.view().register != 0) p.view().register else Registers.default;
switch (name) {
'_', '#', '.', '%' => return,
'*' => name = '+',
else => {},
}
- p.registers.put(p.gpa, name, text, p.multi_index, p.multi_count, p.multi_first);
+ try p.registers.put(p.gpa, name, text, p.multi_index, p.multi_count, p.multi_first);
if (name == '+' and p.multi_first) p.emit(.{ .set_clipboard = {} });
}
@@ -181,7 +181,7 @@ pub fn clipYank(p: *Pardes, pane: *Pane, main_only: bool) void {
defer v.register = named;
// A kind's pane: what it has selected (Kind.Slot.selection).
if (pane.addon) |k| {
- if (k.selection.len > 0) setYank(p, k.selection);
+ if (k.selection.len > 0) setYank(p, k.selection) catch |err| p.reportError(p.view().active, "yank", err);
return;
}
if (pane.body.nsel > 0 and !main_only) {
@@ -467,21 +467,21 @@ fn editTextEol(p: *Pardes, t: *Text, b: Bounds) Error!?panes.EditText {
}
/// install a rewritten editable text (frees the old one)
-pub fn setEditText(p: *Pardes, t: *Text, new: []u8) void {
- setEditTextEnd(p, t, new, null);
+pub fn setEditText(p: *Pardes, t: *Text, new: []u8) Error!void {
+ return setEditTextEnd(p, t, new, null);
}
/// `setEditText` with where the edit ended in `new` (in the edit text's
/// 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);
+pub fn setEditTextEnd(p: *Pardes, t: *Text, new: []u8, known_end: ?modal.Cursor) Error!void {
+ return 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 {
+fn setEditTextSpan(p: *Pardes, t: *Text, new: []u8, known_end: ?modal.Cursor, span: ?panes.File.Span) Error!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.
@@ -489,12 +489,12 @@ fn setEditTextSpan(p: *Pardes, t: *Text, new: []u8, known_end: ?modal.Cursor, sp
// caller reads the new text back, as a body's is kept.
defer retireEditText(p, new);
const pane = t.pane() orelse return;
- const prefix = tagline.pathPrefix(p, p.scratch.allocator(), pane) catch |err| return p.reportError(p.view().active, "edit", err);
+ const prefix = try tagline.pathPrefix(p, p.scratch.allocator(), pane);
if (!std.mem.startsWith(u8, new, prefix)) {
t.refused = true;
return;
}
- const tail = p.gpa.dupe(u8, new[prefix.len..]) catch |err| return p.reportError(p.view().active, "edit", err);
+ const tail = try p.gpa.dupe(u8, new[prefix.len..]);
if (t.own) |old| p.gpa.free(old);
t.own = tail;
return;
@@ -570,13 +570,13 @@ pub fn clampFileCursor(t: *Text) bool {
return old_row != t.cur_row or old_col != t.cur_col;
}
-pub fn enterInsert(p: *Pardes, t: *Text, where: InsertAt, cnt: usize) void {
+pub fn enterInsert(p: *Pardes, t: *Text, where: InsertAt, cnt: usize) Error!void {
if (t.what == .body) if (t.pane()) |pane| if (pane.addon != null) return;
pinPaneCursor(p, t);
_ = clampFileCursor(t);
// snapshot once per insert session (WITH the pre-insert selection) so
// `u` undoes the whole session and restores what was selected
- pushUndo(p, t);
+ try pushUndo(p, t);
t.select = false;
t.restore_cursor = false;
t.sticky_col = -1;
@@ -612,8 +612,8 @@ pub fn enterInsert(p: *Pardes, t: *Text, where: InsertAt, cnt: usize) void {
const terminal = t.what == .body and if (t.pane()) |pane| pane.isTerminal() else false;
var now = text;
if (hi < text.len and gap >= text.len and !terminal) {
- const grown = std.mem.concat(p.gpa, u8, &.{ text, "\n" }) catch |err| return p.reportError(p.view().active, "edit", err);
- setEditText(p, t, grown);
+ const grown = try std.mem.concat(p.gpa, u8, &.{ text, "\n" });
+ try setEditText(p, t, grown);
now = grown; // what setEditText keeps; `text` may be gone
}
const gc = modal.positionAt(now, gap);
@@ -637,12 +637,12 @@ pub fn enterInsert(p: *Pardes, t: *Text, where: InsertAt, cnt: usize) void {
t.vsel.active = false;
const below = where == .open_below;
const abs: i32 = if (b) |bb| (if (below) bb.hi_row else bb.lo_row) else t.cur_row;
- const eb = (editText(p, t, abs, abs, -1) catch |err| return p.reportError(p.view().active, "edit", err)) orelse return;
+ const eb = (try editText(p, t, abs, abs, -1)) orelse return;
const row: usize = @intCast(@max(0, abs - eb.row0));
const ind = modal.indentText(modal.lineSlice(eb.text, row));
const arena = p.scratch.allocator();
- const block_len = std.math.mul(usize, cnt, ind.len + 1) catch return p.reportError(p.view().active, "edit", error.OutOfMemory);
- const block = arena.alloc(u8, block_len) catch |err| return p.reportError(p.view().active, "edit", err);
+ const block_len = std.math.mul(usize, cnt, ind.len + 1) catch return error.OutOfMemory;
+ const block = try arena.alloc(u8, block_len);
var block_at: usize = 0;
for (0..cnt) |_| {
if (below) {
@@ -660,8 +660,8 @@ pub fn enterInsert(p: *Pardes, t: *Text, where: InsertAt, cnt: usize) void {
.{ .row = row, .col = modal.lineSlice(eb.text, row).len }
else
.{ .row = row, .col = 0 };
- const new = modal.insertAt(p.gpa, eb.text, at, block) catch |err| return p.reportError(p.view().active, "edit", err);
- setEditText(p, t, new);
+ const new = try modal.insertAt(p.gpa, eb.text, at, block);
+ try setEditText(p, t, new);
t.cur_row = @as(i32, @intCast(if (below) row + 1 else row)) + eb.row0;
t.cur_col = @intCast(ind.len);
t.cur_pinned = true;
@@ -848,7 +848,7 @@ fn insertEdit(p: *Pardes, t: *Text, key: Key) Error!void {
t.last_edit = .{ .row = @intCast(end.row), .col = @intCast(end.col) };
} else {
const new = try modal.spliceAlloc(p.gpa, text, at, at, key.text);
- setEditTextSpan(p, t, new, end, .{ .head = at, .tail = text.len - at });
+ try setEditTextSpan(p, t, new, end, .{ .head = at, .tail = text.len - at });
}
t.cur_row = @as(i32, @intCast(end.row)) + eb.row0;
t.cur_col = @intCast(end.col);
@@ -869,7 +869,7 @@ fn insertEdit(p: *Pardes, t: *Text, key: Key) Error!void {
const from = @min(wr.anchor, wr.head);
const fc = modal.positionAt(e2.text, from);
const new = try modal.deleteSpan(p.gpa, e2.text, fc, c2);
- setEditTextEnd(p, t, new, fc);
+ try setEditTextEnd(p, t, new, fc);
t.cur_row = @as(i32, @intCast(fc.row)) + e2.row0;
t.cur_col = @intCast(fc.col);
t.cur_pinned = true;
@@ -887,13 +887,13 @@ fn insertEdit(p: *Pardes, t: *Text, key: Key) Error!void {
const to = @max(wr.anchor, wr.head);
if (to <= g) return;
const new = try modal.deleteSpan(p.gpa, e2.text, c2, modal.positionAt(e2.text, to));
- setEditTextEnd(p, t, new, c2);
+ try setEditTextEnd(p, t, new, c2);
t.cur_pinned = true;
return;
}
if (hit(key, config.kill_to_line_start)) {
const new = try modal.deleteSpan(p.gpa, text, .{ .row = c.row, .col = 0 }, c);
- setEditTextEnd(p, t, new, .{ .row = c.row, .col = 0 });
+ try setEditTextEnd(p, t, new, .{ .row = c.row, .col = 0 });
t.cur_col = 0;
t.cur_pinned = true;
t.show();
@@ -902,7 +902,7 @@ fn insertEdit(p: *Pardes, t: *Text, key: Key) Error!void {
if (hit(key, config.kill_to_line_end)) {
const llen = modal.lineSlice(text, c.row).len;
const new = try modal.deleteSpan(p.gpa, text, c, .{ .row = c.row, .col = llen });
- setEditTextEnd(p, t, new, c);
+ try setEditTextEnd(p, t, new, c);
t.cur_pinned = true;
return;
}
@@ -915,7 +915,7 @@ fn insertEdit(p: *Pardes, t: *Text, key: Key) Error!void {
// cursor go and the new line takes the indent
if (std.mem.indexOfNone(u8, before, " \t") == null) {
const new = try modal.insertAt(p.gpa, text, .{ .row = c.row, .col = 0 }, "\n");
- setEditTextEnd(p, t, new, .{ .row = c.row + 1, .col = 0 });
+ try setEditTextEnd(p, t, new, .{ .row = c.row + 1, .col = 0 });
t.cur_row += 1;
t.cur_pinned = true;
t.show();
@@ -939,7 +939,7 @@ fn insertEdit(p: *Pardes, t: *Text, key: Key) Error!void {
const cut = try modal.deleteSpan(p.gpa, text, .{ .row = c.row, .col = kept }, c);
defer p.gpa.free(cut);
const new = try modal.insertAt(p.gpa, cut, .{ .row = c.row, .col = kept }, block);
- setEditTextEnd(p, t, new, .{ .row = c.row + 1, .col = indent });
+ try setEditTextEnd(p, t, new, .{ .row = c.row + 1, .col = indent });
t.cur_row += 1;
t.cur_col = @intCast(indent);
t.cur_pinned = true;
@@ -972,7 +972,7 @@ fn insertEdit(p: *Pardes, t: *Text, key: Key) Error!void {
} else {
const new = if (e > s) try modal.spliceAlloc(p.gpa, text, s, e, "") else try p.gpa.dupe(u8, text);
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);
+ try setEditTextSpan(p, t, new, .{ .row = c.row, .col = prev }, span);
}
t.cur_col = @intCast(prev);
t.cur_pinned = true;
@@ -987,7 +987,7 @@ fn insertEdit(p: *Pardes, t: *Text, key: Key) Error!void {
if (row == 0) return;
const prevlen = modal.lineSlice(e2.text, row - 1).len;
const new = try modal.deleteSpan(p.gpa, e2.text, .{ .row = row - 1, .col = prevlen }, .{ .row = row, .col = 0 });
- setEditTextEnd(p, t, new, .{ .row = row - 1, .col = prevlen });
+ try setEditTextEnd(p, t, new, .{ .row = row - 1, .col = prevlen });
t.cur_row -= 1;
t.cur_col = @intCast(prevlen);
t.cur_pinned = true;
@@ -1000,13 +1000,13 @@ fn insertEdit(p: *Pardes, t: *Text, key: Key) Error!void {
if (c.col < line.len) {
const at = modal.offsetAt(text, c);
const new = try modal.spliceAlloc(p.gpa, text, at, modal.nextGrapheme(text, at), "");
- setEditTextEnd(p, t, new, c);
+ try setEditTextEnd(p, t, new, c);
} else {
const e2 = (try editText(p, t, t.cur_row, t.cur_row + 1, t.cur_col)) orelse return;
const row: usize = @intCast(@max(0, t.cur_row - e2.row0));
if (row + 1 >= modal.lineCount(e2.text)) return;
const new = try modal.deleteSpan(p.gpa, e2.text, .{ .row = row, .col = c.col }, .{ .row = row + 1, .col = 0 });
- setEditTextEnd(p, t, new, .{ .row = row, .col = c.col });
+ try setEditTextEnd(p, t, new, .{ .row = row, .col = c.col });
}
t.cur_pinned = true;
},
@@ -1031,21 +1031,21 @@ fn insertEdit(p: *Pardes, t: *Text, key: Key) Error!void {
if (!syntax.supportsPath(f.path)) break :smart;
return normal.nodeSelect(p, pane, t, .parent_node_end);
}
- insertTab(p, t);
+ try insertTab(p, t);
},
else => {},
}
}
-pub fn insertTab(p: *Pardes, t: *Text) void {
- const eb = (editText(p, t, t.cur_row, t.cur_row, t.cur_col) catch |err| return p.reportError(p.view().active, "edit", err)) orelse return;
+pub fn insertTab(p: *Pardes, t: *Text) Error!void {
+ const eb = (try editText(p, t, t.cur_row, t.cur_row, t.cur_col)) orelse return;
const c: modal.Cursor = .{
.row = @intCast(@max(0, t.cur_row - eb.row0)),
.col = @intCast(@max(0, t.cur_col)),
};
const pad = modal.INDENT_W - (c.col % modal.INDENT_W);
- const new = modal.insertAt(p.gpa, eb.text, c, " "[0..pad]) catch |err| return p.reportError(p.view().active, "edit", err);
- setEditTextEnd(p, t, new, .{ .row = c.row, .col = c.col + pad });
+ const new = try modal.insertAt(p.gpa, eb.text, c, " "[0..pad]);
+ try setEditTextEnd(p, t, new, .{ .row = c.row, .col = c.col + pad });
t.cur_col += @intCast(pad);
t.cur_pinned = true;
t.show();
@@ -1078,14 +1078,14 @@ pub fn normalDelete(p: *Pardes, t: *Text, yank: bool) Error!void {
// cell too, where the delete joins the lines.
if (!t.vsel.active) t.vsel = .{ .active = true, .row = t.cur_row, .col = t.cur_col, .explicit = false };
const b = vselBounds(t);
- if (yank) setYank(p, try vselText(p, t)); // read the range before the move
- pushUndo(p, t);
+ if (yank) try setYank(p, try vselText(p, t)); // read the range before the move
+ try pushUndo(p, t);
const eb = (try editTextEol(p, t, b)) orelse {
t.vsel.active = false;
return;
};
const new = try deleteSelection(p, t, eb);
- setEditText(p, t, new);
+ try setEditText(p, t, new);
t.cur_row = b.lo_row;
t.cur_col = b.lo_col;
t.clampCursor(new, eb.row0);
@@ -1094,15 +1094,15 @@ pub fn normalDelete(p: *Pardes, t: *Text, yank: bool) Error!void {
pub fn normalYank(p: *Pardes, t: *Text) Error!void {
t.select = false;
if (t.what == .body) if (t.pane()) |pane| if (pane.rawPointerText(pane.sel[sel_slot])) |text| {
- setYank(p, text);
+ try setYank(p, text);
return;
};
- setYank(p, try if (t.vsel.active) vselText(p, t) else selText(p, t));
+ try setYank(p, try if (t.vsel.active) vselText(p, t) else selText(p, t));
}
pub fn pasteText(p: *Pardes, t: *Text, y0: []const u8, before: bool, count: usize) Error!void {
if (y0.len == 0) return;
- pushUndo(p, t);
+ try pushUndo(p, t);
t.select = false;
t.sticky_col = -1;
const arena = p.scratch.allocator();
@@ -1133,7 +1133,7 @@ pub fn pasteText(p: *Pardes, t: *Text, y0: []const u8, before: bool, count: usiz
out = try modal.pasteLineBelow(p.gpa, eb.text, row, block_text);
t.cur_row = @as(i32, @intCast(row + n)) + row0;
}
- setEditText(p, t, out);
+ try setEditText(p, t, out);
t.vsel = .{ .active = true, .row = t.cur_row - @as(i32, @intCast(n - 1)), .col = 0, .explicit = false };
// cursor ON the last pasted line's '\n' (helix)
const llen = modal.lineSlice(out, @intCast(@max(0, t.cur_row - row0))).len;
@@ -1150,7 +1150,7 @@ pub fn pasteText(p: *Pardes, t: *Text, y0: []const u8, before: bool, count: usiz
break :blk .{ .row = hrow, .col = gcol };
};
const out = try modal.insertAt(p.gpa, eb.text, at, y);
- setEditText(p, t, out);
+ try setEditText(p, t, out);
t.vsel = .{ .active = modal.nextGrapheme(y, 0) < y.len, .row = @as(i32, @intCast(at.row)) + row0, .col = @intCast(at.col), .explicit = false };
const end = modal.advanceBy(at, y);
if (end.col > 0) {
@@ -1173,17 +1173,17 @@ pub fn normalChange(p: *Pardes, t: *Text) Error!void {
const eb = (try editTextEol(p, t, b)) orelse return;
const hi_len = modal.lineSlice(eb.text, @intCast(@max(0, b.hi_row - eb.row0))).len;
if (b.lo_col == 0 and @as(usize, @intCast(@max(0, b.hi_col))) >= hi_len) {
- setYank(p, try vselText(p, t));
- pushUndo(p, t);
+ try setYank(p, try vselText(p, t));
+ try pushUndo(p, t);
const d = try modal.deleteLines(p.gpa, eb.text, @intCast(@max(0, b.lo_row - eb.row0)), @intCast(@max(0, b.hi_row - eb.row0)));
- setEditText(p, t, d);
+ try setEditText(p, t, d);
const n = modal.lineCount(d);
const row: usize = @min(@as(usize, @intCast(@max(0, b.lo_row - eb.row0))), if (n == 0) 0 else n - 1);
const ind = modal.indentText(modal.lineSlice(d, row));
const arena = p.scratch.allocator();
const block = try std.fmt.allocPrint(arena, "{s}\n", .{ind});
const new = try modal.insertAt(p.gpa, d, .{ .row = row, .col = 0 }, block);
- setEditText(p, t, new);
+ try setEditText(p, t, new);
t.cur_row = @as(i32, @intCast(row)) + eb.row0;
t.cur_col = @intCast(ind.len);
t.vsel.active = false;
@@ -1193,10 +1193,10 @@ pub fn normalChange(p: *Pardes, t: *Text) Error!void {
t.show();
return;
}
- setYank(p, try vselText(p, t));
- pushUndo(p, t);
+ try setYank(p, try vselText(p, t));
+ try pushUndo(p, t);
const new = try deleteSelection(p, t, eb);
- setEditText(p, t, new);
+ try setEditText(p, t, new);
t.cur_row = b.lo_row;
t.cur_col = b.lo_col;
t.clampCursor(new, eb.row0);
@@ -1204,12 +1204,12 @@ pub fn normalChange(p: *Pardes, t: *Text) Error!void {
t.normal.clear();
return;
}
- pushUndo(p, t);
+ try pushUndo(p, t);
const eb = (try editTextEol(p, t, selRows(t))) orelse return;
const r = t.primaryRange(eb.text, eb.row0);
- setYank(p, eb.text[r.anchor..r.head]);
+ try setYank(p, eb.text[r.anchor..r.head]);
const new = try modal.spliceAlloc(p.gpa, eb.text, r.anchor, r.head, "");
- setEditText(p, t, new);
+ try setEditText(p, t, new);
const llen = modal.lineSlice(new, @intCast(@max(0, t.cur_row - eb.row0))).len;
t.cur_col = @min(t.cur_col, @as(i32, @intCast(llen)));
t.mode = .insert;
@@ -1248,7 +1248,7 @@ fn setEditCells(p: *Pardes, t: *Text, new: []u8, row0: i32, cells: []const Text.
const ac = modal.positionAt(new, c.anc);
s.* = .{ .row = @as(i32, @intCast(cc.row)) + row0, .col = @intCast(cc.col), .arow = @as(i32, @intCast(ac.row)) + row0, .acol = @intCast(ac.col) };
}
- setEditText(p, t, new);
+ try setEditText(p, t, new);
const text = try flatSurface(p, t);
var rs: [Text.max_selections]modal.Selection = undefined;
for (sels[0..cells.len], rs[0..cells.len]) |s, *r| r.* = Text.cellRange(text, s.arow, s.acol, s.row, s.col);
@@ -1270,9 +1270,9 @@ pub fn normalReplaceChar(p: *Pardes, t: *Text, ch: u21) Error!void {
const encoded_len = std.unicode.utf8Encode(ch, &encoded) catch return; // a surrogate half types nothing
const rep = try p.scratch.allocator().alloc(u8, graphemes * encoded_len);
for (0..graphemes) |i| @memcpy(rep[i * encoded_len ..][0..encoded_len], encoded[0..encoded_len]);
- pushUndo(p, t);
+ try pushUndo(p, t);
const new = try modal.spliceAlloc(p.gpa, eb.text, lo, hi, rep);
- setEditText(p, t, new);
+ try setEditText(p, t, new);
const end = lo + rep.len;
const mapped: modal.Selection = if (before.head < before.anchor)
.{ .anchor = end, .head = lo }
@@ -1297,9 +1297,9 @@ fn replaceWithText(p: *Pardes, t: *Text, y: []const u8) Error!void {
const eb = (try editTextEol(p, t, selRows(t))) orelse return;
const r = t.primaryRange(eb.text, eb.row0);
const lo = @min(r.anchor, r.head);
- pushUndo(p, t);
+ try pushUndo(p, t);
const new = try modal.spliceAlloc(p.gpa, eb.text, lo, @max(r.anchor, r.head), y);
- setEditText(p, t, new);
+ try setEditText(p, t, new);
const end = lo + y.len;
t.setRange(new, eb.row0, if (r.head < r.anchor) .{ .anchor = end, .head = lo } else .{ .anchor = lo, .head = end }, false);
}
@@ -1310,9 +1310,9 @@ pub fn normalCase(p: *Pardes, t: *Text, op: modal.CaseOp) Error!void {
t.select = false;
const eb = (try editTextEol(p, t, selRows(t))) orelse return;
const r = t.primaryRange(eb.text, eb.row0);
- pushUndo(p, t);
+ try pushUndo(p, t);
const new = try modal.changeCase(p.gpa, eb.text, @min(r.anchor, r.head), @max(r.anchor, r.head), op);
- setEditText(p, t, new);
+ try setEditText(p, t, new);
}
/// Where `pos` lands after `chs`, which are ascending and disjoint.
@@ -1371,7 +1371,7 @@ pub fn normalJoin(p: *Pardes, t: *Text, select_space: bool) Error!void {
const chs = changes.items;
const chs_len = chs.len;
if (chs_len == 0) return;
- pushUndo(p, t);
+ try pushUndo(p, t);
const new = try sam.apply(p.gpa, text, chs[0..chs_len]);
// every range's cells ride through the edit; Alt-J replaces them with
// the spaces, when it put any in
@@ -1422,7 +1422,7 @@ pub fn normalRotateContents(p: *Pardes, t: *Text, forward: bool, cnt: usize) Err
.text = text[@min(src.anchor, src.head)..@max(src.anchor, src.head)],
};
}
- pushUndo(p, t);
+ try pushUndo(p, t);
const new = try sam.apply(p.gpa, text, chs[0..n]);
var cells: [Text.max_selections]Text.Cells = undefined;
var delta: i64 = 0;
@@ -1490,7 +1490,7 @@ pub fn normalAlign(p: *Pardes, t: *Text) Error!void {
m += 1;
}
if (m == 0) return;
- pushUndo(p, t);
+ try pushUndo(p, t);
const new = try sam.apply(p.gpa, text, chs[0..m]);
var cells: [Text.max_selections]Text.Cells = undefined;
for (rs[0..n], cells[0..n]) |r, *cell| {
@@ -1544,7 +1544,7 @@ pub fn normalIndent(p: *Pardes, t: *Text, cnt: usize, add: bool) Error!void {
}
}
if (chs_len == 0) return;
- pushUndo(p, t);
+ try pushUndo(p, t);
const cur_off = modal.offsetAt(text, .{ .row = @intCast(@max(0, t.cur_row - eb.row0)), .col = @intCast(@max(0, t.cur_col)) });
const anc_off = if (t.vsel.active)
modal.offsetAt(text, .{ .row = @intCast(@max(0, t.vsel.row - eb.row0)), .col = @intCast(@max(0, t.vsel.col)) })
@@ -1553,7 +1553,7 @@ pub fn normalIndent(p: *Pardes, t: *Text, cnt: usize, add: bool) Error!void {
const new = try sam.apply(p.gpa, text, chs[0..chs_len]);
const nc = mapThroughChanges(chs[0..chs_len], cur_off);
const na = mapThroughChanges(chs[0..chs_len], anc_off);
- setEditText(p, t, new);
+ try setEditText(p, t, new);
const cc = modal.positionAt(new, nc);
const ac = modal.positionAt(new, na);
t.cur_row = @as(i32, @intCast(cc.row)) + eb.row0;
@@ -1635,7 +1635,7 @@ pub fn normalToggleComment(p: *Pardes, t: *Text) Error!void {
.{ .q0 = @intCast(at), .q1 = @intCast(at), .text = ins };
chs_len += 1;
}
- pushUndo(p, t);
+ try pushUndo(p, t);
// one edit, and the WHOLE selection rides through it (helix maps the
// selection with the transaction)
var cells: [Text.max_selections]Text.Cells = undefined;
@@ -1653,10 +1653,10 @@ pub fn normalAdjustNumber(p: *Pardes, t: *Text, delta: i64) Error!void {
const lo = @min(r.anchor, r.head);
const hi = @max(r.anchor, r.head);
const rep = (modal.incrementDecimal(p.scratch.allocator(), eb.text[lo..hi], delta) catch null) orelse return;
- pushUndo(p, t);
+ try pushUndo(p, t);
t.select = false;
const new = try modal.spliceAlloc(p.gpa, eb.text, lo, hi, rep);
- setEditText(p, t, new);
+ try setEditText(p, t, new);
t.setRange(new, eb.row0, .{ .anchor = lo, .head = lo + rep.len }, false);
}
@@ -1667,14 +1667,14 @@ pub fn addNewline(p: *Pardes, t: *Text, below: bool, cnt: usize) Error!void {
const sr = selRows(t);
const at = if (below) sr.hi_row else sr.lo_row;
const eb = (try editText(p, t, at, at, -1)) orelse return;
- pushUndo(p, t);
+ try pushUndo(p, t);
const row: usize = @intCast(@max(0, at - eb.row0));
const arena = p.scratch.allocator();
const nl = try arena.alloc(u8, cnt);
@memset(nl, '\n');
const llen = modal.lineSlice(eb.text, row).len;
const new = try modal.insertAt(p.gpa, eb.text, .{ .row = row, .col = if (below) llen else 0 }, nl);
- setEditText(p, t, new);
+ try setEditText(p, t, new);
if (!below) {
// the whole selection moved down; stay on it
const n: i32 = @intCast(cnt);
@@ -1760,11 +1760,11 @@ pub fn surroundAdd(p: *Pardes, t: *Text, ch: u21) Error!void {
const r = t.primaryRange(eb.text, eb.row0);
const lo = @min(r.anchor, r.head);
const hi = @max(r.anchor, r.head);
- pushUndo(p, t);
+ try pushUndo(p, t);
const open = [1]u8{pr.o};
const close = [1]u8{pr.c};
const new = try sam.apply(p.gpa, eb.text, &.{ .{ .q0 = @intCast(lo), .q1 = @intCast(lo), .text = &open }, .{ .q0 = @intCast(hi), .q1 = @intCast(hi), .text = &close } });
- setEditText(p, t, new);
+ try setEditText(p, t, new);
// the wrapped range keeps the direction it had (helix with_direction)
t.setRange(new, eb.row0, if (r.head < r.anchor) .{ .anchor = hi + 2, .head = lo } else .{ .anchor = lo, .head = hi + 2 }, false);
}
@@ -1785,7 +1785,7 @@ pub fn surroundDelete(p: *Pardes, t: *Text, ch: u21) Error!void {
const drow = -eb.row0; // surface row -> buffer row
const ra: modal.Cursor = .{ .row = @intCast(@as(i32, @intCast(r.a.row)) + drow), .col = r.a.col };
const rb: modal.Cursor = .{ .row = @intCast(@as(i32, @intCast(r.b.row)) + drow), .col = r.b.col };
- pushUndo(p, t);
+ try pushUndo(p, t);
const a_off = modal.offsetAt(text, ra);
const b_off = modal.offsetAt(text, rb);
const cur_off = modal.offsetAt(text, .{ .row = @intCast(@as(i32, @intCast(cur.row)) + drow), .col = cur.col });
@@ -1793,7 +1793,7 @@ pub fn surroundDelete(p: *Pardes, t: *Text, ch: u21) Error!void {
.{ .q0 = @intCast(a_off), .q1 = @intCast(modal.nextGrapheme(text, a_off)), .text = "" },
.{ .q0 = @intCast(b_off), .q1 = @intCast(modal.nextGrapheme(text, b_off)), .text = "" },
});
- setEditText(p, t, new);
+ try setEditText(p, t, new);
var nc = cur_off;
if (nc > b_off) nc -= 1;
if (nc > a_off) nc -= 1;
@@ -1819,14 +1819,14 @@ pub fn surroundReplace(p: *Pardes, t: *Text, from: u21, to: u21) Error!void {
const drow = -eb.row0; // surface row -> buffer row
const ar: usize = @intCast(@as(i32, @intCast(r.a.row)) + drow);
const br: usize = @intCast(@as(i32, @intCast(r.b.row)) + drow);
- pushUndo(p, t);
+ try pushUndo(p, t);
const out = try p.gpa.dupe(u8, eb.text);
out[modal.lineStartOffset(out, ar) + r.a.col] = tp.o;
out[modal.lineStartOffset(out, br) + r.b.col] = tp.c;
- setEditText(p, t, out);
+ try setEditText(p, t, out);
}
-pub fn pushUndo(p: *Pardes, t: *Text) void {
+pub fn pushUndo(p: *Pardes, t: *Text) error{OutOfMemory}!void {
// one keystroke, one undo step — even when it edited at ten cursors.
if (!p.multi_first) return;
switch (t.what) {
@@ -1838,23 +1838,23 @@ pub fn pushUndo(p: *Pardes, t: *Text) void {
}
const pane = t.pane() orelse return;
if (pane.file != null) return panes.File.pushUndo(p, pane);
- panes.terminal.pushUndo(p, pane);
+ return panes.terminal.pushUndo(p, pane);
}
/// Undo (back) or redo one step of the text's history: its file's, its
/// terminal overlay's, or a tag's or header's own.
-pub fn undoStep(p: *Pardes, t: *Text, back: bool) void {
+pub fn undoStep(p: *Pardes, t: *Text, back: bool) error{OutOfMemory}!void {
if (t.what == .tag or t.what == .column or t.what == .workspace) return stepOwn(p, t, back);
if (t.what != .body) return;
const pane = t.pane() orelse return;
if (pane.file != null) return panes.File.undoStep(p, pane, back);
- panes.terminal.undoStep(p, pane, back);
+ return panes.terminal.undoStep(p, pane, back);
}
/// Undo or redo an edit of a text's own characters; stepping back past its
/// first edit gives a tag its default again.
-fn stepOwn(p: *Pardes, t: *Text, back: bool) void {
- const to = t.step(p.gpa, if (t.own) |own| .{ .text = own } else null, back) orelse return;
+fn stepOwn(p: *Pardes, t: *Text, back: bool) error{OutOfMemory}!void {
+ const to = (try t.step(p.gpa, if (t.own) |own| .{ .text = own } else null, back)) orelse return;
if (t.own) |own| p.gpa.free(own);
t.own = if (to.ovl) |buffer| buffer.text else null;
}
@@ -2206,10 +2206,10 @@ test "a typed edit's known end is where the texts' comparison would find it" {
const base = try p.gpa.dupe(u8, pane.file.?.content);
defer p.gpa.free(base);
const scanned = try modal.insertAt(p.gpa, base, c.at, c.s);
- setEditTextEnd(p, t, scanned, null);
+ try setEditTextEnd(p, t, scanned, null);
const by_scan = t.last_edit.?;
const known = try modal.insertAt(p.gpa, base, c.at, c.s);
- setEditTextEnd(p, t, known, modal.advanceBy(c.at, c.s));
+ try setEditTextEnd(p, t, known, modal.advanceBy(c.at, c.s));
try std.testing.expectEqual(by_scan.row, t.last_edit.?.row);
try std.testing.expectEqual(by_scan.col, t.last_edit.?.col);
}
diff --git a/src/edit_cmd.zig b/src/edit_cmd.zig
index b1239a84..f299a39d 100644
--- a/src/edit_cmd.zig
+++ b/src/edit_cmd.zig
@@ -198,7 +198,7 @@ pub fn run(p: *Pardes, id: usize, command: []const u8) void {
}
}
if (res.undo != 0) {
- for (0..@abs(res.undo)) |_| panes.File.undoStep(p, pane, res.undo > 0);
+ for (0..@abs(res.undo)) |_| panes.File.undoStep(p, pane, res.undo > 0) catch |err| return p.reportError(id, "Edit", err);
return;
}
pd.res = res;
@@ -357,9 +357,8 @@ fn commit(p: *Pardes, pd: *Pending, outputs: []const []const u8) void {
// back with the old text, and it leaves the pane clean.
for (res.files) |f| {
const path = f.get orelse continue;
- var failed: anyerror = error.Unexpected;
- const errno = @import("ninep/ctl.zig").getFile(p, p.panes[f.id].?, path, &failed);
- if (errno != 0) return p.reportFailure(at, text.print("Edit: e {s}: {s}", .{ path[0..@min(path.len, 256)], if (errno == @import("ninep/tree.zig").E.NOENT) "no such file" else "cannot be read" }));
+ @import("ninep/ctl.zig").getFile(p, p.panes[f.id].?, path) catch |err|
+ return p.reportFailure(at, text.print("Edit: e {s}: {s}", .{ path[0..@min(path.len, 256)], if (err == error.FileNotFound) "no such file" else "cannot be read" }));
}
// `w`'s bytes, written after this step, before anything else is. To
// its own file changed on disk since it was read, as Save is: refused
@@ -410,7 +409,10 @@ fn commit(p: *Pardes, pd: *Pending, outputs: []const []const u8) void {
const new = sam.apply(p.gpa, pf.content, ops) catch |err| return p.reportError(at, "Edit", err);
// `s/a/a/` changes nothing: no undo step, no new revision.
if (std.mem.eql(u8, new, pf.content)) p.gpa.free(new) else {
- panes.File.pushUndo(p, pane);
+ panes.File.pushUndo(p, pane) catch |err| {
+ p.gpa.free(new);
+ return p.reportError(at, "Edit", err);
+ };
panes.File.setContent(p, pf, new);
}
}
diff --git a/src/file_watch.zig b/src/file_watch.zig
index 56d2d8e5..788bcae1 100644
--- a/src/file_watch.zig
+++ b/src/file_watch.zig
@@ -771,7 +771,7 @@ test "ordinary file watches still reconcile changes between open and watch" {
};
try std.testing.expect(armed and watches[id] != null);
try std.testing.expectEqualStrings("changed before watch\n", pane.file.?.content);
- pardes.panes.File.undoStep(core, pane, true);
+ try pardes.panes.File.undoStep(core, pane, true);
try std.testing.expectEqualStrings("opened\n", pane.file.?.content);
}
diff --git a/src/fs.zig b/src/fs.zig
index a0092991..d90bb8c0 100644
--- a/src/fs.zig
+++ b/src/fs.zig
@@ -457,11 +457,15 @@ fn resolveVirtual(p: ?*pardes.Pardes, path: []const u8, out: *[4096]u8) ?Resolve
return null;
}
-pub fn read(p: *pardes.Pardes, path: []const u8) ![]u8 {
+/// What reading a file through the namespace fails with: the disk's, a
+/// peer's (Client.readMount), the served tree's.
+pub const ReadError = error{ Timeout, WriteFailed, PermissionDenied, FileNotFound, ReadFailed, OutOfMemory, Dial, BadDial, FileTooLarge, NodeCollision, TooManyFiles, OpenFailed, NotAFile, PathTooLong, IsDirectory, PathTooDeep, Hangup, Botch, Remote, NotFound };
+
+pub fn read(p: *pardes.Pardes, path: []const u8) ReadError![]u8 {
return readLimit(p, path, limits.max_file_bytes);
}
-pub fn readLimit(p: *pardes.Pardes, path: []const u8, max_bytes: usize) ![]u8 {
+pub fn readLimit(p: *pardes.Pardes, path: []const u8, max_bytes: usize) ReadError![]u8 {
const limit = @min(max_bytes, limits.max_file_bytes);
if (std.mem.eql(u8, std.mem.trimEnd(u8, path, "/"), "/n")) {
var out: std.Io.Writer.Allocating = .init(p.gpa);
diff --git a/src/keys.zig b/src/keys.zig
index 33760b8b..5be3a110 100644
--- a/src/keys.zig
+++ b/src/keys.zig
@@ -43,7 +43,7 @@ pub fn cycleMode(p: *Pardes, id: usize) void {
pane.body.mode = .normal;
pane.body.normal.clear();
},
- .normal => edit.enterInsert(p, &pane.body, .at, 1),
+ .normal => edit.enterInsert(p, &pane.body, .at, 1) catch |err| p.reportError(id, "edit", err),
.insert => {
edit.exitInsert(p, &pane.body);
if (pane.isTerminal()) panes.terminal.enterTty(p, id);
@@ -727,7 +727,7 @@ test "raw tty forwards Ctrl letters and former global shortcuts to the child" {
defer p.deinit();
var buf: [256]u8 = undefined;
_ = test_api.ptyBytes(p, null, &buf);
- edit.setYank(p, "register text");
+ try edit.setYank(p, "register text");
for ('a'..'z' + 1) |letter| {
if (letter == p.tty_toggle) continue; // editor/TTY mode shortcut
if (letter == 'v') continue; // the window's paste, asserted just below
diff --git a/src/look.zig b/src/look.zig
index 154e53bc..bde63bf3 100644
--- a/src/look.zig
+++ b/src/look.zig
@@ -396,7 +396,7 @@ pub fn submitSearch(p: *Pardes, id: usize) void {
if (normal.selRegexArmed(pane)) |a| {
// helix keeps the pattern in `/`
if (a.pat.len > 0) {
- p.registers.put(p.gpa, '/', a.pat, 0, 1, true);
+ p.registers.put(p.gpa, '/', a.pat, 0, 1, true) catch |err| return p.reportError(id, "search", err);
p.registers.last_search = '/';
}
return if (panes.promptTarget(p, pane)) |t| normal.applySelRegex(p, pane, t, a.pat, a.mode);
@@ -409,7 +409,7 @@ pub fn submitSearch(p: *Pardes, id: usize) void {
_ = runSearch(p, id, armed[slash + 1 ..], .top, true) catch |err| return p.reportError(id, "search", err);
var pattern: std.ArrayList(u8) = .empty;
normal.appendSearchLiteral(&pattern, p.scratch.allocator(), armed[slash + 1 ..]) catch |err| return p.reportError(id, "search", err);
- p.registers.put(p.gpa, '/', pattern.items, 0, 1, true);
+ p.registers.put(p.gpa, '/', pattern.items, 0, 1, true) catch |err| return p.reportError(id, "search", err);
p.registers.last_search = '/';
lookFirstHit(p, id);
}
diff --git a/src/lsp/Ask.zig b/src/lsp/Ask.zig
index b00a3384..250d6dba 100644
--- a/src/lsp/Ask.zig
+++ b/src/lsp/Ask.zig
@@ -224,7 +224,10 @@ fn applyLspEdits(p: *Pardes, pane: *Pane, revision: u32, edits: []const LspEdit)
}
@memcpy(replacement[write_at..], f.content[read_at..]);
- edit.pushUndo(p, &pane.body);
+ edit.pushUndo(p, &pane.body) catch {
+ p.gpa.free(replacement);
+ return false;
+ };
panes.File.setContent(p, f, replacement);
const cursor = modal.positionAt(f.content, mapped_cursor);
pane.body.cur_row = @intCast(cursor.row);
@@ -305,7 +308,7 @@ pub fn lspResponse(p: *Pardes, id: u32, response: ?[]const u8) void {
}
if (rows.len == 0) {
if (w.kind == .completion and pane.body.mode == .insert and pane.body.nsel == 0 and
- pane.body.cur_row == w.row and pane.body.cur_col == w.col) edit.insertTab(p, &pane.body);
+ pane.body.cur_row == w.row and pane.body.cur_col == w.col) edit.insertTab(p, &pane.body) catch |err| return p.reportError(w.pane, "complete", err);
// Nothing found fails, but for a file with no diagnostics,
// which is no failure, and a completion's Tab.
const none: ?[]const u8 = switch (w.kind) {
diff --git a/src/mouse.zig b/src/mouse.zig
index 7d2df7e8..c3cf64af 100644
--- a/src/mouse.zig
+++ b/src/mouse.zig
@@ -479,7 +479,7 @@ fn chordCutPaste(p: *Pardes, cut: bool) edit.Error!void {
// Everything done while B1 stays down is one undo step, as acme
// marks the file once per B1 hold (text.c:881 textselect, `state`
// and its one filemark): B1-B2 then B1-B3 is a copy.
- edit.pushUndo(p, &pane.body);
+ try edit.pushUndo(p, &pane.body);
p.view().chord_hold = true;
const sl = pane.sel[sel_slot];
pane.sel[sel_slot].state = .none;
@@ -510,7 +510,7 @@ fn chordCutPaste(p: *Pardes, cut: bool) edit.Error!void {
const y = p.registers.text(p.gpa, pardes.Registers.default) orelse return;
if (y.len == 0) return;
const at = modal.Cursor{ .row = @intCast(@max(0, pane.body.cur_row)), .col = @intCast(@max(0, pane.body.cur_col)) };
- edit.pushUndo(p, &pane.body);
+ try edit.pushUndo(p, &pane.body);
const new = try modal.insertAt(p.gpa, f.content, at, y);
panes.File.setContent(p, f, new);
pane.body.vsel = .{ .active = modal.nextGrapheme(y, 0) < y.len, .row = @intCast(at.row), .col = @intCast(at.col), .explicit = false };
@@ -1174,7 +1174,7 @@ fn mirrorTtySelection(p: *Pardes, pane: *Pane) void {
pane.body.restore_cursor = false;
pane.body.sticky_col = -1;
pane.body.normal.clear();
- edit.setYank(p, text);
+ edit.setYank(p, text) catch |err| p.reportError(p.view().active, "yank", err);
}
/// acme's double-click (text.c:881 textselect, plan9port text.c:1407
diff --git a/src/ninep/cols.zig b/src/ninep/cols.zig
index 5218b937..c8d84e5d 100644
--- a/src/ninep/cols.zig
+++ b/src/ninep/cols.zig
@@ -124,8 +124,8 @@ pub fn applyTruncation(p: *Pardes, serial: ?u32) void {
fn clear(p: *Pardes, serial: ?u32) tree.Status {
const t = (header(p, serial) orelse return .err).text;
- const empty = p.gpa.alloc(u8, 0) catch return .err;
- t.remember(p.gpa, if (t.own) |own| .{ .text = own } else null);
+ t.remember(p.gpa, if (t.own) |own| .{ .text = own } else null) catch return .err;
+ const empty = p.gpa.alloc(u8, 0) catch unreachable; // no byte: the allocator is not asked
if (t.own) |own| p.gpa.free(own);
t.own = empty;
t.cur_row = 0;
diff --git a/src/ninep/ctl.zig b/src/ninep/ctl.zig
index ce92ba30..dc66663e 100644
--- a/src/ninep/ctl.zig
+++ b/src/ninep/ctl.zig
@@ -711,7 +711,10 @@ pub fn fillPager(p: *Pardes, serial: u32, held: *std.ArrayList(u8)) error{OutOfM
const page = try pardes.pager.parse(p.gpa, held.items);
held.clearAndFree(p.gpa);
if (page.text.len == 0 and f.content.len == 0) return page.deinit(p.gpa);
- if (!pane.fs.nomark) panes.File.pushUndo(p, pane);
+ if (!pane.fs.nomark) panes.File.pushUndo(p, pane) catch |err| {
+ page.deinit(p.gpa);
+ return err;
+ };
panes.File.setContent(p, f, page.text);
f.pager_spans = page.spans;
f.saved_revision = f.revision;
@@ -1101,18 +1104,16 @@ pub fn writePane(p: *Pardes, req: Req, pane: *Pane) Reply {
// It ran and was refused: its words (in ename), not the line
// quoted, as a builtin's refusal (Save's) says it.
if (getRefused(p, pane, "get")) |said| return tree.failText(req.tag, E.IO, said);
- var failed: anyerror = error.Unexpected;
- const errno = get(p, pane, &failed);
// Naming the path, in words 9ns reads as the errno; a peer
// out of reach as a look or a Save says it.
- if (errno != 0) {
+ get(p, pane) catch |err| {
const path = if (pane_files.fileOf(pane)) |f| f.path else "";
var why_buf: pardes.Kind.Buf(48) = .{};
- const why = if (pardes.Messages.dialReason(failed)) |r|
+ const why = if (pardes.Messages.dialReason(err)) |r|
why_buf.print("dial failed: {s}", .{r})
- else if (errno == E.NOENT) "no such file" else "cannot be read";
- return tree.failText(req.tag, errno, std.fmt.bufPrint(&p.fs.ename, "get: {s}: {s}", .{ path[0..@min(path.len, 256)], why[0..@min(why.len, 48)] }) catch &p.fs.ename); // cut to ename's 320
- }
+ else if (err == error.FileNotFound) "no such file" else "cannot be read";
+ return tree.failText(req.tag, if (err == error.FileNotFound) E.NOENT else E.IO, std.fmt.bufPrint(&p.fs.ename, "get: {s}: {s}", .{ path[0..@min(path.len, 256)], why[0..@min(why.len, 48)] }) catch &p.fs.ename); // cut to ename's 320
+ };
},
.lock => {
if (mine == null) return tree.failText(req.tag, E.INVAL, tree.e_bad_ctl);
@@ -1270,22 +1271,18 @@ pub fn getRefused(p: *Pardes, pane: *Pane, word: []const u8) ?[]const u8 {
/// loaded into the pane, which takes its name, in one undo step that puts
/// the old name back with the old text. Read first, so one that cannot be
/// read changes nothing; loaded, the pane is clean. Asking about unsaved
-/// edits is the caller's (getRefused). Returns an errno, 0 when loaded.
-pub fn getFile(p: *Pardes, pane: *Pane, path: []const u8, failed: *anyerror) u16 {
- const f = pane_files.fileOf(pane) orelse return E.INVAL;
- const id = p.paneBySerial(pane.serial) orelse return E.NOENT;
- const bytes = fs.read(p, path) catch |err| {
- failed.* = err;
- return switch (err) {
- error.FileNotFound => E.NOENT,
- else => E.IO,
- };
+/// edits is the caller's (getRefused).
+pub fn getFile(p: *Pardes, pane: *Pane, path: []const u8) GetError!void {
+ const f = pane_files.fileOf(pane) orelse return error.NotAFile;
+ const id = p.paneBySerial(pane.serial) orelse return error.FileNotFound;
+ const bytes = try fs.read(p, path);
+ panes.File.pushUndo(p, pane) catch |err| {
+ p.gpa.free(bytes);
+ return err;
};
- panes.File.pushUndo(p, pane);
pane_files.nameBuffer(p, id, path, false) catch |err| {
p.gpa.free(bytes);
- failed.* = err;
- return E.INVAL;
+ return if (err == error.OutOfMemory) error.OutOfMemory else error.InvalidName;
};
panes.File.setContent(p, f, bytes);
f.saved_revision = f.revision;
@@ -1295,31 +1292,30 @@ pub fn getFile(p: *Pardes, pane: *Pane, path: []const u8, failed: *anyerror) u16
f.disk_newer_warned = false;
f.disk_gone = false;
if (fs.localPath(path) != null) p.emit(.{ .watch = .{ .pane = @intCast(id), .on = true } });
- return 0;
}
-pub fn get(p: *Pardes, pane: *Pane, failed: *anyerror) u16 {
- const f = pane_files.fileOf(pane) orelse return 0;
+/// What Get and Edit's `e` fail with, as their callers say it (the 9P
+/// reply's errno, FileNotFound ENOENT and the rest EIO; a peer's dial,
+/// Messages.dialReason; Get's words, Messages.errorWords): a read's, and a
+/// name the pane cannot take.
+pub const GetError = fs.ReadError || error{InvalidName};
+
+pub fn get(p: *Pardes, pane: *Pane) GetError!void {
+ const f = pane_files.fileOf(pane) orelse return;
// A directory pane: the directory read again (Dir.zig).
- if (f.listing != null) {
- panes.Dir.refresh(p, p.paneBySerial(pane.serial).?) catch |err| {
- failed.* = err;
- return if (err == error.FileNotFound) E.NOENT else E.IO;
- };
- return 0;
- }
- if (!panes.Output.fileTraits(f.output).saves) return 0;
- const bytes = fs.read(p, f.path) catch |err| {
- failed.* = err;
- return switch (err) {
- error.FileNotFound => E.NOENT,
- else => E.IO,
- };
+ if (f.listing != null) return panes.Dir.refresh(p, p.paneBySerial(pane.serial).?) catch |err| switch (err) {
+ error.FileNotFound, error.OutOfMemory => |e| e,
+ else => error.ReadFailed,
};
+ if (!panes.Output.fileTraits(f.output).saves) return;
+ const bytes = try fs.read(p, f.path);
// Throwing unsaved edits away for it is a reload the log hears of, as a
// clean one from the watch is.
const discarded = f.revision != f.saved_revision;
- panes.File.pushUndo(p, pane);
+ panes.File.pushUndo(p, pane) catch |err| {
+ p.gpa.free(bytes);
+ return err;
+ };
panes.File.setContent(p, f, bytes);
f.saved_revision = f.revision;
f.saved_hash = std.hash.Wyhash.hash(0, f.content);
@@ -1330,7 +1326,6 @@ pub fn get(p: *Pardes, pane: *Pane, failed: *anyerror) u16 {
var rec: [32]u8 = undefined;
pardes.ctlfs.events.notePath(p, "changed", std.fmt.bufPrint(&rec, "{d} reloaded", .{pane.serial}) catch unreachable); // a u32 fits 32
}
- return 0;
}
// ---- tests ----
@@ -2658,7 +2653,7 @@ test "what a /pager open writes after its directory is the text: plain in the bo
try testing.expectEqual(@as(usize, 0), f.pager_spans.len);
// Undone back to the paged text: the text comes back, its colours
// stay dropped (they were the program's, for the text it printed).
- panes.File.undoStep(p, pn, true);
+ try panes.File.undoStep(p, pn, true);
try testing.expectEqualStrings("red /a\nNext\n", f.content);
try testing.expectEqual(@as(usize, 0), f.pager_spans.len);
diff --git a/src/ninep/pane.zig b/src/ninep/pane.zig
index ce246465..b77d72d7 100644
--- a/src/ninep/pane.zig
+++ b/src/ninep/pane.zig
@@ -300,7 +300,7 @@ pub fn spliceBody(p: *Pardes, pane: *Pane, q0: usize, q1: usize, bytes: []const
if (std.mem.eql(u8, f.content[lo..hi], bytes[0..take])) return take;
const join = pane.fs.joined == f.revision;
pane.fs.joined = null;
- if (!pane.fs.nomark and !join) panes.File.pushUndo(p, pane);
+ if (!pane.fs.nomark and !join) panes.File.pushUndo(p, pane) catch return null;
if (!panes.File.replace(p, f, lo, hi - lo, bytes[0..take])) return null;
return take;
}
@@ -652,9 +652,10 @@ pub fn applyTagTruncation(p: *Pardes, pane: *Pane) void {
const pf = &pane.fs;
if (!pf.tag_trunc_pending) return;
pf.tag_trunc_pending = false;
- const empty = p.gpa.alloc(u8, 0) catch return;
// An edit like a keyboard one: `u` in the tag brings it back.
- pane.tag.remember(p.gpa, if (pane.tag.own) |own| .{ .text = own } else null);
+ pane.tag.remember(p.gpa, if (pane.tag.own) |own| .{ .text = own } else null) catch |err|
+ return p.reportError(p.paneBySerial(pane.serial) orelse return, "tag", err);
+ const empty = p.gpa.alloc(u8, 0) catch unreachable; // no byte: the allocator is not asked
if (pane.tag.own) |own| p.gpa.free(own);
pane.tag.own = empty;
// what is left is the prefix; the cursor goes after it
@@ -800,7 +801,7 @@ fn writeFlag(p: *Pardes, req: Req, pane: *Pane, file: PaneFile) Reply {
// step starts here: the text as it is now is what Undo brings back,
// and turning mark on again only ends it.
.mark => {
- if (!on and !pf.nomark) panes.File.pushUndo(p, pane);
+ if (!on and !pf.nomark) panes.File.pushUndo(p, pane) catch return Reply.fail(req.tag, E.NOMEM);
pf.nomark = !on;
},
.scroll => pf.noscroll = !on,
diff --git a/src/normal.zig b/src/normal.zig
index 446f0e3e..fc6da633 100644
--- a/src/normal.zig
+++ b/src/normal.zig
@@ -601,7 +601,7 @@ pub fn searchSelection(p: *Pardes, t: *Text, text: []const u8, boundary: bool) e
if (boundary and to < text.len and modal.searchWordBefore(text, to) and !modal.searchWordAt(text, to)) try pattern.appendSlice(arena, "\\b");
}
const name = if (p.view().register != 0) p.view().register else '/';
- p.registers.put(p.gpa, name, pattern.items, 0, 1, true);
+ try p.registers.put(p.gpa, name, pattern.items, 0, 1, true);
p.registers.last_search = name;
}
@@ -882,7 +882,7 @@ fn executeNormalAction(p: *Pardes, t: *Text, a: modal.Normal.Action) edit.Error!
m.recorded.shrinkRetainingCapacity(m.recorded.items.len -| (m.command.items.len + 1));
const keys = try Macro.encode(p.gpa, m.recorded.items);
defer p.gpa.free(keys);
- p.registers.put(p.gpa, m.recording, keys, 0, 1, true);
+ try p.registers.put(p.gpa, m.recording, keys, 0, 1, true);
m.recording = 0;
},
.macro_replay => {
diff --git a/src/rollback.zig b/src/rollback.zig
index e08e6242..ccd056fd 100644
--- a/src/rollback.zig
+++ b/src/rollback.zig
@@ -718,7 +718,7 @@ test "a register's texts are pinned, not copied, and come back whole" {
defer std.testing.allocator.free(grid);
@memset(grid, 'y');
const reg = pardes.Registers.default;
- p.registers.put(gpa, reg, grid, 0, 1, true);
+ try p.registers.put(gpa, reg, grid, 0, 1, true);
_ = p.registers.text(gpa, reg) orelse return error.NoText;
var c: Copy = .{};
defer c.deinit();
@@ -726,7 +726,7 @@ test "a register's texts are pinned, not copied, and come back whole" {
try std.testing.expect(c.savedBytes() < 1 << 20);
try std.testing.expect(c.pinnedBytes() >= 4 << 20);
// A speculation yanks over it, and is undone.
- p.registers.put(gpa, reg, "a word", 0, 1, true);
+ try p.registers.put(gpa, reg, "a word", 0, 1, true);
try std.testing.expect(c.restore());
const back = p.registers.value(reg, 0) orelse return error.Lost;
try std.testing.expectEqual(grid.len, back.len);
diff --git a/src/terminal.zig b/src/terminal.zig
index b4f0d353..68b3adde 100644
--- a/src/terminal.zig
+++ b/src/terminal.zig
@@ -2435,13 +2435,13 @@ pub fn padOutputBelowEdits(p: *Pardes, id: usize) void {
while (i < pad) : (i += 1) p.emitWrite(id, "\r");
}
-pub fn pushUndo(p: *Pardes, pane: *Pane) void {
- pane.body.remember(p.gpa, pane.ovl);
+pub fn pushUndo(p: *Pardes, pane: *Pane) error{OutOfMemory}!void {
+ return pane.body.remember(p.gpa, pane.ovl);
}
/// Undo (back) or redo one step of the edit overlay.
-pub fn undoStep(p: *Pardes, pane: *Pane, back: bool) void {
- const to = pane.body.step(p.gpa, pane.ovl, back) orelse return;
+pub fn undoStep(p: *Pardes, pane: *Pane, back: bool) error{OutOfMemory}!void {
+ const to = (try pane.body.step(p.gpa, pane.ovl, back)) orelse return;
if (pane.ovl) |o| p.gpa.free(o.text);
pane.ovl = to.ovl;
pane.ensureCursorVisible();