summaryrefslogtreecommitdiff
path: root/src/sam_edit.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-10-30 17:35:06 -0300
committerGabriel Schneider <[email protected]>2026-10-30 17:35:06 -0300
commit6d8da8721141284cf33bb901168b26135893eb86 (patch)
tree791d63401d4e85fbca1d597a8ce0326e70efd545 /src/sam_edit.zig
parentefd43a3a2cf03bb741366331158b368abf9ac583 (diff)
parentbf6810a8f9d6cc82050e7d9c0cfb06358301b574 (diff)
downloadpardes-6d8da8721141284cf33bb901168b26135893eb86.tar.gz
pardes-6d8da8721141284cf33bb901168b26135893eb86.zip
Merge latest upstream into the macOS branch for Zig 0.17
Retain the macOS branch history and local Acme selection color while adopting upstream's current core and platform changes. Pin Zig and ZLS to 0.17.0, and fetch the existing zstbi compatibility commit through upstream after its original fork was removed.
Diffstat (limited to 'src/sam_edit.zig')
-rw-r--r--src/sam_edit.zig1402
1 files changed, 1402 insertions, 0 deletions
diff --git a/src/sam_edit.zig b/src/sam_edit.zig
new file mode 100644
index 00000000..73cd6ecd
--- /dev/null
+++ b/src/sam_edit.zig
@@ -0,0 +1,1402 @@
+//! acme's Edit (editors/acme/edit.c, ecmd.c, elog.c): sam's command
+//! language over the open text panes. The commands are parsed as edit.c
+//! parses them, run as ecmd.c runs them against the text as it was before
+//! the Edit, and their changes collected in order, a log a file, as elog.c
+//! logs them, then applied at once: an Edit is one undo step in each file it
+//! changes, and one that fails changes nothing.
+//!
+//! Addresses are the `addr` file's (src/ninep/addr.zig), so they take
+//! pardes's `line:col` too; regular expressions are src/regexp.zig's, mvzr
+//! searched as sam searches, with its step budget.
+//!
+//! What touches more than the text is the caller's (src/EditCmd.zig): `<`,
+//! `|` and `>` are collected as jobs, a command to run per address, whose
+//! output fills the change they hold the place of; `w` as the bytes to
+//! write; `D`, `e`'s load and the name `f` sets, as marks on the file; `B`
+//! and the reads of `e` and `r` through `World`, at once, as acme does them.
+//!
+//! Left out: the `'` address, `B <cmd` and `D <cmd` (a file list from a
+//! command), and `\1`..`\9` in `s` and sam's longest of alternatives (mvzr
+//! keeps no submatches and takes the first alternative that matches). `u`
+//! undoes or redoes only as a whole Edit. acme warns about changes out of
+//! sequence (elog.c:130) and applies them anyway; here the Edit is refused.
+//! A command that fails (`|`, `<`, `>`) refuses the whole Edit, where sam
+//! warns and puts in what it wrote; `D` of a file the Edit changed is
+//! refused rather than drop the changes; `e` loads its file once the Edit
+//! is done, by Get's way (ninep/ctl.zig getFile), so the file takes no
+//! other command in the same Edit.
+const std = @import("std");
+const regexp = @import("regexp.zig");
+const addr_lang = @import("ninep/addr.zig");
+const modal = @import("modal.zig");
+
+/// The next place after `p` a search may start: a rune on, and past the
+/// text's end once there, which ends a loop over `p <= end`.
+fn stepRune(text: []const u8, p: usize) usize {
+ return if (p >= text.len) p + 1 else modal.nextRune(text, p);
+}
+
+pub const Range = addr_lang.Range;
+
+/// A change to the text as it was: `job`, when set, is a `<` or `|` whose
+/// command's output is the text, known once it has run.
+pub const Op = struct { q0: u32, q1: u32, text: []const u8, job: ?u32 = null };
+
+/// One open text pane, as an Edit sees and leaves it.
+pub const File = struct {
+ /// Its absolute path; after `e` or `f`, the name they gave it.
+ name: []const u8,
+ text: []const u8,
+ dot: Range = .{},
+ /// Edited since it was saved: the `'` of acme's file line.
+ dirty: bool = false,
+ /// No file of its own (a +Errors, a +New): `e`, `r` and `w` want a name.
+ scratch: bool = false,
+ /// The caller's: which pane it is.
+ id: usize = 0,
+ ops: std.ArrayList(Op) = .empty,
+ /// `e` or `f` named it `name`.
+ renamed: bool = false,
+ /// `D` closes it once the Edit is done.
+ close: bool = false,
+ /// `e` loads this file into it once the Edit is done (the editor's Get
+ /// path, which renames the pane and leaves it clean); the file takes no
+ /// more commands in the Edit.
+ get: ?[]const u8 = null,
+ /// A command left a dot in it.
+ moved: bool = false,
+};
+
+/// A command for `<`, `|` or `>` (`c`), run in `file`'s directory, its
+/// stdin `file`'s text in `q0..q1` (none for `<`). `>`'s output is printed
+/// at `at` in `Result.printed`.
+pub const Job = struct { c: u8, command: []const u8, file: u32, q0: u32, q1: u32, at: usize };
+
+/// `w`: `bytes` to `path`, `whole` when they are all of `file`'s text.
+pub const Write = struct { file: u32, path: []const u8, bytes: []const u8, whole: bool };
+
+/// What the editor does for `B`, `e` and `r` while an Edit runs.
+pub const World = struct {
+ ctx: *anyopaque,
+ /// Whether `B` could open the absolute `path`: false, and `why` set,
+ /// when it could not, before any is opened.
+ check: *const fn (ctx: *anyopaque, path: []const u8, why: *Why) bool,
+ /// The text pane holding the absolute `path`, opened if it is not open:
+ /// `B`. Null, and `why` set, when it cannot be.
+ open: *const fn (ctx: *anyopaque, path: []const u8, why: *Why) ?File,
+ /// The bytes of the absolute `path`, in `arena`: `e` and `r`.
+ read: *const fn (ctx: *anyopaque, arena: std.mem.Allocator, path: []const u8, why: *Why) ?[]const u8,
+ /// `e` over unsaved edits in the pane `id`: asked once, as Get asks;
+ /// true, and `why` set, when it is refused this time.
+ refuseGet: *const fn (ctx: *anyopaque, id: usize, why: *Why) bool,
+};
+
+/// What an Edit came to: every file (those `B` opened after the ones it
+/// was given), each with its changes in order and the dot it leaves (in the
+/// text before them); the jobs and writes; and what `p`, `=`, `b`, `f` and
+/// `X` printed.
+pub const Result = struct {
+ files: []File,
+ /// The current file at the end (`b` moves it).
+ cur: usize,
+ jobs: []const Job = &.{},
+ writes: []const Write = &.{},
+ printed: []const u8 = "",
+ /// A bare `u`/`u-3`: undo (positive) or redo (negative) that many.
+ undo: i32 = 0,
+};
+
+pub const Failure = error{ Edit, OutOfMemory };
+
+/// Why an Edit failed, in acme's words, when `run` answered error.Edit.
+pub const Why = struct {
+ buf: [200]u8 = undefined,
+ len: usize = 0,
+ pub fn text(w: *const Why) []const u8 {
+ return w.buf[0..w.len];
+ }
+};
+
+/// The most commands an Edit's `<`, `|` and `>` may run: each is a process.
+pub const max_jobs = 1024;
+
+const Cmd = struct {
+ c: u8,
+ addr: ?[]const u8 = null,
+ /// A `"re"` address: the file whose line matches.
+ file_re: ?[]const u8 = null,
+ /// A `,` after it, whose right side acme evaluates in the current file
+ /// (ecmd.c cmdaddress): only `;` carries the file over.
+ file_comma: bool = false,
+ re: ?[]const u8 = null,
+ text: []const u8 = "",
+ sub: ?*Cmd = null,
+ next: ?*Cmd = null,
+ num: i32 = 0,
+ global: bool = false,
+ to: ?[]const u8 = null,
+};
+
+/// Runs `command` over `files` from `files[cur]`, whose dots are where
+/// each starts. `world` answers `B`, `e` and `r`; with none they fail.
+/// Everything returned lives in `arena`.
+pub fn run(arena: std.mem.Allocator, files: []const File, cur: usize, command: []const u8, world: ?World, why: *Why) Failure!Result {
+ var src = try arena.alloc(u8, command.len + 1);
+ @memcpy(src[0..command.len], command);
+ src[command.len] = '\n';
+ if (command.len > 0 and command[command.len - 1] == '\n') src = src[0..command.len];
+ var ps: Parser = .{ .arena = arena, .src = src, .why = why };
+ var first: ?*Cmd = null;
+ var last: ?*Cmd = null;
+ while (try ps.parse(0)) |c| {
+ if (last) |l| l.next = c else first = c;
+ last = c;
+ }
+ // An a, c or i text that never met its `.` line is refused, as an
+ // unclosed `{` is: sam takes the end of input for one, but a block that
+ // reaches Edit unfinished was cut short (a write, an open closed), and
+ // half of it inserted is worse than none.
+ if (ps.open_text) return fail(why, "a, c or i text not ended by a . line", .{});
+ var ex: Exec = .{ .arena = arena, .why = why, .world = world, .cur = cur };
+ try ex.files.appendSlice(arena, files);
+ const cmds = first orelse return .{ .files = ex.files.items, .cur = cur };
+ // acme's u runs at once (ecmd.c:532), outside the edit log; here it is
+ // an Edit of its own.
+ if (cmds.c == 'u') {
+ if (cmds.next != null) return fail(why, "u is only an Edit of its own here", .{});
+ return .{ .files = ex.files.items, .cur = cur, .undo = cmds.num };
+ }
+ // editthread: each command from the current file, which `b` changes.
+ var it: ?*Cmd = cmds;
+ while (it) |c| : (it = c.next) {
+ const fi = ex.cur;
+ const d = try ex.exec(c, fi, ex.files.items[fi].dot);
+ ex.files.items[fi].dot = d;
+ ex.files.items[fi].moved = true;
+ }
+ return .{
+ .files = ex.files.items,
+ .cur = ex.cur,
+ .jobs = ex.jobs.items,
+ .writes = ex.writes.items,
+ .printed = ex.out.items,
+ };
+}
+
+/// What an Edit command still waits for: nothing, the `.` line that ends
+/// an a, c or i text block, or the `}` of a group.
+pub const Wait = enum { none, text, group };
+
+/// Whether `command` stops inside a `{` group or an `a`, `c` or `i` text
+/// block still waiting for its `.` line, and which: a writer of lines (a
+/// ctl, exec) hands an Edit the lines after it until it does not. While a
+/// text block is open only a `.` line can end it, so a caller need not
+/// parse the block again for every line of text in it (ninep/ctl.zig,
+/// editEnd), which was quadratic.
+pub fn waitsFor(arena: std.mem.Allocator, command: []const u8) Wait {
+ var why: Why = .{};
+ const src = std.fmt.allocPrint(arena, "{s}\n", .{command}) catch return .none;
+ defer arena.free(src);
+ var ps: Parser = .{ .arena = arena, .src = src, .why = &why };
+ while (true) {
+ const c = ps.parse(0) catch
+ return if (ps.open_text) .text else if (std.mem.eql(u8, why.text(), "unmatched `{'") or groupOpen(command)) .group else .none;
+ if (c == null) return if (ps.open_text) .text else .none;
+ }
+}
+
+/// A `{` block not closed yet by its `}` line: a command in it that fails
+/// to parse still leaves the block to end at its `}`, so the error is that
+/// command's, not the `}`'s taken as a line of its own.
+fn groupOpen(command: []const u8) bool {
+ var depth: usize = 0;
+ var lines = std.mem.splitScalar(u8, command, '\n');
+ while (lines.next()) |raw| {
+ const line = std.mem.trim(u8, raw, " \t\r");
+ if (std.mem.eql(u8, line, "}")) {
+ depth -|= 1;
+ } else if (std.mem.endsWith(u8, line, "{")) depth += 1;
+ }
+ return depth > 0;
+}
+
+/// Whether `command` holds a `<`, `|` or `>`: its write is answered only
+/// when they have run (ninep/ctl.zig refuses other lines beside it).
+pub fn runsCommands(arena: std.mem.Allocator, command: []const u8) bool {
+ var why: Why = .{};
+ const src = std.fmt.allocPrint(arena, "{s}\n", .{command}) catch return false;
+ var ps: Parser = .{ .arena = arena, .src = src, .why = &why };
+ const Walk = struct {
+ fn any(c: ?*Cmd) bool {
+ var it = c;
+ while (it) |each| : (it = each.next) {
+ if (std.mem.indexOfScalar(u8, "<|>", each.c) != null) return true;
+ if (any(each.sub)) return true;
+ }
+ return false;
+ }
+ };
+ while (true) {
+ const c = (ps.parse(0) catch return false) orelse return false;
+ if (Walk.any(c)) return true;
+ }
+}
+
+fn fail(why: *Why, comptime fmt: []const u8, args: anytype) Failure {
+ why.len = if (std.fmt.bufPrint(&why.buf, fmt, args)) |s| s.len else |_| 0;
+ return error.Edit;
+}
+
+// ---- 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,
+ i: usize = 0,
+ /// The last pattern given, for an empty one (edit.c:562, getregexp).
+ lastpat: []const u8 = "",
+ /// The last `parse` that answered null met a `}`, not the end.
+ braced: bool = false,
+ /// A text block of `a`, `c` or `i` ran out before its `.` line.
+ 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 {
+ if (ps.i >= ps.src.len) return null;
+ ps.i += 1;
+ return ps.src[ps.i - 1];
+ }
+
+ fn nextc(ps: *const Parser) ?u8 {
+ return if (ps.i < ps.src.len) ps.src[ps.i] else null;
+ }
+
+ fn skipbl(ps: *Parser) ?u8 {
+ while (ps.nextc()) |c| {
+ if (c != ' ' and c != '\t') return c;
+ ps.i += 1;
+ }
+ return null;
+ }
+
+ fn atnl(ps: *Parser) Failure!void {
+ _ = ps.skipbl();
+ const c = ps.getch() orelse '\n';
+ if (c != '\n') return fail(ps.why, "newline expected (saw {c})", .{c});
+ }
+
+ fn okdelim(ps: *Parser, c: u8) Failure!void {
+ if (c == '\\' or std.ascii.isAlphanumeric(c)) return fail(ps.why, "bad delimiter {c}", .{c});
+ }
+
+ /// edit.c:216: a count, 1 when there is none; `-` allowed when signok > 1.
+ fn getnum(ps: *Parser, signok: u8) i32 {
+ var sign: i32 = 1;
+ if (signok > 1 and ps.nextc() == '-') {
+ sign = -1;
+ ps.i += 1;
+ }
+ const c = ps.nextc() orelse return sign;
+ if (c < '0' or c > '9') return sign;
+ var n: i32 = 0;
+ while (ps.nextc()) |d| {
+ if (d < '0' or d > '9') break;
+ n = n *| 10 +| (d - '0');
+ ps.i += 1;
+ }
+ return sign * n;
+ }
+
+ /// An address's text, blanks dropped, or null: the syntax of edit.c's
+ /// compoundaddr and simpleaddr, evaluated later by addr.zig. A `"re"`
+ /// first is the file the rest addresses, kept in `file_re`.
+ fn address(ps: *Parser, file_re: ?*?[]const u8) Failure!?[]const u8 {
+ var out: std.ArrayList(u8) = .empty;
+ while (true) {
+ const c = ps.skipbl() orelse break;
+ switch (c) {
+ '0'...'9', '#', '.', '$', '+', '-', ',', ';' => {
+ ps.i += 1;
+ try out.append(ps.arena, c);
+ if (c == ',' and file_re != null and file_re.?.* != null) ps.file_comma = true;
+ // pardes's line:col
+ if (c >= '0' and c <= '9' and ps.nextc() == ':' and ps.i + 1 < ps.src.len and
+ ps.src[ps.i + 1] >= '0' and ps.src[ps.i + 1] <= '9')
+ {
+ ps.i += 1;
+ try out.append(ps.arena, ':');
+ }
+ },
+ '/', '?' => {
+ ps.i += 1;
+ try out.append(ps.arena, c);
+ while (ps.nextc()) |d| {
+ if (d == '\n') break;
+ ps.i += 1;
+ try out.append(ps.arena, d);
+ if (d == '\\') {
+ if (ps.nextc()) |e| if (e != '\n') {
+ ps.i += 1;
+ try out.append(ps.arena, e);
+ };
+ continue;
+ }
+ if (d == c) break;
+ }
+ },
+ '\'' => return fail(ps.why, "can't handle '", .{}),
+ '"' => {
+ // Only first, as the file the rest of it addresses.
+ const into = file_re orelse return fail(ps.why, "bad address", .{});
+ if (out.items.len > 0 or into.* != null) return fail(ps.why, "bad address", .{});
+ ps.i += 1;
+ into.* = try ps.getregexp('"');
+ },
+ else => break,
+ }
+ }
+ return if (out.items.len == 0) null else out.items;
+ }
+
+ /// edit.c:562: up to the delimiter; `\delim` is the delimiter, `\\` stays.
+ fn getregexp(ps: *Parser, delim: u8) Failure![]const u8 {
+ var buf: std.ArrayList(u8) = .empty;
+ while (true) {
+ var c = ps.getch() orelse break;
+ if (c == '\\') {
+ if (ps.nextc() == delim) {
+ c = ps.getch().?;
+ } else if (ps.nextc() == '\\') {
+ try buf.append(ps.arena, c);
+ c = ps.getch().?;
+ }
+ } else if (c == delim or c == '\n') {
+ if (c == '\n') ps.i -= 1;
+ break;
+ }
+ try buf.append(ps.arena, c);
+ }
+ if (buf.items.len > 0) ps.lastpat = buf.items;
+ if (ps.lastpat.len == 0) return fail(ps.why, "no regular expression defined", .{});
+ return ps.lastpat;
+ }
+
+ /// edit.c:388: `\n` is a newline; for `s` every other escape is kept
+ /// for it to read (`\&`, `\\`).
+ fn getrhs(ps: *Parser, delim: u8, cmd: u8) Failure![]const u8 {
+ var s: std.ArrayList(u8) = .empty;
+ while (ps.getch()) |c0| {
+ var c = c0;
+ if (c == delim or c == '\n') {
+ ps.i -= 1;
+ break;
+ }
+ if (c == '\\') {
+ c = ps.getch() orelse return fail(ps.why, "bad right hand side", .{});
+ if (c == '\n') {
+ ps.i -= 1;
+ c = '\\';
+ } else if (c == 'n') {
+ c = '\n';
+ } else if (c != delim and (cmd == 's' or c != '\\')) {
+ try s.append(ps.arena, '\\');
+ }
+ }
+ try s.append(ps.arena, c);
+ }
+ return s.items;
+ }
+
+ /// edit.c:425: `/text/` on the line, or lines up to one that is `.`.
+ fn collecttext(ps: *Parser) Failure![]const u8 {
+ if (ps.skipbl() == '\n') {
+ ps.i += 1;
+ var s: std.ArrayList(u8) = .empty;
+ while (ps.i < ps.src.len) {
+ const end = std.mem.indexOfScalarPos(u8, ps.src, ps.i, '\n') orelse ps.src.len;
+ const line = ps.src[ps.i..end];
+ ps.i = @min(end + 1, ps.src.len);
+ if (std.mem.eql(u8, line, ".")) return s.items;
+ try s.appendSlice(ps.arena, line);
+ try s.append(ps.arena, '\n');
+ }
+ ps.open_text = true;
+ return s.items;
+ }
+ const delim = ps.getch() orelse return "";
+ try ps.okdelim(delim);
+ const s = try ps.getrhs(delim, 'a');
+ if (ps.nextc() == delim) ps.i += 1;
+ try ps.atnl();
+ return s;
+ }
+
+ /// edit.c:404, collecttoken: up to a byte of `end`, blanks before it
+ /// kept (the command trims them); a word wants its newline after it.
+ fn collecttoken(ps: *Parser, end: []const u8) Failure![]const u8 {
+ const start = ps.i;
+ while (ps.nextc()) |c| : (ps.i += 1) {
+ if (c != ' ' and c != '\t') break;
+ }
+ while (ps.nextc()) |c| : (ps.i += 1) {
+ if (std.mem.indexOfScalar(u8, end, c) != null) break;
+ }
+ const s = ps.src[start..ps.i];
+ if (ps.nextc() == '\n') ps.i += 1 else try ps.atnl();
+ return s;
+ }
+
+ /// 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);
+ _ = ps.skipbl() orelse return null;
+ const c = ps.getch() orelse return null;
+ const cmd = try ps.arena.create(Cmd);
+ cmd.* = .{ .c = c, .addr = a, .file_re = file_re, .file_comma = ps.file_comma };
+ // aNo in edit.c's cmdtab.
+ if ((a != null or file_re != null) and std.mem.indexOfScalar(u8, "bBDefuXY", c) != null)
+ return fail(ps.why, "command takes no address", .{});
+ switch (c) {
+ '\n' => {},
+ 'a', 'c', 'i' => cmd.text = try ps.collecttext(),
+ 'd', 'p' => try ps.atnl(),
+ '=' => {
+ _ = ps.skipbl();
+ const start = ps.i;
+ while (ps.nextc()) |d| : (ps.i += 1) if (d == '\n') break;
+ cmd.text = std.mem.trimEnd(u8, ps.src[start..ps.i], " \t");
+ ps.i = @min(ps.i + 1, ps.src.len);
+ if (cmd.text.len != 0 and !std.mem.eql(u8, cmd.text, "#")) return fail(ps.why, "newline expected", .{});
+ },
+ 's' => {
+ cmd.num = ps.getnum(1);
+ _ = ps.skipbl();
+ const delim = ps.getch() orelse '\n';
+ if (delim == '\n') return fail(ps.why, "no address", .{});
+ try ps.okdelim(delim);
+ cmd.re = try ps.getregexp(delim);
+ cmd.text = try ps.getrhs(delim, 's');
+ if (ps.nextc() == delim) {
+ ps.i += 1;
+ if (ps.nextc() == 'g') {
+ ps.i += 1;
+ cmd.global = true;
+ } else if (ps.nextc()) |d| if (d >= '1' and d <= '9') {
+ // `s/a/b/2`, the count after, as some write it for
+ // sam's `s2/a/b/`.
+ cmd.num = ps.getnum(1);
+ };
+ }
+ try ps.atnl();
+ },
+ 'x', 'y', 'g', 'v', 'X', 'Y' => {
+ // x without a pattern is every line (ecmd.c:568,
+ // linelooper), X every file.
+ const n = ps.nextc();
+ if ((c != 'x' and c != 'X') or (n != ' ' and n != '\t' and n != '\n')) {
+ _ = ps.skipbl();
+ const delim = ps.getch() orelse '\n';
+ if (delim == '\n') return fail(ps.why, "no address", .{});
+ try ps.okdelim(delim);
+ cmd.re = try ps.getregexp(delim);
+ }
+ if (ps.skipbl() == '\n') {
+ ps.i += 1;
+ const p = try ps.arena.create(Cmd);
+ p.* = .{ .c = if (c == 'X' or c == 'Y') 'f' else 'p' };
+ cmd.sub = p;
+ } else {
+ cmd.sub = (try ps.parse(nest)) orelse return fail(ps.why, "defcmd", .{});
+ }
+ },
+ 'm', 't' => {
+ cmd.to = (try ps.address(null)) orelse return fail(ps.why, "bad address", .{});
+ try ps.atnl();
+ },
+ 'u' => {
+ cmd.num = ps.getnum(2);
+ try ps.atnl();
+ },
+ // edit.c's cmdtab: a line for these, a word for those.
+ 'b', 'B', 'D', '<', '|', '>' => cmd.text = try ps.collecttoken("\n"),
+ 'e', 'f', 'r', 'w' => cmd.text = try ps.collecttoken(" \t\n"),
+ '{' => {
+ var last: ?*Cmd = null;
+ while (true) {
+ if (ps.skipbl() == '\n') ps.i += 1;
+ ps.braced = false;
+ const next = (try ps.parse(nest + 1)) orelse {
+ // sam reads on for the `}`; an Edit has no more to read.
+ if (!ps.braced) return fail(ps.why, "unmatched `{{'", .{});
+ break;
+ };
+ if (last) |l| l.next = next else cmd.sub = next;
+ last = next;
+ }
+ },
+ '}' => {
+ ps.braced = true;
+ try ps.atnl();
+ if (nest == 0) return fail(ps.why, "right brace with no left brace", .{});
+ return null;
+ },
+ else => return fail(ps.why, "unknown command {c}", .{c}),
+ }
+ return cmd;
+ }
+};
+
+// ---- running: ecmd.c, logging: elog.c ----
+
+const e_noname = "no file name given";
+
+const Exec = struct {
+ arena: std.mem.Allocator,
+ why: *Why,
+ world: ?World,
+ files: std.ArrayList(File) = .empty,
+ /// The current file: where the next top-level command runs.
+ cur: usize,
+ jobs: std.ArrayList(Job) = .empty,
+ writes: std.ArrayList(Write) = .empty,
+ out: std.ArrayList(u8) = .empty,
+ nest: u32 = 0,
+ /// Inside an X or Y, which do not nest (ecmd.c Glooping).
+ looping: bool = false,
+
+ fn clip(n: usize) u32 {
+ return std.math.cast(u32, n) orelse std.math.maxInt(u32);
+ }
+
+ fn text(ex: *const Exec, fi: usize) []const u8 {
+ return ex.files.items[fi].text;
+ }
+
+ /// An address in file `fi` from `dot`, or `dot` when there is none
+ /// (aDot).
+ fn address(ex: *Exec, fi: usize, expr: ?[]const u8, dot: Range) Failure!Range {
+ const e = expr orelse return dot;
+ var a: addr_lang.Addr = .{ .text = ex.text(fi), .lim = null, .expr = e };
+ // A miss names the pattern that missed, not the whole Edit line.
+ const r = a.address(dot) orelse return if (std.mem.eql(u8, a.err, addr_lang.e_no_match))
+ fail(ex.why, "no match for regexp {s}", .{e})
+ else
+ fail(ex.why, "{s}", .{a.err});
+ if (a.i < e.len) return fail(ex.why, "bad address syntax", .{});
+ if (r.q0 > r.q1) return fail(ex.why, "addresses out of order", .{});
+ return r;
+ }
+
+ /// elog.c's order: each change at or after the end of the one before,
+ /// since they all address the text as it was.
+ fn log(ex: *Exec, fi: usize, q0: u32, q1: u32, bytes: []const u8, job: ?u32) Failure!void {
+ if (q0 == q1 and bytes.len == 0 and job == null) return;
+ const ops = &ex.files.items[fi].ops;
+ if (ops.items.len > 0) {
+ const prev = ops.items[ops.items.len - 1];
+ if (q0 < prev.q1 or q0 < prev.q0) return fail(ex.why, "changes out of sequence", .{});
+ }
+ try ops.append(ex.arena, .{ .q0 = q0, .q1 = q1, .text = bytes, .job = job });
+ }
+
+ fn compile(ex: *Exec, pat: []const u8, c: u8) Failure!regexp.Regex {
+ return regexp.Regex.compile(pat) catch |err| switch (err) {
+ error.Anchor => fail(ex.why, "{s}", .{regexp.Regex.e_anchor}),
+ error.TooLong => fail(ex.why, "{s}", .{regexp.Regex.e_long}),
+ error.WideRange => fail(ex.why, "{s}", .{regexp.Regex.e_wide}),
+ error.NegatedRunes => fail(ex.why, "{s}", .{regexp.Regex.e_negated}),
+ error.Mixed => fail(ex.why, "{s}", .{regexp.Regex.e_mixed}),
+ error.Bad => if (c == '"' or c == 'X' or c == 'Y')
+ fail(ex.why, "bad regexp in file match", .{})
+ else
+ fail(ex.why, "bad regexp in {c} command", .{c}),
+ };
+ }
+
+ /// A match covers the runes it touches, as an address's does
+ /// (addr.zig): mvzr matches bytes, so `.` would take one byte of `é`
+ /// and x, y and s would split it. From `from` on only, so a match never
+ /// reaches back into what the last one took.
+ fn find(ex: *Exec, rx: *regexp.Regex, in: []const u8, from: usize, hi: usize) Failure!?regexp.Regex.Match {
+ if (from > hi) return null;
+ // The budget is each search's own: an x over 100k lines makes 100k
+ // searches, none of which is the slow one.
+ rx.steps = regexp.Regex.budget;
+ const m = (rx.find(in, from, hi, hi) catch return fail(ex.why, "{s}", .{addr_lang.e_slow})) orelse return null;
+ var start = modal.runeStart(in, m.start);
+ if (start < from) start = modal.runeEnd(in, m.start);
+ return .{ .start = start, .end = @max(start, modal.runeEnd(in, m.end)) };
+ }
+
+ /// ecmd.c pfilename: `'` if edited, `+`, `.` if current, and the name.
+ fn fileLine(ex: *Exec, fi: usize) Failure![]const u8 {
+ const f = &ex.files.items[fi];
+ return std.fmt.allocPrint(ex.arena, "{c}+{c} {s}\n", .{
+ @as(u8, if (f.dirty and !f.scratch) '\'' else ' '),
+ @as(u8, if (fi == ex.cur) '.' else ' '),
+ f.name,
+ });
+ }
+
+ /// ecmd.c filematch: the file's line matches `pat`.
+ fn fileMatch(ex: *Exec, fi: usize, pat: []const u8) Failure!bool {
+ var rx = try ex.compile(pat, 'X');
+ const line = try ex.fileLine(fi);
+ return (try ex.find(&rx, line, 0, line.len)) != null;
+ }
+
+ /// ecmd.c matchfile: the one open file whose line matches `pat`.
+ fn matchFile(ex: *Exec, pat: []const u8) Failure!usize {
+ var found: ?usize = null;
+ for (ex.files.items, 0..) |f, i| {
+ if (f.close or f.scratch) continue;
+ if (!try ex.fileMatch(i, pat)) continue;
+ if (found != null) return fail(ex.why, "too many files match \"{s}\"", .{pat});
+ found = i;
+ }
+ return found orelse fail(ex.why, "no file matches \"{s}\"", .{pat});
+ }
+
+ /// `name` as a path: itself when absolute, else in `fi`'s directory
+ /// (acme's dirname).
+ fn pathIn(ex: *Exec, fi: usize, name_in: []const u8) Failure![]const u8 {
+ // `~` and `~user` as Get, Incl and Save read them.
+ var home: [4096]u8 = undefined;
+ const name = try ex.arena.dupe(u8, @import("fs.zig").expandHome(name_in, &home));
+ if (name.len > 0 and name[0] == '/') return name;
+ const dir = std.fs.path.dirnamePosix(ex.files.items[fi].name) orelse "/";
+ return std.fs.path.resolvePosix(ex.arena, &.{ dir, name });
+ }
+
+ /// The open file named `path`, a scratch too.
+ fn lookFile(ex: *Exec, path: []const u8) ?usize {
+ for (ex.files.items, 0..) |f, i| if (!f.close and std.mem.eql(u8, f.name, path)) return i;
+ return null;
+ }
+
+ /// ecmd.c cmdname: the name a file command means: the one given, in the
+ /// file's directory, else the file's own (none for a scratch). `set`
+ /// names the file so (`e`, `f`), as an unnamed one always is.
+ fn cmdName(ex: *Exec, fi: usize, given: []const u8, set: bool) Failure!?[]const u8 {
+ const s = std.mem.trim(u8, given, " \t");
+ const f = &ex.files.items[fi];
+ if (s.len == 0) return if (f.scratch) null else f.name;
+ const full = try ex.pathIn(fi, s);
+ if (set and !std.mem.eql(u8, full, f.name)) {
+ if (ex.lookFile(full)) |other| if (other != fi)
+ try ex.out.print(ex.arena, "warning: duplicate file name \"{s}\"\n", .{full});
+ f.name = full;
+ f.renamed = true;
+ f.scratch = false;
+ }
+ return full;
+ }
+
+ fn readFile(ex: *Exec, path: []const u8) Failure![]const u8 {
+ const w = ex.world orelse return fail(ex.why, "can't open {s}: no files here", .{path});
+ return w.read(w.ctx, ex.arena, path, ex.why) orelse error.Edit;
+ }
+
+ /// ecmd.c:62, cmdexec: runs `c` in file `fi` from `dot`, answering the
+ /// dot it leaves there.
+ fn exec(ex: *Exec, c: *Cmd, fi_in: usize, dot_in: Range) Failure!Range {
+ var fi = fi_in;
+ var dot = dot_in;
+ if (ex.files.items[fi].close) return fail(ex.why, "no current window", .{});
+ if (ex.files.items[fi].get) |path| return fail(ex.why, "{s} is read in by e at the Edit's end: no more commands in it", .{path});
+ // A `"re"` address: the command runs in that file, from its dot.
+ if (c.file_re) |pat| {
+ fi = try ex.matchFile(pat);
+ dot = ex.files.items[fi].dot;
+ if (c.file_comma and fi != fi_in) return fail(ex.why, "addresses in different files", .{});
+ }
+ // w's default address is the whole file (aAll).
+ const r = if (c.c == 'w' and c.addr == null)
+ Range{ .q0 = 0, .q1 = clip(ex.text(fi).len) }
+ else
+ try ex.address(fi, c.addr, dot);
+ const d = try ex.execIn(c, fi, r);
+ if (fi == fi_in) return d;
+ ex.files.items[fi].dot = d;
+ ex.files.items[fi].moved = true;
+ return dot_in;
+ }
+
+ /// The command itself, at `r` in file `fi`.
+ fn execIn(ex: *Exec, c: *Cmd, fi: usize, r: Range) Failure!Range {
+ const txt = ex.text(fi);
+ switch (c.c) {
+ '\n' => return r,
+ 'a' => {
+ try ex.log(fi, r.q1, r.q1, c.text, null);
+ return .{ .q0 = r.q1, .q1 = r.q1 };
+ },
+ 'i' => {
+ try ex.log(fi, r.q0, r.q0, c.text, null);
+ return .{ .q0 = r.q0, .q1 = r.q0 };
+ },
+ 'c' => {
+ try ex.log(fi, r.q0, r.q1, c.text, null);
+ return .{ .q0 = r.q0, .q1 = r.q0 };
+ },
+ 'd' => {
+ try ex.log(fi, r.q0, r.q1, "", null);
+ return .{ .q0 = r.q0, .q1 = r.q0 };
+ },
+ 'p' => {
+ try ex.out.appendSlice(ex.arena, txt[r.q0..r.q1]);
+ return r;
+ },
+ '=' => {
+ // ecmd.c:665, printposn
+ const name = ex.files.items[fi].name;
+ if (c.text.len > 0) {
+ try ex.out.print(ex.arena, "{s}:#{d}", .{ name, r.q0 });
+ if (r.q1 != r.q0) try ex.out.print(ex.arena, ",#{d}", .{r.q1});
+ } else {
+ const l1 = 1 + std.mem.count(u8, txt[0..r.q0], "\n");
+ var l2 = l1 + std.mem.count(u8, txt[r.q0..r.q1], "\n");
+ if (r.q1 > r.q0 and txt[r.q1 - 1] == '\n') l2 -= 1;
+ try ex.out.print(ex.arena, "{s}:{d}", .{ name, l1 });
+ if (l2 != l1) try ex.out.print(ex.arena, ",{d}", .{l2});
+ }
+ try ex.out.append(ex.arena, '\n');
+ return r;
+ },
+ 's' => return ex.substitute(c, fi, r),
+ 'x', 'y' => {
+ const ranges = if (c.re) |pat| try ex.looper(pat, fi, r, c.c == 'x') else try ex.lines(fi, r);
+ ex.nest += 1;
+ defer ex.nest -= 1;
+ var d = r;
+ for (ranges) |each| d = try ex.exec(c.sub.?, fi, each);
+ return d;
+ },
+ 'g', 'v' => {
+ var rx = try ex.compile(c.re.?, c.c);
+ const hit = (try ex.find(&rx, txt, r.q0, r.q1)) != null;
+ if (hit != (c.c == 'v')) return ex.exec(c.sub.?, fi, r);
+ return r;
+ },
+ 'm', 't' => {
+ const to = try ex.address(fi, c.to, r);
+ const bytes = txt[r.q0..r.q1];
+ if (c.c == 't') {
+ try ex.log(fi, to.q1, to.q1, bytes, null);
+ } else if (r.q1 <= to.q0) {
+ // ecmd.c:408, move
+ try ex.log(fi, r.q0, r.q1, "", null);
+ try ex.log(fi, to.q1, to.q1, bytes, null);
+ } else if (r.q0 >= to.q1) {
+ try ex.log(fi, to.q1, to.q1, bytes, null);
+ try ex.log(fi, r.q0, r.q1, "", null);
+ } else if (!(r.q0 == to.q0 and r.q1 == to.q1)) {
+ return fail(ex.why, "move overlaps itself", .{});
+ }
+ return r;
+ },
+ 'u' => return fail(ex.why, "u is only an Edit of its own here", .{}),
+ '{' => {
+ var it = c.sub;
+ while (it) |each| : (it = each.next) _ = try ex.exec(each, fi, r);
+ return r;
+ },
+ 'b' => {
+ // ecmd.c b_cmd, tofile: the file named so, exactly or in
+ // the current file's directory.
+ const name = std.mem.trim(u8, c.text, " \t");
+ const at = ex.lookFile(name) orelse ex.lookFile(try ex.pathIn(fi, name));
+ const to = if (at) |i| (if (ex.files.items[i].scratch) null else i) else null;
+ const target = to orelse return fail(ex.why, "no such file \"{s}\"", .{name});
+ // The `.` goes with it in the line printed.
+ ex.cur = target;
+ if (ex.nest == 0) try ex.out.appendSlice(ex.arena, try ex.fileLine(target));
+ return r;
+ },
+ 'B' => {
+ const list = std.mem.trim(u8, c.text, " \t");
+ if (list.len > 0 and list[0] == '<') return fail(ex.why, "B <command is not supported: give the names", .{});
+ if (list.len == 0) return fail(ex.why, e_noname, .{});
+ const w = ex.world orelse return fail(ex.why, "B: no panes to open here", .{});
+ // Every name first: one that cannot open opens none.
+ var checks = std.mem.tokenizeAny(u8, list, " \t");
+ while (checks.next()) |name| if (!w.check(w.ctx, try ex.pathIn(fi, name), ex.why)) return error.Edit;
+ var names = std.mem.tokenizeAny(u8, list, " \t");
+ while (names.next()) |name| {
+ const path = try ex.pathIn(fi, name);
+ const opened = w.open(w.ctx, path, ex.why) orelse return error.Edit;
+ if (for (ex.files.items) |f| {
+ if (f.id == opened.id and !f.close) break true;
+ } else false) continue;
+ try ex.files.append(ex.arena, opened);
+ }
+ return r;
+ },
+ 'D' => {
+ const list = std.mem.trim(u8, c.text, " \t");
+ if (list.len > 0 and list[0] == '<') return fail(ex.why, "D <command is not supported: give the names", .{});
+ if (list.len == 0) {
+ try ex.closeFile(fi);
+ return r;
+ }
+ var names = std.mem.tokenizeAny(u8, list, " \t");
+ while (names.next()) |name| {
+ const path = try ex.pathIn(fi, name);
+ try ex.closeFile(ex.lookFile(path) orelse return fail(ex.why, "no such file {s}", .{path}));
+ }
+ return r;
+ },
+ 'r' => {
+ // ecmd.c e_cmd: r reads a file over dot.
+ const path = (try ex.cmdName(fi, c.text, false)) orelse return fail(ex.why, e_noname, .{});
+ try ex.log(fi, r.q0, r.q1, try ex.readFile(path), null);
+ return r;
+ },
+ 'e' => {
+ // ecmd.c e_cmd: a file read over all of this one, which takes
+ // its name: Get's way (ctl.getFile), once the Edit is done,
+ // asking first, once, over unsaved edits.
+ const f = &ex.files.items[fi];
+ if (f.ops.items.len > 0) return fail(ex.why, "e: {s} has changes pending in this Edit", .{f.name});
+ const given = std.mem.trim(u8, c.text, " \t");
+ const path = if (given.len == 0)
+ (if (f.scratch) return fail(ex.why, e_noname, .{}) else f.name)
+ else
+ try ex.pathIn(fi, given);
+ const w = ex.world orelse return fail(ex.why, "can't open {s}: no files here", .{path});
+ if (w.refuseGet(w.ctx, f.id, ex.why)) return error.Edit;
+ _ = try ex.readFile(path);
+ f.get = path;
+ f.name = path;
+ return r;
+ },
+ 'w' => {
+ if (ex.files.items[fi].ops.items.len > 0) return fail(ex.why, "can't write file with pending modifications", .{});
+ const path = (try ex.cmdName(fi, c.text, false)) orelse return fail(ex.why, "no name specified for 'w' command", .{});
+ try ex.writes.append(ex.arena, .{
+ .file = @intCast(fi),
+ .path = path,
+ .bytes = try ex.arena.dupe(u8, txt[r.q0..r.q1]),
+ .whole = r.q0 == 0 and r.q1 == txt.len,
+ });
+ return r;
+ },
+ 'f' => {
+ _ = try ex.cmdName(fi, c.text, true);
+ try ex.out.appendSlice(ex.arena, try ex.fileLine(fi));
+ return r;
+ },
+ 'X', 'Y' => {
+ // ecmd.c filelooper: the files whose line matches (X) or
+ // does not (Y), each from its own dot; X alone is every
+ // file with a name.
+ if (ex.looping) return fail(ex.why, "can't nest {c} command", .{c.c});
+ ex.looping = true;
+ defer ex.looping = false;
+ ex.nest += 1;
+ defer ex.nest -= 1;
+ var chosen: std.ArrayList(usize) = .empty;
+ for (ex.files.items, 0..) |f, i| {
+ if (f.close) continue;
+ if (c.re == null and f.scratch) continue;
+ if (c.re == null or (try ex.fileMatch(i, c.re.?)) == (c.c == 'X')) try chosen.append(ex.arena, i);
+ }
+ for (chosen.items) |i| {
+ const d = try ex.exec(c.sub.?, i, ex.files.items[i].dot);
+ ex.files.items[i].dot = d;
+ ex.files.items[i].moved = true;
+ }
+ return r;
+ },
+ '<', '|', '>' => {
+ // ecmd.c runpipe: the command's output replaces dot (`<`,
+ // `|`), dot is its input (`|`, `>`), and `>`'s output is
+ // printed.
+ const command = std.mem.trim(u8, c.text, " \t");
+ if (command.len == 0) return fail(ex.why, "no command specified for {c}", .{c.c});
+ if (ex.jobs.items.len >= max_jobs) return fail(ex.why, "too many commands: more than {d} for one Edit", .{max_jobs});
+ const job: u32 = @intCast(ex.jobs.items.len);
+ try ex.jobs.append(ex.arena, .{ .c = c.c, .command = command, .file = @intCast(fi), .q0 = r.q0, .q1 = r.q1, .at = ex.out.items.len });
+ if (c.c != '>') try ex.log(fi, r.q0, r.q1, "", job);
+ return r;
+ },
+ else => return fail(ex.why, "unknown command {c}", .{c.c}),
+ }
+ }
+
+ /// ecmd.c D1: closed once the Edit is done. One with changes pending
+ /// in this Edit is refused rather than have them dropped.
+ fn closeFile(ex: *Exec, fi: usize) Failure!void {
+ const f = &ex.files.items[fi];
+ if (f.ops.items.len > 0 or f.get != null) return fail(ex.why, "D: {s} has changes pending in this Edit", .{f.name});
+ f.close = true;
+ }
+
+ /// ecmd.c:443, s_cmd.
+ fn substitute(ex: *Exec, c: *Cmd, fi: usize, r: Range) Failure!Range {
+ const txt = ex.text(fi);
+ var rx = try ex.compile(c.re.?, 's');
+ var n = c.num;
+ var op: ?usize = null;
+ var p1: usize = r.q0;
+ var did = false;
+ while (p1 <= r.q1) {
+ const m = (try ex.find(&rx, txt, p1, r.q1)) orelse break;
+ if (m.start == m.end) {
+ if (op != null and m.start == op.?) {
+ p1 = stepRune(txt, p1);
+ continue;
+ }
+ p1 = stepRune(txt, m.end);
+ } else p1 = m.end;
+ op = m.end;
+ n -= 1;
+ if (n > 0) continue;
+ var buf: std.ArrayList(u8) = .empty;
+ var i: usize = 0;
+ while (i < c.text.len) : (i += 1) {
+ const ch = c.text[i];
+ if (ch == '\\' and i + 1 < c.text.len) {
+ i += 1;
+ const e = c.text[i];
+ if (e >= '1' and e <= '9') return fail(ex.why, "no \\{c}: mvzr keeps no submatches", .{e});
+ try buf.append(ex.arena, e);
+ } else if (ch == '&') {
+ try buf.appendSlice(ex.arena, txt[m.start..m.end]);
+ } else try buf.append(ex.arena, ch);
+ }
+ try ex.log(fi, clip(m.start), clip(m.end), buf.items, null);
+ did = true;
+ if (!c.global) break;
+ }
+ if (!did and ex.nest == 0) return if (r.q0 == r.q1)
+ fail(ex.why, "no substitution: dot is empty", .{})
+ else
+ fail(ex.why, "no substitution", .{});
+ return r;
+ }
+
+ /// ecmd.c:796, looper: the matches (x) or what lies between them (y).
+ fn looper(ex: *Exec, pat: []const u8, fi: usize, r: Range, xy: bool) Failure![]Range {
+ const txt = ex.text(fi);
+ var rx = try ex.compile(pat, if (xy) 'x' else 'y');
+ var out: std.ArrayList(Range) = .empty;
+ var op: ?usize = if (xy) null else r.q0;
+ var p: usize = r.q0;
+ while (p <= r.q1) {
+ var tr: Range = undefined;
+ var sel_end: usize = undefined;
+ if (try ex.find(&rx, txt, p, r.q1)) |m| {
+ if (m.start == m.end) {
+ if (op != null and m.start == op.?) {
+ p = stepRune(txt, p);
+ continue;
+ }
+ p = stepRune(txt, m.end);
+ } else p = m.end;
+ tr = if (xy) .{ .q0 = clip(m.start), .q1 = clip(m.end) } else .{ .q0 = clip(op.?), .q1 = clip(m.start) };
+ sel_end = m.end;
+ } else {
+ // no match, but y still takes what is left
+ if (xy or op.? > r.q1) break;
+ tr = .{ .q0 = clip(op.?), .q1 = r.q1 };
+ p = @as(usize, r.q1) + 1;
+ sel_end = r.q1;
+ }
+ op = sel_end;
+ try out.append(ex.arena, tr);
+ }
+ return out.items;
+ }
+
+ /// ecmd.c:840, linelooper: each line in the range, the first from where
+ /// the range starts, the last cut where it ends.
+ fn lines(ex: *Exec, fi: usize, r: Range) Failure![]Range {
+ const txt = ex.text(fi);
+ var out: std.ArrayList(Range) = .empty;
+ var p: usize = r.q0;
+ while (p < r.q1) {
+ const nl = std.mem.indexOfScalarPos(u8, txt, p, '\n');
+ const e = @min(if (nl) |i| i + 1 else txt.len, r.q1);
+ if (e <= p) break;
+ try out.append(ex.arena, .{ .q0 = clip(p), .q1 = clip(e) });
+ p = e;
+ }
+ return out.items;
+ }
+};
+
+/// The text after `ops`, which are in order and do not overlap (a job's
+/// with its output in place).
+pub fn apply(gpa: std.mem.Allocator, text: []const u8, ops: []const Op) ![]u8 {
+ var n: usize = text.len;
+ for (ops) |o| n = n - (o.q1 - o.q0) + o.text.len;
+ const out = try gpa.alloc(u8, n);
+ var at: usize = 0;
+ var from: usize = 0;
+ for (ops) |o| {
+ const keep = text[from..o.q0];
+ @memcpy(out[at..][0..keep.len], keep);
+ at += keep.len;
+ @memcpy(out[at..][0..o.text.len], o.text);
+ at += o.text.len;
+ from = o.q1;
+ }
+ @memcpy(out[at..], text[from..]);
+ return out;
+}
+
+/// Where `dot` lands after `ops` (their texts final): each end moved by the
+/// changes before it; an empty dot where a change starts selects what it
+/// put there, as elogapply does (elog.c:283).
+pub fn moveDot(dot: Range, ops: []const Op) Range {
+ var shift: i64 = 0;
+ for (ops) |o| {
+ if (dot.q0 == dot.q1 and o.q0 == dot.q0 and (o.text.len > 0)) {
+ const q: u32 = @intCast(@as(i64, dot.q0) + shift);
+ return .{ .q0 = q, .q1 = q + @as(u32, @intCast(o.text.len)) };
+ }
+ if (o.q1 > dot.q0) break;
+ shift += @as(i64, @intCast(o.text.len)) - @as(i64, o.q1 - o.q0);
+ }
+ const q0: u32 = @intCast(@as(i64, dot.q0) + shift);
+ var shift1: i64 = 0;
+ for (ops) |o| {
+ if (o.q1 > dot.q1 or (o.q0 == o.q1 and o.q0 == dot.q1)) break;
+ shift1 += @as(i64, @intCast(o.text.len)) - @as(i64, o.q1 - o.q0);
+ }
+ const q1: u32 = @intCast(@max(@as(i64, q0), @as(i64, dot.q1) + shift1));
+ return .{ .q0 = q0, .q1 = q1 };
+}
+
+fn edited(text: []const u8, command: []const u8) ![]u8 {
+ var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
+ defer arena_state.deinit();
+ var why: Why = .{};
+ const res = run(arena_state.allocator(), &.{.{ .name = "t", .text = text }}, 0, command, null, &why) catch |err| {
+ if (err == error.Edit) std.debug.print("Edit: {s}\n", .{why.text()});
+ return err;
+ };
+ return apply(std.testing.allocator, text, res.files[0].ops.items);
+}
+
+fn expectEdit(text: []const u8, command: []const u8, want: []const u8) !void {
+ const got = try edited(text, command);
+ defer std.testing.allocator.free(got);
+ try std.testing.expectEqualStrings(want, got);
+}
+
+test "an x over 100k lines is 100k searches, each with its own step budget" {
+ const th = @import("ninep/testing.zig");
+ const line = &@as([80]u8, @splat('x')) ++ "\n";
+ const text = try std.testing.allocator.alloc(u8, line.len * 100_000);
+ defer std.testing.allocator.free(text);
+ for (0..100_000) |k| @memcpy(text[line.len * k ..][0..line.len], line);
+ const p = try th.withFile(std.testing.allocator, text);
+ defer p.deinit();
+ const tree = @import("ninep/tree.zig");
+ const r = th.wr(p, tree.Node.of(th.serialOf(p), .ctl), "Edit ,x/x+/c/z/\n");
+ try std.testing.expectEqual(tree.Status.ok, r.reply.status);
+ try std.testing.expect(std.mem.startsWith(u8, p.panes[0].?.file.?.content, "z\nz\n"));
+}
+
+test "sam's classic commands" {
+ try expectEdit("foo x foo y foo\n", ",x/foo/c/foobar/", "foobar x foobar y foobar\n");
+ try expectEdit("a b\nc d\n", ",x/ /c/_/", "a_b\nc_d\n");
+ // As in acme (ecmd.c:810), y also takes the empty stretch after the last match.
+ try expectEdit("one\ntwo\nthree\n", ",y/\\n/c/X/", "X\nX\nX\nX");
+ try expectEdit("aaa\n", ",s/a/b/g", "bbb\n");
+ try expectEdit("aaa\n", ",s/a/b/", "baa\n");
+ try expectEdit("aaa\n", ",s2/a/b/", "aba\n");
+ try expectEdit("aaa\n", ",s/a/b/2", "aba\n");
+ try expectEdit("cat dog\n", ",s/[a-z]+/<&>/g", "<cat> <dog>\n");
+ // x within x, g within x.
+ try expectEdit("int a;\nfloat b;\nint c;\n", ",x/.*\\n/g/^int/x/[a-z];/c/X;/", "int X;\nfloat b;\nint X;\n");
+ try expectEdit("keep 1\ndrop 2\nkeep 3\n", ",x g/drop/d", "keep 1\nkeep 3\n");
+ try expectEdit("keep 1\ndrop 2\nkeep 3\n", ",x v/keep/d", "keep 1\nkeep 3\n");
+ // Lines, a/i, grouping, m and t.
+ try expectEdit("a\nb\n", ",x a/;/", "a\n;b\n;");
+ try expectEdit("a\nb\n", "1 i/>/", ">a\nb\n");
+ try expectEdit("abc\n", "/b/{\ni/[/\na/]/\n}", "a[b]c\n");
+ try expectEdit("one\ntwo\n", "1 m $", "two\none\n");
+ try expectEdit("one\ntwo\n", "1 t $", "one\ntwo\none\n");
+ try expectEdit("one\ntwo\nthree\n", "2 d", "one\nthree\n");
+ // ^ at every line start in a pattern that spans lines (dogfood round 5).
+ try expectEdit("x = 1\ndef a\ndef b\n", ",x/^def .*\\n/a/X\\n/", "x = 1\ndef a\nX\ndef b\nX\n");
+ // pardes's line:col.
+ try expectEdit("one\ntwo\n", "2:2 i/-/", "one\nt-wo\n");
+}
+
+test "an Edit that fails halfway changes nothing, and says why in acme's words" {
+ var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
+ defer arena_state.deinit();
+ for ([_][2][]const u8{
+ .{ ",x/foo/c/bar/\n/nomatch/d", "no match for regexp /nomatch/" },
+ .{ ",s/zzz/y/", "no substitution" },
+ .{ "s/foo/y/", "no substitution: dot is empty" },
+ .{ "k", "unknown command k" },
+ .{ ",x/a/{\na/1/\ni/2/\n}", "changes out of sequence" },
+ .{ "}", "right brace with no left brace" },
+ .{ ",x/foo/{", "unmatched `{'" },
+ .{ ",x/foo/{\nd", "unmatched `{'" },
+ .{ "B <ls", "B <command is not supported: give the names" },
+ .{ "1d\nD", "D: t has changes pending in this Edit" },
+ .{ "X X p", "can't nest X command" },
+ .{ "3 b t", "command takes no address" },
+ .{ ",|", "no command specified for |" },
+ .{ "b nowhere", "no such file \"nowhere\"" },
+ .{ "1d\nw /tmp/x", "can't write file with pending modifications" },
+ .{ "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| {
+ var why: Why = .{};
+ try std.testing.expectError(error.Edit, run(arena_state.allocator(), &.{.{ .name = "t", .text = "foo a\nfoo\n" }}, 0, c[0], null, &why));
+ try std.testing.expectEqualStrings(c[1], why.text());
+ }
+}
+
+test "an Edit wants the lines after it until its braces and text blocks close" {
+ var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
+ defer arena_state.deinit();
+ const a = arena_state.allocator();
+ try std.testing.expect(waitsFor(a, ",x/foo/{") != .none);
+ try std.testing.expect(waitsFor(a, ",x/foo/{\ni/[/") != .none);
+ try std.testing.expectEqual(Wait.none, waitsFor(a, ",x/foo/{\ni/[/\n}"));
+ try std.testing.expect(waitsFor(a, "$a\nline one") != .none);
+ try std.testing.expectEqual(Wait.none, waitsFor(a, "$a\nline one\n."));
+ try std.testing.expectEqual(Wait.none, waitsFor(a, ",s/{/x/"));
+ try std.testing.expectEqual(Wait.none, waitsFor(a, ",x/foo/c/bar/"));
+}
+
+test "the dot an Edit leaves selects what a change put where it stood" {
+ const ops = [_]Op{.{ .q0 = 2, .q1 = 4, .text = "XYZ" }};
+ try std.testing.expectEqual(Range{ .q0 = 2, .q1 = 5 }, moveDot(.{ .q0 = 2, .q1 = 2 }, &ops));
+ try std.testing.expectEqual(Range{ .q0 = 6, .q1 = 7 }, moveDot(.{ .q0 = 5, .q1 = 6 }, &ops));
+}
+
+test "x, y and s match whole runes: a byte pattern never splits one" {
+ // é is c3 a9: `.` takes it whole, as it takes a lone combining mark.
+ try expectEdit("\u{e9}", ",x/./a/|/", "\u{e9}|");
+ try expectEdit("e\u{301}t", ",s/./X/g", "XXX");
+ try expectEdit("a\u{e9}b", ",y/\u{e9}/c/-/", "-\u{e9}-");
+ try expectEdit("\u{e9}\u{e9}", ",x/\\xC3/c/E/", "EE");
+ // An invalid byte is a place of its own.
+ try expectEdit("a\x81b", ",x/./a/|/", "a|\x81|b|");
+ try expectEdit("\u{e9}", ",s/$/!/", "\u{e9}!");
+}
+
+/// Three files and a +Errors, the way the editor hands them over, and a
+/// world whose disk holds /src/new.c and /src/data.
+const Fixture = struct {
+ arena_state: std.heap.ArenaAllocator,
+ why: Why = .{},
+
+ const files = [_]File{
+ .{ .name = "/src/a.c", .text = "int foo;\nint bar;\n", .id = 0 },
+ .{ .name = "/src/b.h", .text = "foo bar foo\n", .id = 1, .dirty = true },
+ .{ .name = "/src/c.c", .text = "bar\n", .id = 2 },
+ .{ .name = "/src/+Errors", .text = "foo\n", .id = 3, .scratch = true },
+ };
+
+ var opened: usize = 0;
+
+ fn check(_: *anyopaque, path: []const u8, why: *Why) bool {
+ if (std.mem.eql(u8, path, "/src/new.c")) return true;
+ why.len = if (std.fmt.bufPrint(&why.buf, "B: cannot open {s}", .{path})) |said| said.len else |_| 0;
+ return false;
+ }
+
+ /// The edited file, b.h, is asked about: refused.
+ fn refuseGet(_: *anyopaque, id: usize, why: *Why) bool {
+ if (id != 1) return false;
+ why.len = (std.fmt.bufPrint(&why.buf, "/src/b.h: Modified (e again to discard)", .{}) catch unreachable).len;
+ return true;
+ }
+
+ fn open(_: *anyopaque, path: []const u8, why: *Why) ?File {
+ opened += 1;
+ if (std.mem.eql(u8, path, "/src/new.c")) return .{ .name = "/src/new.c", .text = "new foo\n", .id = 9 };
+ why.len = if (std.fmt.bufPrint(&why.buf, "B: cannot open {s}", .{path})) |said| said.len else |_| 0;
+ return null;
+ }
+
+ fn read(_: *anyopaque, arena: std.mem.Allocator, path: []const u8, why: *Why) ?[]const u8 {
+ if (std.mem.eql(u8, path, "/src/data")) return arena.dupe(u8, "DATA\n") catch null;
+ why.len = if (std.fmt.bufPrint(&why.buf, "can't open {s}: file does not exist", .{path})) |said| said.len else |_| 0;
+ return null;
+ }
+
+ fn init() Fixture {
+ return .{ .arena_state = .init(std.testing.allocator) };
+ }
+
+ fn deinit(fx: *Fixture) void {
+ fx.arena_state.deinit();
+ }
+
+ fn edit(fx: *Fixture, from: usize, command: []const u8) !Result {
+ var ctx: u8 = 0;
+ const world: World = .{ .ctx = &ctx, .check = check, .open = open, .read = read, .refuseGet = refuseGet };
+ return run(fx.arena_state.allocator(), &files, from, command, world, &fx.why);
+ }
+
+ /// File `i`'s text after the Edit.
+ fn after(fx: *Fixture, res: Result, i: usize) ![]const u8 {
+ return apply(fx.arena_state.allocator(), res.files[i].text, res.files[i].ops.items);
+ }
+};
+
+test "X and Y run a command in each open file whose line matches, or does not" {
+ var fx: Fixture = .init();
+ defer fx.deinit();
+ // ecmd.c filelooper: each file from its own dot, the current one too.
+ const x = try fx.edit(0, "X/\\.c$/ ,s/foo/FOO/g");
+ try std.testing.expectEqualStrings("int FOO;\nint bar;\n", try fx.after(x, 0));
+ try std.testing.expectEqual(@as(usize, 0), x.files[1].ops.items.len);
+ try std.testing.expectEqual(@as(usize, 0), x.files[2].ops.items.len); // no foo: s in a loop is quiet
+ const y = try fx.edit(0, "Y/\\.c$/ ,s/foo/FOO/g");
+ try std.testing.expectEqualStrings("FOO bar FOO\n", try fx.after(y, 1));
+ try std.testing.expectEqualStrings("FOO\n", try fx.after(y, 3));
+ try std.testing.expectEqual(@as(usize, 0), y.files[0].ops.items.len);
+ // X alone is every file with a name, f its default: acme's file lines,
+ // `'` for the edited one and `.` for the current.
+ const all = try fx.edit(2, "X");
+ try std.testing.expectEqualStrings(" + /src/a.c\n'+ /src/b.h\n +. /src/c.c\n", all.printed);
+ // The line is what is matched: X/'/ is every edited file.
+ const dirty = try fx.edit(0, "X/'/ =");
+ try std.testing.expectEqualStrings("/src/b.h:1\n", dirty.printed);
+}
+
+test "b moves the current file, \"re\" addresses another, and f names one" {
+ var fx: Fixture = .init();
+ defer fx.deinit();
+ const b = try fx.edit(0, "b /src/c.c\n,c/C/");
+ try std.testing.expectEqualStrings(" +. /src/c.c\n", b.printed);
+ try std.testing.expectEqualStrings("C", try fx.after(b, 2));
+ try std.testing.expectEqual(@as(usize, 0), b.files[0].ops.items.len);
+ try std.testing.expectEqual(@as(usize, 2), b.cur);
+ // A name in the current file's directory will do.
+ try std.testing.expectEqual(@as(usize, 1), (try fx.edit(0, "b b.h")).cur);
+ // `"re"`: that file's line, the command in it, the current file kept.
+ const q = try fx.edit(0, "\"b\\.h\" 1 s/bar/BAR/");
+ try std.testing.expectEqualStrings("foo BAR foo\n", try fx.after(q, 1));
+ try std.testing.expectEqual(@as(usize, 0), q.cur);
+ // Only `;` carries the file to the right of a `,`, as in acme.
+ try std.testing.expectError(error.Edit, fx.edit(0, "\"b\\.h\" ,s/bar/BAR/"));
+ try std.testing.expectEqualStrings("addresses in different files", fx.why.text());
+ try std.testing.expectEqualStrings("FOO", (try fx.after(try fx.edit(0, "\"b\\.h\"0;$ s/foo bar foo/FOO/"), 1))[0..3]);
+ try std.testing.expectError(error.Edit, fx.edit(0, "\"\\.c\" p"));
+ try std.testing.expectEqualStrings("too many files match \"\\.c\"", fx.why.text());
+ const f = try fx.edit(0, "f other.c");
+ try std.testing.expectEqualStrings(" +. /src/other.c\n", f.printed);
+ try std.testing.expect(f.files[0].renamed);
+}
+
+test "e and r read a file into the text, w writes it, D and B close and open panes" {
+ var fx: Fixture = .init();
+ defer fx.deinit();
+ // r replaces dot; e loads a file over all of it at the end, by Get's
+ // way, which names the pane after it.
+ const r = try fx.edit(0, "2 r data");
+ try std.testing.expectEqualStrings("int foo;\nDATA\n", try fx.after(r, 0));
+ try std.testing.expect(!r.files[0].renamed);
+ const e = try fx.edit(0, "e data");
+ try std.testing.expectEqualStrings("/src/data", e.files[0].get.?);
+ try std.testing.expectEqual(@as(usize, 0), e.files[0].ops.items.len);
+ // ...and takes no more commands, nor follows another change.
+ try std.testing.expectError(error.Edit, fx.edit(0, "e data\n,d"));
+ try std.testing.expectError(error.Edit, fx.edit(0, "1d\ne data"));
+ // e of an edited file is asked about, as Get asks.
+ try std.testing.expectError(error.Edit, fx.edit(1, "e"));
+ try std.testing.expectEqualStrings("/src/b.h: Modified (e again to discard)", fx.why.text());
+ // `~` is the home directory, as Get and Save read it.
+ const home = try fx.edit(0, "w ~/t.txt");
+ try std.testing.expect(home.writes[0].path[0] == '/' and std.mem.indexOfScalar(u8, home.writes[0].path, '~') == null);
+ try std.testing.expectError(error.Edit, fx.edit(0, "r nothing"));
+ try std.testing.expectEqualStrings("can't open /src/nothing: file does not exist", fx.why.text());
+ // w: all of it by default, to its own name; an address and a name.
+ const w = try fx.edit(0, "w\n2 w part");
+ try std.testing.expectEqual(@as(usize, 2), w.writes.len);
+ try std.testing.expectEqualStrings("/src/a.c", w.writes[0].path);
+ try std.testing.expect(w.writes[0].whole);
+ try std.testing.expectEqualStrings("/src/part", w.writes[1].path);
+ try std.testing.expectEqualStrings("int bar;\n", w.writes[1].bytes);
+ try std.testing.expect(!w.writes[1].whole);
+ try std.testing.expectError(error.Edit, fx.edit(3, "w"));
+ try std.testing.expectEqualStrings("no name specified for 'w' command", fx.why.text());
+ // D marks the panes to close once the Edit is done; a closed one takes
+ // no more commands.
+ const d = try fx.edit(0, "D c.c b.h");
+ try std.testing.expect(d.files[2].close and d.files[1].close and !d.files[0].close);
+ try std.testing.expectError(error.Edit, fx.edit(0, "D\n,d"));
+ try std.testing.expectEqualStrings("no current window", fx.why.text());
+ // B opens a pane, which the rest of the Edit can then use.
+ const b = try fx.edit(0, "B new.c\nb /src/new.c\n,s/new/old/");
+ try std.testing.expectEqual(@as(usize, 5), b.files.len);
+ try std.testing.expectEqualStrings("old foo\n", try fx.after(b, 4));
+ try std.testing.expectError(error.Edit, fx.edit(0, "B gone.c"));
+ try std.testing.expectEqualStrings("B: cannot open /src/gone.c", fx.why.text());
+ // Every name is checked first: one that cannot open opens none.
+ Fixture.opened = 0;
+ try std.testing.expectError(error.Edit, fx.edit(0, "B new.c gone.c"));
+ try std.testing.expectEqual(@as(usize, 0), Fixture.opened);
+}
+
+test "<, | and > are jobs: a command per address, its output the change" {
+ var fx: Fixture = .init();
+ defer fx.deinit();
+ const res = try fx.edit(0, ",x/foo|bar/ | tr a-z A-Z\n$ > wc -c\n$ < date");
+ try std.testing.expectEqual(@as(usize, 4), res.jobs.len);
+ try std.testing.expectEqual(@as(u8, '|'), res.jobs[0].c);
+ try std.testing.expectEqualStrings("tr a-z A-Z", res.jobs[0].command);
+ try std.testing.expectEqualStrings("foo", res.files[0].text[res.jobs[0].q0..res.jobs[0].q1]);
+ try std.testing.expectEqualStrings("bar", res.files[0].text[res.jobs[1].q0..res.jobs[1].q1]);
+ try std.testing.expectEqual(@as(u8, '>'), res.jobs[2].c);
+ try std.testing.expectEqual(@as(u8, '<'), res.jobs[3].c);
+ // `>` changes nothing; `|` and `<` hold their output's place.
+ const ops = res.files[0].ops.items;
+ try std.testing.expectEqual(@as(usize, 3), ops.len);
+ try std.testing.expectEqual(@as(?u32, 0), ops[0].job);
+ try std.testing.expectEqual(@as(?u32, 1), ops[1].job);
+ try std.testing.expectEqual(@as(?u32, 3), ops[2].job);
+ // ...out of order with the x before it: `1 <` reaches back.
+ try std.testing.expectError(error.Edit, fx.edit(0, ",x/bar/ | cat\n1 < date"));
+ try std.testing.expectEqualStrings("changes out of sequence", fx.why.text());
+ // Across files with X: each job is its file's.
+ const x = try fx.edit(0, "X/\\.c$/ , | sort");
+ try std.testing.expectEqual(@as(usize, 2), x.jobs.len);
+ try std.testing.expectEqual(@as(u32, 2), x.jobs[1].file);
+}
+
+test "an Edit that runs commands is told from one that does not" {
+ var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
+ defer arena_state.deinit();
+ const a = arena_state.allocator();
+ try std.testing.expect(runsCommands(a, ", | sort"));
+ try std.testing.expect(runsCommands(a, ",x/a/{\n< date\n}"));
+ try std.testing.expect(runsCommands(a, "X/c/ , > wc"));
+ try std.testing.expect(!runsCommands(a, ",s/|/>/g"));
+ try std.testing.expect(!runsCommands(a, ",x/</d"));
+}