//! Command structs and runtime settings form the builtin registry; bindings live in config.zig. const std = @import("std"); const pardes = @import("pardes.zig"); const tagline = @import("tagline.zig"); const dump = @import("dump.zig"); const exec = @import("exec.zig"); const look = @import("look.zig"); const edit = @import("edit.zig"); const colors = @import("colors.zig"); const Pardes = pardes.Pardes; const Pane = pardes.Pane; const panes = @import("panes.zig"); const layout = @import("layout.zig"); const config = @import("config.zig"); const limits = @import("memory.zig").limits; const keys = @import("keys.zig"); const Jump = @import("Jump.zig"); /// What this build's own frontend draws and its host does: the render's. pub const frontend: config.Runtime.Capabilities = .{ .font_picker = pardes.font_picker, // The tty's font belongs to its emulator. .tagline_font_size = pardes.platform != .tui, .window_opacity = pardes.platform == .gui or pardes.platform == .macos, // The grip's width, the cursor's blink and the Pet are the SDL window's. .pixels = pardes.platform == .gui, }; /// The terminal's build and the window's (docs/next-daemon.md, "Phase 6: /// GUI replica notes"): each has the other's words, which a view takes as /// its own frontend does (`viewCapabilities`), so a terminal's replica of a /// window's session steps as the window's own does, and back. pub const desktop = pardes.platform == .tui or pardes.platform == .gui; const window_capabilities: config.Runtime.Capabilities = .{ .font_picker = true, .tagline_font_size = true, .window_opacity = true, .pixels = true }; const terminal_capabilities: config.Runtime.Capabilities = .{ .font_picker = false, .tagline_font_size = false, .window_opacity = false, .pixels = false }; /// The words this build has: a desktop build's are the window's. pub const capabilities: config.Runtime.Capabilities = if (desktop) window_capabilities else frontend; /// What the live view's frontend takes: a window's, or a terminal's /// (`Pardes.frontend`, which its client says, Event.frontend). pub fn viewCapabilities(p: *const Pardes) config.Runtime.Capabilities { if (comptime !desktop) return frontend; return if (p.view().frontend.windowed) window_capabilities else terminal_capabilities; } /// The live view's frontend, by name (the Settings report's platform). pub fn viewPlatform(p: *const Pardes) []const u8 { if (comptime !desktop) return @tagName(pardes.platform); return if (p.view().frontend.windowed) "gui" else "tui"; } /// Where a builtin acts: at the pane it runs from, or on the editor as a /// whole. acme keeps its window verbs on a window's ctl and its session /// commands elsewhere, as webfs and upas/fs keep session settings on a root /// ctl; pardes's root `ctl` takes the session builtins and a pane's `ctl` /// the pane ones. A builtin says `pub const scope: Scope = .session;`, /// and every setting is one; the rest act on their pane. /// The kinds of pane a builtin may be for alone (registry.needs). pub const PaneKind = enum { terminal, image, /// An image pane, or a terminal, whose program's kitty graphics are /// pictures too. picture, /// A terminal, or a +Pager: a program's colours. program_colors, /// A text pane showing a diff: a .diff, a .patch, a +Pager holding one. diff, pub fn has(kind: PaneKind, pane: *const panes.Pane) bool { return switch (kind) { .terminal => pane.isTerminal(), .image => pane.addon != null, .picture => pane.addon != null or pane.isTerminal(), .program_colors => pane.isTerminal() or (pane.file != null and pane.file.?.pager), .diff => if (pane.file) |f| pane.colorAlgo() == .diff or (f.output != null and std.meta.eql(f.output.?.from, panes.Output.Origin{ .cmd = .Diff })) else false, }; } pub fn noun(kind: PaneKind) []const u8 { return switch (kind) { .terminal => "a terminal", .image => "an image", .picture => "an image or a terminal", .program_colors => "a terminal or a +Pager", .diff => "a diff or a +Diff", }; } }; pub const Scope = enum { pane, session }; pub const Ctx = struct { p: *Pardes, pane: *Pane, id: usize, txt: []const u8, arg: ?[]const u8, /// Made by a gesture on the pane's body -- a middle click, the execute /// key -- as acme's execute() asks of its Text (exec.c:122,169): an /// Exec from a body may be a bound REPL's (exec.zig routeToRepl). from_body: bool = false, }; fn isEnabled(comptime T: type) bool { return !@hasDecl(T, "enabled") or T.enabled; } /// Why `word`, a builtin some build has, is none in this one: `GUI-only` /// for the GUI's own (`gui_only`), else `not in this build`; null for a /// word that is one here, or in no build. pub fn absentWhy(name: []const u8) ?[]const u8 { @setEvalBranchQuota(20000); inline for (@typeInfo(@This()).@"struct".decl_names) |d| { if (comptime @TypeOf(@field(@This(), d)) == type) { const T = @field(@This(), d); if (comptime @typeInfo(T) == .@"struct" and @hasDecl(T, "run") and !isEnabled(T)) { if (std.mem.eql(u8, d, name)) return if (@hasDecl(T, "gui_only")) "GUI-only" else "not in this build"; } } } return null; } fn manualBuiltinList() []const type { comptime { @setEvalBranchQuota(4000); var list: []const type = &.{}; for (@typeInfo(@This()).@"struct".decl_names) |d| { if (@TypeOf(@field(@This(), d)) != type) continue; const T = @field(@This(), d); if (@typeInfo(T) != .@"struct" or !@hasDecl(T, "run") or !isEnabled(T)) continue; if (@TypeOf(T.run) != fn (Ctx) void) @compileError(d ++ ".run must have signature fn (Ctx) void"); list = list ++ .{T}; } return list; } } fn settingList() []const config.Runtime.Setting { comptime { var list: []const config.Runtime.Setting = &.{}; for (config.Runtime.settings) |setting| if (setting.enabled(capabilities)) { list = list ++ .{setting}; }; return list; } } pub fn word(comptime T: type) []const u8 { const n = @typeName(T); const dot = std.mem.lastIndexOfScalar(u8, n, '.') orelse return n; return n[dot + 1 ..]; } pub const OutputTraits = struct { name: []const u8, steps: bool = false, jumps: bool = false, // This producer emits location rows whose labels and source excerpts may be styled. locations: bool = false, commands: bool = false, doc: bool = false, // Saving promotes this scratch buffer into an ordinary file. saves: bool = false, }; // Keep enum-dependent signatures out of the outer declaration walk. pub const registry = struct { /// Whether builtin `b` is one the live view's frontend takes: a window's /// own words (a builtin that says `in_window`, the settings a terminal /// cannot show) in a window's view alone. The rest of a build's words are /// every view's. pub fn here(p: *const Pardes, b: Builtin()) bool { return hereFor(b, viewCapabilities(p), !desktop or p.view().frontend.windowed); } /// `here` for a frontend of these capabilities, windowed or not. pub fn hereFor(b: Builtin(), caps: config.Runtime.Capabilities, windowed: bool) bool { inline for (comptime manualBuiltinList(), 0..) |T, i| if (@backingInt(b) == i) return !@hasDecl(T, "in_window") or windowed; inline for (comptime settingList(), comptime manualBuiltinList().len..) |setting, i| if (@backingInt(b) == i) return setting.enabled(caps); unreachable; } pub fn Builtin() type { // Duplicate-name validation compares every pair. @setEvalBranchQuota(200_000); const manual = manualBuiltinList(); const generated = settingList(); const count = manual.len + generated.len; const Tag = std.math.IntFittingRange(0, count - 1); var names: [count][]const u8 = undefined; for (manual, 0..) |T, i| names[i] = word(T); for (generated, manual.len..) |setting, i| names[i] = setting.word; for (names, 0..) |name, i| for (names[i + 1 ..]) |later| if (std.mem.eql(u8, name, later)) @compileError("duplicate builtin name: " ++ name); return @Enum(Tag, .exhaustive, &names, &std.simd.iota(Tag, count)); } /// What a hand-written builtin says as `name` (`pub const takes_arg = /// true;`), `default` when it says nothing, and `setting` for a setting. fn declOr(b: Builtin(), comptime name: []const u8, default: anytype, setting: @TypeOf(default)) @TypeOf(default) { inline for (comptime manualBuiltinList(), 0..) |T, i| if (@backingInt(b) == i) return if (@hasDecl(T, name)) @field(T, name) else default; return setting; } pub fn takesArg(b: Builtin()) bool { // Every setting takes its value, and a switch flips when bare. return declOr(b, "takes_arg", false, true); } /// Whether the word takes its argument joined by a `+` as one word a /// tag can hold and a click take whole (`Term+fish`). Only a builtin /// that says `pub const plus_arg = true;`: others have arguments a `+` /// may be in (`Dump+2024.zon` is a name, not Dump's argument). pub fn plusArg(b: Builtin()) bool { return declOr(b, "plus_arg", false, false); } /// Whether the word means nothing without its argument (`Mount`, /// `Msg`, a setting's value), or would ask for it at a prompt (`Find`): /// a ctl refuses it bare before any line of the write runs. A builtin /// says `pub const requires_arg = true;` beside `takes_arg`. /// The one kind of pane a builtin means something on, or null for any: /// it says `pub const needs: PaneKind = .terminal;`, and on any other /// pane it is refused (exec.runBuiltinFrom), as Repl and Edit are. pub fn needs(b: Builtin()) ?PaneKind { return declOr(b, "needs", @as(?PaneKind, null), null); } pub fn requiresArg(b: Builtin()) bool { inline for (comptime settingList(), comptime manualBuiltinList().len..) |setting, i| if (@backingInt(b) == i) return switch (setting.action) { // a switch flips bare, a choice steps, and DumpDir and Shell bare // are the default .toggle, .dump_dir, .choice, .shell => false, .theme, .font, .tagline_size, .window_opacity, .message_linger, .inactive_dim, .grip_width => true, // bare, it says the current value (exec.applySettingBuiltin) .tab, .callstack_depth => false, }; return declOr(b, "requires_arg", false, false); } pub fn scope(b: Builtin()) Scope { return declOr(b, "scope", Scope.pane, .session); } pub fn outputTraits(b: Builtin()) ?OutputTraits { return declOr(b, "output", @as(?OutputTraits, null), null); } /// Does this builtin say its own name on the message row before it runs? /// The ones that own that row themselves declare `quiet` and do not. pub fn announces(b: Builtin()) bool { // a setting builtin changes something invisible; say so return !declOr(b, "quiet", false, false); } pub fn dispatch(b: Builtin(), c: Ctx) void { inline for (comptime manualBuiltinList(), 0..) |T, i| if (@backingInt(b) == i) return T.run(c); inline for (comptime settingList(), comptime manualBuiltinList().len..) |setting, i| if (@backingInt(b) == i) return exec.applySettingBuiltin(c.p, setting, c.arg); unreachable; } }; test "capabilities exactly gate setting builtins" { const Builtin = registry.Builtin(); for (config.Runtime.settings) |setting| { const registered = std.meta.stringToEnum(Builtin, setting.word) != null; try std.testing.expectEqual(setting.enabled(capabilities), registered); } } test "a builtin's scope is the pane unless it says session, and every setting is the session's" { const Builtin = registry.Builtin(); try std.testing.expectEqual(Scope.pane, registry.scope(Builtin.Del)); try std.testing.expectEqual(Scope.pane, registry.scope(Builtin.Save)); try std.testing.expectEqual(Scope.session, registry.scope(Builtin.Newcol)); try std.testing.expectEqual(Scope.session, registry.scope(Builtin.Kill)); try std.testing.expectEqual(Scope.session, registry.scope(Builtin.Verbose)); for (comptime settingList()) |setting| try std.testing.expectEqual(Scope.session, registry.scope(std.meta.stringToEnum(Builtin, setting.word).?)); } test "Exit asks once about unsaved text, and quits when asked again" { const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true }); defer p.deinit(); const pane = try p.setTestFile("saved\n"); pane.file.?.saved_revision = pane.file.?.revision -% 1; // modified pane.file.?.saved_hash = 0; // edited: what it had is not what it has try std.testing.expect(p.executeBuiltinLine(p.view().active, "Exit")); try std.testing.expect(!p.quit); try std.testing.expect(std.mem.endsWith(u8, unsavedList(p), ": Modified\n\nExit again to discard\n")); // Told once, and nothing edited since: the second Exit quits. try std.testing.expect(p.executeBuiltinLine(p.view().active, "Exit")); try std.testing.expect(p.quit); } test "Exit over a ctl write or a click names every pane it asks about, a second only those edited since, and the next discards them all" { for ([_]bool{ false, true }) |clicked| { const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true }); defer p.deinit(); const first = try p.setTestFile("saved\n"); first.file.?.saved_revision = first.file.?.revision -% 1; first.file.?.saved_hash = 0; // edited: what it had is not what it has p.newScratchBelow(p.view().active); const second = p.panes[p.view().active].?; panes.File.setContent(p, &second.file.?, try std.testing.allocator.dupe(u8, &@as([120]u8, @splat('x')))); try std.testing.expect(second.file.?.revision != second.file.?.saved_revision); // A ctl write, or a click through exec (ctl.captured). if (clicked) p.fs.capturing = true else p.fs.no_prompt = true; defer p.fs.capturing = false; defer p.fs.no_prompt = false; try std.testing.expect(p.executeBuiltinLine(p.view().active, "Exit")); try std.testing.expect(!p.quit); // Two: counted, never a list cut short; `unsaved` records name them. try std.testing.expectEqualStrings("2 unsaved panes: Modified (Exit again to discard)", p.fs.failure[0..p.fs.failure_len]); const log = p.fs.log.buf.items; var rec: [64]u8 = undefined; for ([_]*const Pane{ first, second }) |pane| try std.testing.expect(std.mem.indexOf(u8, log, try std.fmt.bufPrint(&rec, "unsaved {d} ", .{pane.serial})) != null); // The whole list stays in +Unsaved; the notice is short. try std.testing.expect(std.mem.indexOf(u8, unsavedList(p), first.file.?.path) != null); try std.testing.expect(std.mem.endsWith(u8, unsavedList(p), "\nExit again to discard\n")); var noticed = false; for (p.panes) |slot| if (slot) |pane| { noticed = noticed or std.mem.eql(u8, pane.msg[0..pane.msg_len], "2 unsaved panes \u{2014} Exit again to discard"); }; try std.testing.expect(noticed); // Edited since: only that one is named again (acme's rule). p.fs.failure_len = 0; panes.File.setContent(p, &second.file.?, try std.testing.allocator.dupe(u8, &@as([120]u8, @splat('y')))); try std.testing.expect(p.executeBuiltinLine(p.view().active, "Exit")); try std.testing.expect(!p.quit); const again = p.fs.failure[0..p.fs.failure_len]; try std.testing.expect(std.mem.indexOf(u8, again, first.file.?.path) == null); // The one +Unsaved, filled again. var kept: usize = 0; for (p.panes) |slot| if (slot) |pane| if (pane.file) |f| if (f.output) |o| { kept += @intFromBool(o.from == .unsaved); }; try std.testing.expectEqual(@as(usize, 1), kept); try std.testing.expect(std.mem.indexOf(u8, unsavedList(p), first.file.?.path) == null); try std.testing.expect(std.mem.startsWith(u8, again, second.file.?.path)); p.fs.failure_len = 0; try std.testing.expect(p.executeBuiltinLine(p.view().active, "Exit")); try std.testing.expect(p.quit); } } /// What +Unsaved holds: the list a refusal over unsaved panes keeps. fn unsavedList(p: *Pardes) []const u8 { for (p.panes) |slot| if (slot) |pane| if (pane.file) |f| if (f.output) |o| if (o.from == .unsaved) return f.content; return ""; } /// A dump file that exists, for a Restore to get past reading it. fn testDump(buf: []u8) ![]const u8 { var tmp = std.testing.tmpDir(.{}); // A real dump: a Restore reads it through before it asks anything. const source = try Pardes.init(std.testing.allocator, .{ .tty_only = true }); defer source.deinit(); try pardes.dump.dumpState(source); try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "d.zon", .data = source.dump_out.? }); var dir: [4096]u8 = undefined; const at = dir[0..try tmp.dir.realPath(std.testing.io, &dir)]; return std.fmt.bufPrint(buf, "Restore {s}/d.zon", .{at}); } test "Restore asks about unsaved text as Exit does, and restores when asked again" { const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true }); defer p.deinit(); const pane = try p.setTestFile("saved\n"); pane.file.?.saved_revision = pane.file.?.revision -% 1; // modified pane.file.?.saved_hash = 0; // edited: what it had is not what it has var line_buf: [4200]u8 = undefined; const line = try testDump(&line_buf); try std.testing.expect(p.executeBuiltinLine(p.view().active, line)); try std.testing.expect(p.restore_req == null); try std.testing.expect(std.mem.endsWith(u8, unsavedList(p), ": Modified\n\nRestore again to discard\n")); try std.testing.expect(p.executeBuiltinLine(p.view().active, line)); try std.testing.expectEqualStrings(line["Restore ".len..], p.restore_req.?); } test "a Restore of a dump that cannot be read says so, before the unsaved-text warning" { const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true }); defer p.deinit(); const pane = try p.setTestFile("saved\n"); pane.file.?.saved_revision = pane.file.?.revision -% 1; // modified pane.file.?.saved_hash = 0; // edited: what it had is not what it has p.fs.no_prompt = true; defer p.fs.no_prompt = false; try std.testing.expect(p.executeBuiltinLine(p.view().active, "Restore /nope/missing.zon")); try std.testing.expect(p.restore_req == null); try std.testing.expectEqualStrings("Restore: /nope/missing.zon: no such file", p.fs.failure[0..p.fs.failure_len]); // No warning spent: the Exit after it still asks. try std.testing.expect(pane.discard_warned == null); } test "a Restore's warning is not an Exit's: each word is warned on its own" { const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true }); defer p.deinit(); const pane = try p.setTestFile("saved\n"); pane.file.?.saved_revision = pane.file.?.revision -% 1; // modified pane.file.?.saved_hash = 0; // edited: what it had is not what it has var line_buf: [4200]u8 = undefined; try std.testing.expect(p.executeBuiltinLine(p.view().active, try testDump(&line_buf))); try std.testing.expect(p.restore_req == null); // The Restore warned; an Exit after it has not been, and asks. try std.testing.expect(p.executeBuiltinLine(p.view().active, "Exit")); try std.testing.expect(!p.quit); try std.testing.expect(std.mem.endsWith(u8, unsavedList(p), ": Modified\n\nExit again to discard\n")); try std.testing.expect(p.executeBuiltinLine(p.view().active, "Exit")); try std.testing.expect(p.quit); } test "Kill stops the commands pardes typed, bare all and by name those that match, and never quits" { const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 24 }); defer p.deinit(); while (p.nextEffect()) |_| {} const term = p.view().active; try std.testing.expect(p.panes[term].?.isTerminal()); const prompt = "\x1b]133;A;cl=line;aid=pardes\x07$ \x1b]133;B;aid=pardes\x07"; p.update(.{ .output = .{ .pane = @intCast(term), .bytes = prompt } }); while (p.nextEffect()) |_| {} // The host the core asks: how many it was asked to stop, and whether // their shells run jobs in groups of their own. const killed = struct { var asked: usize = 0; var job_control = true; const vtable: pardes.Host.VTable = .{ .kill_job = answer }; fn answer(_: ?*anyopaque, _: u8) bool { asked += 1; return job_control; } fn count(pp: *Pardes, line: []const u8) usize { asked = 0; _ = pp.executeBuiltinLine(pp.view().active, line); return asked; } }; p.host = .{ .vtable = &killed.vtable }; // Nothing running: nothing to stop, and never the shell; said. try std.testing.expectEqual(@as(usize, 0), killed.count(p, "Kill")); try std.testing.expectEqualStrings("Kill: nothing running", p.panes[term].?.msg[0..p.panes[term].?.msg_len]); _ = exec.execute(p, term, "make -j8"); while (p.nextEffect()) |_| {} // Typed but not started yet (no C mark): not running. try std.testing.expectEqual(@as(usize, 0), killed.count(p, "Kill")); p.update(.{ .output = .{ .pane = @intCast(term), .bytes = "\x1b]133;C;aid=pardes\x07" } }); while (p.nextEffect()) |_| {} try std.testing.expectEqual(@as(usize, 0), killed.count(p, "Kill ls")); try std.testing.expectEqual(@as(usize, 1), killed.count(p, "Kill ls make")); try std.testing.expectEqual(@as(usize, 1), killed.count(p, "Kill")); try std.testing.expect(!p.quit); // With job control off there is no job apart from the shell: said, and // over ctl the write fails with it. killed.job_control = false; p.fs.no_prompt = true; try std.testing.expectEqual(@as(usize, 1), killed.count(p, "Kill")); try std.testing.expectStringStartsWith(p.fs.failure[0..p.fs.failure_len], "Kill: no job to signal"); p.fs.no_prompt = false; p.fs.failure_len = 0; killed.job_control = true; // Ended (a D mark): nothing to stop again. p.update(.{ .output = .{ .pane = @intCast(term), .bytes = "\x1b]133;D;143;aid=pardes\x07" ++ prompt } }); while (p.nextEffect()) |_| {} try std.testing.expectEqual(@as(usize, 0), killed.count(p, "Kill")); } test "Look does not announce itself on the message row; Del still does" { const Builtin = registry.Builtin(); try std.testing.expect(!registry.announces(Builtin.Look)); try std.testing.expect(registry.announces(Builtin.Del)); } // ---- the two acme verbs ---- /// Look at its argument: open the file or address it names, else find the word, as a right click does. pub const Look = struct { pub const takes_arg = true; pub const requires_arg = true; // a look's answer is the pane it opens or the place it jumps to; its own // name on the message row would only be noise over that pub const quiet = true; pub fn run(c: Ctx) void { // Bare (a key bound to it, a tag's Look with nothing held): the // selection, else what Enter on the cursor takes, the one expansion. const arg = c.arg orelse (exec.currentOperand(c.p, c.pane) orelse return); look.lookAt(c.p, c.id, arg); } }; /// Execute its argument as a middle click on it would, a builtin or a shell command. pub const Exec = struct { pub const takes_arg = true; pub const requires_arg = true; pub fn run(c: Ctx) void { // the destination pane is Look's business (it focuses what answered); // an execute deliberately leaves you where you were _ = exec.executeFrom(c.p, c.id, c.arg orelse return, c.from_body); } }; // ---- session ---- /// Which panes a refusal asks about: every one (Exit, Restore), one (Del), /// or a column's (Delcol). pub const Asked = union(enum) { all, pane: usize, column: usize }; /// acme's rowclean (editors/acme/wind.c:511-529, winclean), asked before /// what would throw unsaved text away: each pane holding some nobody has /// been told about is listed in +Unsaved, `: Modified`, under it /// `Exit again to discard`, with a short notice, `3 unsaved panes -- Exit /// again to discard`, /// naming the word asking, since repeating it throws the text away, and is /// then clean for the asking, as winclean clears `dirty`; so the same word /// again, with nothing edited since, goes ahead. Only the same word: a /// Restore a script was refused does not spend the warning an Exit owes /// the person at the keyboard. A scratch of under 100 bytes is no loss /// worth the question, as winclean does not ask for one. pub fn warnModifiedIn(c: Ctx, asking: Pane.Discarding, which: Asked) bool { // Every pane asked about is an `unsaved ` record, as // acme's rowclean names them all (wind.c:511); the refusal a write // gets names the one, or counts them, never a list cut short. var count: usize = 0; var one_buf: [limits.host_path_cap + 24]u8 = undefined; var one: []const u8 = ""; // The whole list goes into +Unsaved, where it stays; the notice is short. var listed: std.ArrayList(u8) = .empty; const arena = c.p.scratch.allocator(); for (c.p.panes, 0..) |slot, id| { const pane = slot orelse continue; switch (which) { .all => {}, .pane => |only| if (id != only) continue, .column => |col| if ((layout.findPane(c.p, id) orelse continue).col != col) continue, } const f = pane.file orelse continue; // Twins (Zerox) hold one text: closing one while another stays // loses nothing, and the text is asked about once. if (f.twin != 0) { const asked_elsewhere = for (c.p.panes, 0..) |other_slot, other_id| { const other = other_slot orelse continue; const of = other.file orelse continue; if (other_id == id or of.twin != f.twin) continue; const closing = switch (which) { .all => true, .pane => |only| other_id == only, .column => |col| if (layout.findPane(c.p, other_id)) |at| at.col == col else false, }; if (!closing or other_id < id) break true; } else false; if (asked_elsewhere) continue; } // A +New scratch saves nowhere, but what is typed in it is as lost; // under 100 bytes it is not asked about, as acme's winclean does not // whine about a small unnamed window, nor about a command's output. const scratch = if (f.output) |o| o.from == .cmd and o.from.cmd == .New else false; // A file deleted on disk is asked about, edited or not: its text is // nowhere else now (acme's winclean asks the same). const gone = f.disk_gone and f.output == null; if (!gone) { if (f.revision == f.saved_revision or !(panes.Output.fileTraits(f.output).saves or scratch)) continue; if (f.output != null and f.content.len < 100) continue; // Dirty by a rename alone is no text to lose, as get says (ctl.zig). // Nor is a buffer never edited at all: its first edit is what keeps // the text it had (File.zig), so with none there is nothing to lose. const saved = f.saved_hash orelse continue; if (std.hash.Wyhash.hash(0, f.content) == saved) continue; } if (pane.discard_warned) |w| if (w.revision == f.revision and w.by == asking) continue; pane.discard_warned = .{ .revision = f.revision, .by = asking }; // Scratches share a name: each is named with its pane's serial too, // `/dir/+New (pane 12)`, the same in every refusal (Exit, Restore, // Del, Delcol). var name_buf: [limits.host_path_cap + 24]u8 = undefined; const name = if (scratch) std.fmt.bufPrint(&name_buf, "{s} (pane {d})", .{ f.path, pane.serial }) catch f.path else f.path; pardes.ctlfs.events.noteLog(c.p, .unsaved, pane); listed.print(arena, "{s}: Modified\n", .{name}) catch {}; if (count == 0) one = std.fmt.bufPrint(&one_buf, "{s}", .{name}) catch name; count += 1; } if (count > 0) { listed.print(arena, "\n{s} again to discard\n", .{@tagName(asking)}) catch {}; // A refused Delcol changes nothing, the layout included: its records // and its notice say it, and no +Unsaved opens. if (asking != .Delcol) if (c.p.gpa.dupe(u8, listed.items)) |content| panes.Output.openUnsaved(c.p, c.id, content) else |_| {}; var short: pardes.Kind.Buf(96) = .{}; c.p.reportFailure(c.id, short.print("{d} unsaved pane{s} \u{2014} {s} again to discard", .{ count, if (count == 1) "" else "s", @tagName(asking) })); } if (count > 0 and (c.p.fs.no_prompt or c.p.fs.capturing)) { var said_buf: pardes.Kind.Buf(limits.host_path_cap + 96) = .{}; const said = if (count == 1) said_buf.print("{s}: Modified ({s} again to discard)", .{ one, @tagName(asking) }) else said_buf.print("{d} unsaved panes: Modified ({s} again to discard)", .{ count, @tagName(asking) }); var room: @TypeOf(c.p.fs.failure) = undefined; const kept = pardes.ctlfs.fitErr(said, &room); @memcpy(c.p.fs.failure[0..kept.len], kept); c.p.fs.failure_len = @intCast(kept.len); } return count > 0; } /// Quit the editor, refusing once while a pane holds unsaved text: an Exit /// with nothing edited since discards it (acme's Exit, editors/acme/exec.c:892, /// asking warnModified first). pub const Exit = struct { pub const scope: Scope = .session; pub fn run(c: Ctx) void { if (warnModifiedIn(c, .Exit, .all)) return; c.p.quit = true; c.p.emit(.quit); } }; /// acme's Kill (exec.c, `kill`; acme.c's WKill): stop the commands pardes /// started -- the lines it typed into a terminal, from an exec, a middle /// click or a pty/run, while their shell says they run (C mark to D). /// Bare, every one; `Kill make ls`, those whose line starts with one of /// the words. acme posts the "kill" note, which ends a process; here that /// is SIGTERM to the terminal's foreground job, and never to the shell, /// which is its own job and stays. pub const Kill = struct { pub const scope: Scope = .session; pub const takes_arg = true; pub fn run(c: Ctx) void { const names = std.mem.trim(u8, c.arg orelse "", " \t\r\n"); var stopped = false; var jobless = false; var running = false; for (c.p.panes, 0..) |slot, id| { const pane = slot orelse continue; const command: ?[]const u8 = if (pane.command) |line| (if (pane.command_done) null else line) else null; if (command == null and !panes.terminal.commandRunning(pane)) continue; running = true; const first = if (command) |line| first: { const said = std.mem.trim(u8, line, " \t"); break :first said[0 .. std.mem.indexOfAny(u8, said, " \t") orelse said.len]; } else pane.sent_command.?.word[0..pane.sent_command.?.len]; if (names.len > 0) { var words = std.mem.tokenizeAny(u8, names, " \t"); while (words.next()) |w| { if (std.mem.eql(u8, w, first)) break; } else continue; } // A command pane's child is the command: the whole of its // process group goes, as acme's Kill ends the process. A // terminal's job is asked of the host now, not queued: the job // the marks say is running is the one signalled, not whatever // runs by then. if (command != null) { c.p.emit(.{ .signal_pty = .{ .pane = @intCast(id), .serial = pane.serial, .sig = .term } }); stopped = true; } else if (c.p.hostKillJob(id)) stopped = true else jobless = true; } if (stopped) return; if (jobless) return c.p.reportFailure(c.id, "Kill: no job to signal (its shell runs it without job control)"); // Said, but no failure: a script's Kill, named or not, has nothing // left to do. Only commands running, none of them the one named, is. if (names.len > 0 and running) c.p.reportFailure(c.id, "Kill: no running command has that first word") else c.p.setMessage(c.id, "Kill: nothing running"); } }; /// Write the session's panes and layout to the state file, for Restore; /// `Dump export ` writes them to a file of their own instead. pub const Dump = struct { pub const scope: Scope = .session; pub const takes_arg = true; pub fn run(c: Ctx) void { var to: ?[]const u8 = null; if (c.arg) |arg| { const trimmed = std.mem.trim(u8, arg, " \t"); if (!std.mem.startsWith(u8, trimmed, "export ")) return c.p.reportFailure(c.id, "Dump: takes export , or nothing"); const path = std.mem.trim(u8, trimmed["export".len..], " \t"); if (path.len == 0) return c.p.reportFailure(c.id, "Dump: takes export , or nothing"); to = path; } // Never a Dump said done that wrote nothing: its failure is said. dump.dumpTo(c.p, to) catch |err| c.p.reportError(c.id, "Dump", err); } }; /// Replace every pane with those of a dump: the state file's of that label, /// or a file's; bare, the last one this session made, else the newest. pub const Restore = struct { pub const scope: Scope = .session; pub const takes_arg = true; pub fn run(c: Ctx) void { const typed: ?[]const u8 = c.arg orelse c.p.last_dump; // A file it names, its whole path (`~`, the DumpDir, the directory // it runs in): what the log's `restore` record and every message // name. Else a label of the state file's. var full_buf: [4096]u8 = undefined; var label_buf: [256]u8 = undefined; const file = if (typed) |t| dump.restoreFile(t, c.p.settings.dump_dir.get(), &full_buf) else null; const name = if (file) |path| path else pardes.tape.authority(pardes.Db.labelled, .{ &c.p.db, c.p, typed, @as([]u8, &label_buf) }) orelse { var buf: pardes.Kind.Buf(320) = .{}; return c.p.reportFailure(c.id, if (typed) |t| buf.print("Restore: no dump labelled {s}", .{t}) else "Restore: no dump yet; name one"); }; if (name.len > c.p.restore_buf.len) return c.p.reportFailure(c.id, "Restore: that name is too long"); // A file that cannot be read is said now, and fails a ctl write: // the host reads it only after this step, where nobody hears. // First, so a Restore that could never happen spends no warning. if (file) |path| { const bytes = @import("fs.zig").readFile(c.p.gpa, path) catch |err| { var buf: pardes.Kind.Buf(limits.host_path_cap + 160) = .{}; var words: [128]u8 = undefined; const why = switch (err) { error.FileNotFound => "no such file", error.PermissionDenied => "permission denied", error.IsDirectory => "a directory, not a dump", else => pardes.Messages.errorWords(err, &words), }; return c.p.reportFailure(c.id, buf.print("Restore: {s}: {s}", .{ path[0..@min(path.len, limits.host_path_cap)], why })); }; defer c.p.gpa.free(bytes); // Nor does a file that is not a dump, before any warning. var why_buf: [256]u8 = undefined; pardes.dump.check(c.p.gpa, bytes, &why_buf) catch |err| { var buf: pardes.Kind.Buf(limits.host_path_cap + 320) = .{}; const why = if (err == error.OutOfMemory) pardes.Messages.errorWords(err, &why_buf) else why_buf[0..std.mem.indexOfScalar(u8, &why_buf, 0).?]; return c.p.reportFailure(c.id, buf.print("Restore: {s}: not a pardes dump: {s}", .{ path[0..@min(path.len, limits.host_path_cap)], why })); }; } // acme's Load adds a dump's windows to the ones there; a Restore // replaces them all, so it asks what Exit asks first. if (warnModifiedIn(c, .Restore, .all)) return; @memcpy(c.p.restore_buf[0..name.len], name); c.p.restore_req = c.p.restore_buf[0..name.len]; } }; /// Detach this pardes from its terminal or window, leaving the session /// running: `pardes --attach` (or `pardes-gui --attach`) takes it back. pub const Detach = struct { pub const scope: Scope = .session; pub const enabled = pardes.can_attach; pub fn run(c: Ctx) void { c.p.emit(.{ .detach = .{ .pane = @intCast(c.id) } }); } }; /// Take in the shells of a session that died holding them, each as a /// terminal pane here: the pardes daemon kept their terminals open. pub const Adopt = struct { pub const scope: Scope = .session; pub const enabled = pardes.can_attach; pub fn run(c: Ctx) void { const adopt = c.p.host.vtable.adopt orelse return c.p.reportFailure(c.id, "Adopt: no pardes daemon is keeping shells for this session"); adopt(c.p.host.ctx, @intCast(c.id)); } }; /// Move this session onto the pardes installed since it started, in place: /// its text, undo, views, terminals with their running shells, and its /// terminals and windows come along. The pardes daemon moves too. pub const Upgrade = struct { pub const scope: Scope = .session; pub const enabled = pardes.can_attach; pub fn run(c: Ctx) void { const upgrade = c.p.host.vtable.upgrade orelse return c.p.reportFailure(c.id, "Upgrade: this pardes cannot move to another build in place"); upgrade(c.p.host.ctx, @intCast(c.id)); } }; /// Mount another pardes's 9P tree under /n/, given its dial address. pub const Mount = struct { pub const scope: Scope = .session; pub const takes_arg = true; pub const requires_arg = true; pub fn run(c: Ctx) void { var args = std.mem.tokenizeAny(u8, c.arg orelse "", " \t"); const e_args = "wrong #args in control message \"Mount\": Mount name dial"; const name = args.next() orelse return c.p.reportFailure(c.id, e_args); const dial = std.mem.trim(u8, args.rest(), " \t"); if (dial.len == 0) return c.p.reportFailure(c.id, e_args); c.p.fs.mount(c.p.gpa, name, dial) catch |err| { var said: pardes.Kind.Buf(200) = .{}; if (err == error.BadDial) return c.p.reportFailure(c.id, said.print("Mount: bad dial address: {s} (unix!/path, /path, tcp!!, or a session name)", .{dial[0..@min(dial.len, 100)]})); return c.p.reportError(c.id, "Mount", err); }; // A socket path that is not there: said so (ENOENT), not a dial // that went unanswered. const sock_path: ?[]const u8 = if (std.mem.startsWith(u8, dial, "unix!")) dial[5..] else if (dial.len > 0 and dial[0] == '/') dial else null; if (sock_path) |path| if (@import("exec.zig").kindOf(path) == null) { if (c.p.fs.mounts.pop()) |gone| { c.p.gpa.free(gone.name); c.p.gpa.free(gone.dial); } var said: pardes.Kind.Buf(200) = .{}; return c.p.reportFailure(c.id, said.print("Mount {s}: {s}: no such socket", .{ name[0..@min(name.len, 32)], path[0..@min(path.len, 100)] })); }; // A mount that cannot be reached is said now, and taken back, not // found out by the first look through it. const reached = pardes.tape.site(.probe, null, @import("9p_io.zig").Client.probeMount, .{ c.p.gpa, dial }); reached catch |err| { if (c.p.fs.mounts.pop()) |gone| { c.p.gpa.free(gone.name); c.p.gpa.free(gone.dial); } var what: pardes.Kind.Buf(160) = .{}; return c.p.reportError(c.id, what.print("Mount {s} {s}", .{ name[0..@min(name.len, 32)], dial }), err); }; } }; /// Unmount the 9P tree mounted under /n/. pub const Unmount = struct { pub const scope: Scope = .session; pub const takes_arg = true; pub const requires_arg = true; pub fn run(c: Ctx) void { var args = std.mem.tokenizeAny(u8, c.arg orelse "", " \t"); const name = args.next() orelse return c.p.reportError(c.id, "Unmount name", error.MissingArgument); if (args.next() != null) return c.p.reportError(c.id, "Unmount name", error.TooManyArguments); pardes.filesystem.unmount(c.p, name) catch |err| { // "no such": the words 9ns reads as ENOENT. if (err == error.NotMounted) { var said: pardes.Kind.Buf(96) = .{}; return c.p.reportFailure(c.id, said.print("Unmount: no such mount {s}", .{name})); } return c.p.reportError(c.id, "Unmount", err); }; } }; // ---- the message row ---- /// Show its argument on this pane's message row. pub const Msg = struct { pub const takes_arg = true; pub const requires_arg = true; pub const quiet = true; // it IS the message row pub fn run(c: Ctx) void { if (c.arg) |text| c.p.setMessage(c.id, text) else c.p.reportError(c.id, comptime word(@This()), error.NoMessage); } }; /// Switch to the next bundled theme. pub const NextColor = struct { pub const scope: Scope = .session; pub fn run(c: Ctx) void { colors.setThemeIndex(c.p, (@as(usize, c.p.settings.theme) + 1) % pardes.themes.len); } }; /// List the themes in a pane, each a word to click. pub const Themes = struct { pub const scope: Scope = .session; pub const output: OutputTraits = .{ .name = config.themes_buffer, .steps = true, .commands = true }; pub fn run(c: Ctx) void { panes.Output.openThemes(c.p, c.id) catch |err| c.p.reportError(c.id, "themes", err); } }; /// Load a theme from a file. pub const ThemeFile = struct { pub const scope: Scope = .session; pub const takes_arg = true; pub const requires_arg = true; pub fn run(c: Ctx) void { var home_buf: [4096]u8 = undefined; const arg = pardes.filesystem.expandHome(std.mem.trim(u8, c.arg orelse return, " \t\r\n"), &home_buf); // Said with why, not "invalid theme path". if (!std.mem.endsWith(u8, arg, ".zon")) { var said: pardes.Kind.Buf(320) = .{}; return c.p.reportFailure(c.id, said.print("ThemeFile: {s}: invalid theme path: a theme file is a .zon (DumpThemes writes some to start from)", .{arg[0..@min(arg.len, 200)]})); } colors.requestThemeFile(c.p, c.id, arg); } }; /// Write the bundled themes into the config directory's themes, to edit. pub const DumpThemes = struct { pub const scope: Scope = .session; pub fn run(c: Ctx) void { if (c.p.configDir() == null) { c.p.reportError(c.id, "dump themes", error.NoConfigDirectory); return; } c.p.emit(.{ .dump_themes = .{ .pane = @intCast(c.id) } }); } }; /// List the fonts in a pane, each a word to click. pub const Fonts = struct { pub const scope: Scope = .session; pub const output: OutputTraits = .{ .name = config.fonts_buffer, .steps = true, .commands = true }; pub const enabled = capabilities.font_picker; pub const gui_only = true; pub const in_window = true; pub fn run(c: Ctx) void { panes.Output.openFonts(c.p, c.id) catch |err| c.p.reportError(c.id, "fonts", err); } }; /// Show the declarations enclosing the top row at the pane's head, on or off. pub const TreeContext = struct { pub const enabled = pardes.syntax.enabled; pub const takes_arg = true; pub fn run(c: Ctx) void { if (comptime !enabled) unreachable; if (!panes.File.supportsContext(c.pane)) return c.p.reportFailure(c.id, "TreeContext: only a source file the parser knows has context"); const file = &c.pane.file.?; const arg = std.mem.trim(u8, c.arg orelse "", " \t\r\n"); const on = if (arg.len == 0) !file.tree_context else if (std.mem.eql(u8, arg, "on")) true else if (std.mem.eql(u8, arg, "off")) false else { c.p.reportError(c.id, "TreeContext", error.ExpectedOnOrOff); return; }; file.tree_context = on; file.syntax_dirty = true; c.pane.geometry_key = 0; c.p.surface.body_layers[c.id].rows = 0; } }; /// A toggle's argument, when it has one: the state its tag word names, /// set rather than flipped. Null runs no step and says what it takes. fn stateArg(c: Ctx, comptime T: type, comptime builtin_word: []const u8, comptime takes: []const u8) ?T { const a = std.mem.trim(u8, c.arg orelse return null, " \t"); return std.meta.stringToEnum(T, a) orelse { var said: pardes.Kind.Buf(128) = .{}; c.p.reportFailure(c.id, said.print("invalid argument: " ++ builtin_word ++ " takes " ++ takes ++ ", not \"{s}\"", .{a[0..@min(a.len, 32)]})); return null; }; } const OnOff = enum { on, off }; /// Addons, the libraries that bring kinds of pane: `Addon load `, /// `Addon unload `, `Addon reload `; bare, the kinds here. pub const Addon = struct { pub const scope: Scope = .session; pub const takes_arg = true; pub fn run(c: Ctx) void { pardes.Addon.run(c.p, c.id, c.arg); } }; /// glyph art over the host's pixels: an image pane's picture, or the /// kitty graphics a terminal's program placed (yazi's previews) pub const Petscii = struct { pub const needs: PaneKind = .picture; pub const takes_arg = true; pub fn run(c: Ctx) void { // `on|off` sets it, as the tag's `petscii:on` reads; none flips it. const now = if (c.pane.addon) |k| k.art.glyph else panes.terminal.petscii(c.pane) orelse false; if (c.arg != null) { const want = stateArg(c, OnOff, "Petscii", "on or off") orelse return; if ((want == .on) == now) return; } if (c.pane.addon) |k| k.art.glyph = !k.art.glyph; panes.terminal.togglePetscii(c.pane); } }; /// the C64 palette or the terminal's own 16 pub const Palette = struct { pub const needs: PaneKind = .image; pub const takes_arg = true; pub fn run(c: Ctx) void { const art = &(c.pane.addon orelse return).art; if (c.arg != null) { const want = stateArg(c, pardes.Placement.Art.Palette, "Palette", "commodore or terminal") orelse return; if (want == art.palette) return; } art.palette = if (art.palette == .commodore) .terminal else .commodore; } }; /// add the printable ASCII bitmaps to the matcher's glyph set pub const Ascii = struct { pub const needs: PaneKind = .image; pub const takes_arg = true; pub fn run(c: Ctx) void { const art = &(c.pane.addon orelse return).art; if (c.arg != null) { const want = stateArg(c, OnOff, "Ascii", "on or off") orelse return; if ((want == .on) == art.ascii) return; } art.ascii = !art.ascii; } }; // ---- the system clipboard ---- /// Copy the selection to the system clipboard. pub const ClipYank = struct { pub fn run(c: Ctx) void { edit.clipYank(c.p, c.pane, false); } }; /// helix `Y`: the PRIMARY selection alone, where `SPC y` joins every /// cursor's. One cursor makes them the same word. pub const ClipYankMain = struct { pub fn run(c: Ctx) void { edit.clipYank(c.p, c.pane, true); } }; /// Paste the system clipboard after the selection. pub const ClipPaste = struct { pub fn run(c: Ctx) void { edit.clipRequest(c.p, c.id, .after); } }; /// Paste the system clipboard before the selection. pub const ClipPasteBefore = struct { pub fn run(c: Ctx) void { edit.clipRequest(c.p, c.id, .before); } }; /// Replace the selection with the system clipboard. pub const ClipReplace = struct { pub fn run(c: Ctx) void { edit.clipRequest(c.p, c.id, .replace); } }; // ---- panes and columns ---- /// acme's Get: the pane's file read again, its unsaved edits refused once /// as Del refuses them. `Get file` loads that file into the pane instead, /// the pane taking its name. pub const Get = struct { pub const takes_arg = true; pub fn run(c: Ctx) void { const ctl = @import("ninep/ctl.zig"); if (@import("edit_cmd.zig").busyOn(c.p, c.id)) return c.p.reportFailure(c.id, "Get: " ++ @import("edit_cmd.zig").e_busy); const f = if (c.pane.file) |*file| file else return c.p.reportFailure(c.id, "Get: only a file pane takes it"); const typed = std.mem.trim(u8, c.arg orelse "", " \t\r\n"); // A directory pane: the directory read again (Dir.zig), as acme's // Get is in a directory window; a file is a Look's from there. if (f.listing != null) { if (typed.len > 0) return c.p.reportFailure(c.id, "Get: a directory pane reads its directory; a Look at the file opens it"); 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 // edits are asked about: there would be nothing to load over them. if (typed.len > 0) if (@import("fs.zig").localPath(path)) |local| { var said: pardes.Kind.Buf(320) = .{}; const kind = exec.kindOf(local); if (kind == null or kind.? == .directory) 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) { 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); c.p.reportFailure(c.id, said.print("Get: {s}: {s}", .{ path[0..@min(path.len, 256)], why })); } } }; /// acme's Putall: every pane holding unsaved edits to a file is saved, each /// as its own Save; one that is refused (changed on disk since, a write /// that fails) says so and the rest are saved all the same. pub const Putall = struct { pub const scope: Scope = .session; pub fn run(c: Ctx) void { for (c.p.panes, 0..) |slot, id| { const pane = slot orelse continue; const f = pane.file orelse continue; if (f.output != null or f.listing != null or f.revision == f.saved_revision) continue; // A Zerox pair is one buffer: saved once, by its first pane. if (f.twin != 0) if (for (c.p.panes[0..id]) |earlier| { if ((earlier orelse continue).file) |ef| if (ef.twin == f.twin) break true; } else false) continue; exec.saveFile(c.p, id); } } }; /// acme's Incl, for the session: `Incl dir ...` adds directories a look at a /// name found nowhere else is tried in (`stdio.h`, ``), bare lists /// them, `Incl -` empties the list. pub const Incl = struct { pub const scope: Scope = .session; pub const takes_arg = true; pub fn run(c: Ctx) void { const p = c.p; const typed = std.mem.trim(u8, c.arg orelse "", " \t\r\n"); if (std.mem.eql(u8, typed, "-")) { for (p.incl.items) |dir| p.gpa.free(dir); p.incl.clearRetainingCapacity(); return p.setMessage(c.id, "Incl: none"); } // All checked before any is taken: `-` clears, alone; a directory // is absolute (or ~) and there. var check = std.mem.tokenizeAny(u8, typed, " \t"); while (check.next()) |dir_word| { var said: pardes.Kind.Buf(320) = .{}; const shown = dir_word[0..@min(dir_word.len, 200)]; if (std.mem.eql(u8, dir_word, "-")) return p.reportFailure(c.id, "Incl: invalid: - clears the list, alone"); if (dir_word[0] != '/' and dir_word[0] != '~') return p.reportFailure(c.id, said.print("Incl: invalid directory: {s} is relative", .{shown})); var home_buf: [4096]u8 = undefined; const expanded = @import("fs.zig").expandHome(dir_word, &home_buf); if (@import("fs.zig").localPath(expanded)) |local| if (exec.kindOf(local) != .directory) return p.reportFailure(c.id, if (exec.kindOf(local) != null) said.print("Incl: not a directory: {s}", .{shown}) else said.print("Incl: no such directory: {s}", .{shown})); } var words = std.mem.tokenizeAny(u8, typed, " \t"); while (words.next()) |dir_word| { var home_buf: [4096]u8 = undefined; const full = std.Io.Dir.path.resolvePosix(p.scratch.allocator(), &.{ Pardes.paneDir(c.pane), @import("fs.zig").expandHome(dir_word, &home_buf) }) catch |err| return p.reportError(c.id, "Incl", err); if (!std.Io.Dir.path.isAbsolute(full)) return p.reportFailure(c.id, "Incl: invalid directory"); 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); } } if (typed.len > 0) return; var list: std.Io.Writer.Allocating = .init(p.scratch.allocator()); list.writer.writeAll("Incl:") catch |err| return p.reportError(c.id, "Incl", err); for (p.incl.items) |dir| list.writer.print(" {s}", .{dir}) catch |err| return p.reportError(c.id, "Incl", err); if (p.incl.items.len == 0) list.writer.writeAll(" none") catch |err| return p.reportError(c.id, "Incl", err); p.setMessage(c.id, list.written()); } }; /// The plumber's rules, for the session, one a line as plumb(6) orders a /// rule: `Plumb suffix .svg to image` makes a look at an existing `.svg` /// file an image pane. The user's rules are tried in the order given, /// before the built-in ones, and the first that matches takes the look. /// Bare, it lists them; `Plumb -` empties the list. pub const Plumb = struct { pub const scope: Scope = .session; pub const takes_arg = true; pub fn run(c: Ctx) void { const p = c.p; const typed = std.mem.trim(u8, c.arg orelse "", " \t\r\n"); if (std.mem.eql(u8, typed, "-")) { for (p.plumb.items) |rule| p.gpa.free(rule); p.plumb.clearRetainingCapacity(); return p.setMessage(c.id, "Plumb: none"); } if (typed.len > 0) { var said: [320]u8 = undefined; if (look.plumbRuleError(&p.kinds, typed)) |why| 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; 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); } const owned = rule.toOwnedSlice(p.gpa) catch return rule.deinit(p.gpa); p.plumb.append(p.gpa, owned) catch return p.gpa.free(owned); 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; p.setMessage(c.id, list.written()); } }; /// acme's Zerox: a second pane on this pane's file, the same text, undo and /// unsaved state, with a scroll and a cursor of its own (File.zerox). pub const Zerox = struct { pub fn run(c: Ctx) void { if (@import("edit_cmd.zig").busyOn(c.p, c.id)) return c.p.reportFailure(c.id, "Zerox: " ++ @import("edit_cmd.zig").e_busy); const f = c.pane.file orelse return c.p.reportFailure(c.id, "Zerox: only a file pane takes it"); if (f.output != null or f.listing != null or f.mini != null) return c.p.reportFailure(c.id, "Zerox: only a file pane takes it"); const free = c.p.freeSlot() orelse return c.p.reportError(c.id, "Zerox", error.NoPaneSlots); _ = panes.File.zerox(c.p, c.id, free) catch |err| return c.p.reportError(c.id, "Zerox", err); exec.placeNew(c.p, c.id, c.id, free, .doc); } }; /// Write the pane's text to its file, or to the file its argument names. pub const Save = struct { pub const takes_arg = true; pub fn run(c: Ctx) void { // A kind's pane (an image, a PDF) shows a file it does not hold as // text: there is nothing of its own to write, bare or to a path. // Said, never a silent success. if (c.pane.file == null and !c.pane.isTerminal()) { const kind = if (c.pane.addon) |k| k.nameOf() else ""; var said: pardes.Kind.Buf(64) = .{}; return c.p.reportFailure(c.id, said.print("Save: a{s} {s} pane has no text to save", .{ if (kind.len > 0 and std.mem.indexOfScalar(u8, "aeiou", kind[0]) != null) "n" else "", kind[0..@min(kind.len, 16)] })); } // A directory's listing is no file to write, bare or to a path, as // acme's Put does nothing in a directory window. if (c.pane.file) |file| if (file.listing != null) { var said: pardes.Kind.Buf(limits.host_path_cap + 48) = .{}; return c.p.reportFailure(c.id, said.print("Save: {s} is a directory", .{file.path[0..@min(file.path.len, limits.host_path_cap)]})); }; const path = std.mem.trim(u8, c.arg orelse "", " \t\r\n"); if (path.len > 0) return exec.saveTo(c.p, c.id, path); // A `+` name is a generated pane's (+Tutor), no file of its own: // a bare Save asks for a path, as a +New scratch's does. if (c.pane.file) |file| if (file.output == null and !std.mem.startsWith(u8, std.Io.Dir.path.basename(file.path), "+")) return exec.saveFile(c.p, c.id); if (c.pane.file != null or c.pane.isTerminal()) panes.startPrompt(c.p, c.pane, &c.pane.body, .save); } }; /// Open an empty scratch pane, /+New, in this pane's directory. pub const New = struct { pub const output: OutputTraits = .{ .name = config.scratch_buffer, .doc = true, .saves = true }; pub fn run(c: Ctx) void { c.p.newScratchBelow(c.id); } }; /// An empty column right of the keyboard's, its tag taking the keyboard. pub const Newcol = struct { pub const scope: Scope = .session; pub fn run(c: Ctx) void { layout.newColumn(c.p, c.id); } }; /// Close the pane. `Del k` gives its rows to the open pane above it and /// `Del j` to the one below, each falling back to the other side. Focus on /// it goes with its rows. pub const Del = struct { pub const takes_arg = true; pub fn run(c: Ctx) void { const side = std.mem.trim(u8, c.arg orelse "", " \t\r\n"); if (@import("edit_cmd.zig").busyOn(c.p, c.id)) return c.p.reportFailure(c.id, "Del: " ++ @import("edit_cmd.zig").e_busy); // acme's Del asks winclean first (exec.c del): unsaved text is warned // about once, and the same Del again, nothing edited since, closes. if (warnModifiedIn(c, .Del, .{ .pane = c.id })) return; // An attachment's rows go back to its owner: nothing to ask. if (layout.ownerOf(c.p, c.id)) |owner| return c.p.removePane(c.id, owner) catch |err| c.p.reportError(c.id, "close", err); const at = layout.findPane(c.p, c.id); const above = if (at) |f| layout.expandedNeighbor(c.p, f.col, f.idx, .above) else null; // An owner's attachments close with it: below is past them. const below = if (at) |f| layout.expandedNeighbor(c.p, f.col, layout.groupEnd(c.p, f.col, f.idx) - 1, .below) else null; const to: ?usize = if (std.mem.eql(u8, side, "k")) above orelse below else if (std.mem.eql(u8, side, "j")) below orelse above else if (side.len > 0) return c.p.reportFailure(c.id, "Del: takes k, j or nothing") else null; // Someone at the keyboard with a real choice to make is asked, on the // pane's notice band; a click, a 9P write or a script closes it the // way it always has. A folded pane gives back only its tag row, and a // pane with a prompt open closes as it did rather than trade the // prompt for a question. if (side.len == 0 and c.p.can_ask and above != null and below != null and !c.pane.collapsed and c.pane.prompt == .none) { c.pane.prompt = .del_side; c.pane.question_due_ns = exec.clockNow(c.p) + config.del_question_delay_ns; c.p.view().active = c.id; var rec: [32]u8 = undefined; pardes.ctlfs.events.notePath(c.p, "ask", std.fmt.bufPrint(&rec, "{d} del k j", .{c.pane.serial}) catch unreachable); // a u32 fits 32 // The question says Del already. if (c.pane.msg_announcement) c.pane.msg_len = 0; return; } c.p.removePane(c.id, to) catch |err| return c.p.reportError(c.id, "close", err); } }; /// Recolour a terminal's or a +Pager's program colours to the theme, or show them as sent, flipping between them. pub const Filter = struct { pub const needs: PaneKind = .program_colors; pub fn run(c: Ctx) void { c.pane.tty_filter = !c.pane.tty_filter; } }; /// Stack a diff's hunks as a diff viewer shows them, each under its place and the declarations around it, in a +Diff; on a +Diff, show the diff itself as text. pub const Diff = struct { pub const needs: PaneKind = .diff; pub const output: OutputTraits = .{ .name = config.diff_buffer, .steps = true, .locations = true }; pub fn run(c: Ctx) void { const f = &c.pane.file.?; if (panes.Output.diffSource(c.p, f)) |source| return panes.Output.showDiffText(c.p, c.id, source); _ = panes.Output.openDiff(c.p, c.id, f.path, f.content) catch |err| switch (err) { error.NoHunks => c.p.reportFailure(c.id, "Diff: no hunk in it"), else => c.p.reportError(c.id, "hunks", err), }; } }; /// Cycle the pane's input modes: terminals add raw tty mode to normal/insert. pub const Mode = struct { pub fn run(c: Ctx) void { if (c.pane.file == null and !c.pane.isTerminal()) return c.p.reportFailure(c.id, "Mode: only a text or terminal pane has modes"); keys.cycleMode(c.p, c.id); } }; /// Switch this terminal between raw program input and normal editor mode. pub const Togglettymode = struct { pub const needs: PaneKind = .terminal; pub fn run(c: Ctx) void { keys.toggleTty(c.p, c.id); } }; /// acme's Edit (exec.c `edit`, edit.c): sam's command language over the /// open text panes, from a tag, a pane ctl or exec, starting in the pane's /// body. One undo step in each file it changes; a failure changes nothing /// and says why. src/edit_cmd.zig runs it; src/sam_edit.zig has what is /// left out. pub const Edit = struct { pub const takes_arg = true; pub const requires_arg = true; pub fn run(c: Ctx) void { @import("edit_cmd.zig").run(c.p, c.id, c.arg orelse ""); } }; /// acme's Undo and Redo (exec.c `undo`): step the pane's body back or /// forward through its edits, from a tag, a pane ctl or exec. /// With no step left, Undo and Redo say so and change nothing; a ctl write /// of them still succeeds, as acme's Undo is silent there. A file keeps /// limits.undo_max steps (256). 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); } }; /// Redo the last undone edit. 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); } }; /// Fold a pane to its tag, or restore its share of the column. pub const Collapse = struct { pub fn run(c: Ctx) void { layout.toggleCollapse(c.p, c.id); } }; /// Unattach a pane from the pane it answers for: it stays where it is, a /// pane of its own, and the next search from that pane opens another /// under it. pub const Unattach = struct { pub fn run(c: Ctx) void { if (c.pane.attached_to == null) return c.p.reportFailure(c.id, "Unattach: not attached to a pane"); c.pane.attached_to = null; } }; /// Close this column and its panes, refusing once over unsaved text. pub const Delcol = struct { pub fn run(c: Ctx) void { // The column of the tag it came from, else the pane's: a pane ctl's // Delcol closes that pane's column wherever the keyboard is. const col = c.p.exec_column orelse (layout.findPane(c.p, c.id) orelse return).col; // acme's Delcol refuses a column with unsaved text (exec.c delcol, // cols.c colclean), once: the next Delcol closes it. if (warnModifiedIn(c, .Delcol, .{ .column = col })) return; layout.removeColumn(c.p, col) catch |err| c.p.reportError(c.id, "close column", err); } }; /// Close the pane, giving its rows to the pane above it. pub const DelAbove = struct { pub fn run(c: Ctx) void { Del.run(.{ .p = c.p, .pane = c.pane, .id = c.id, .txt = c.txt, .arg = "k" }); } }; /// Close the pane, giving its rows to the pane below it. pub const DelBelow = struct { pub fn run(c: Ctx) void { Del.run(.{ .p = c.p, .pane = c.pane, .id = c.id, .txt = c.txt, .arg = "j" }); } }; /// A shell in the calling pane's directory, raw from the first frame. On every /// pane's tagline: the fast path from wherever you are to a prompt there. /// A terminal below the caller in its directory: the configured shell, or /// the one named, `Term fish`, as a terminal's own tag word `Term+fish` says. pub const Term = struct { pub const takes_arg = true; pub const plus_arg = true; pub fn run(c: Ctx) void { const arg = std.mem.trim(u8, c.arg orelse "", " \t"); // A shell that is not there is said, where the host would quietly // start its fallback in its place. if (arg.len > 0) { var why: [320]u8 = undefined; // The authority's lookup, taped, as Shell's (exec.zig). if (pardes.tape.value(.shell, @import("host_io.zig").Shell.refusal, .{ arg[0..@min(arg.len, 200)], &why })) |refused| { var said: pardes.Kind.Buf(340) = .{}; return c.p.reportFailure(c.id, said.print("Term: {s}", .{refused})); } } const pane = exec.spawnTty(c.p, c.id) orelse return; if (arg.len > 0) pane.shell = c.p.gpa.dupe(u8, arg) catch null; } }; /// Binds this terminal as a language's REPL, so an exec on that language's /// files is typed into it instead of run. The language is named as the /// syntax table has it: an exec made on the body of a file in that /// language -- a middle click, the execute key, a single word like `ls` /// as much as a selection -- and one made on this terminal's own body, is /// typed into it (bracketed paste if its program asked for that, else line /// by line, then Enter) instead of run. `Repl python` binds (again, it is /// already); `Repl -` unbinds; `Repl` bare says what it is bound as. With /// several bound for a language, the exec asks which. /// Still commands, whatever is bound: a word in a tag, `Exec ` run by /// name (typed, a 2-1 chord onto Exec, a ctl line), and a command word /// @`cmd` in the text, looked at or clicked. pub const Repl = struct { pub const takes_arg = true; pub fn run(c: Ctx) void { const pane = c.pane; // A terminal with its emulator -- not a document pane -- and not // a command pane whose command, the REPL it would be, is done. if (!pane.isTerminal() or pane.terminal == null) return c.p.reportFailure(c.id, "Repl: only a terminal is a REPL"); if (pane.command != null and pane.command_done) return c.p.reportFailure(c.id, "Repl: its command is done; a REPL is a running program"); const arg = std.mem.trim(u8, c.arg orelse "", " \t\r\n"); var buf: pardes.Kind.Buf(320) = .{}; var idbuf: [48]u8 = undefined; if (arg.len == 0) { if (pane.repl == null) return c.p.setMessage(c.id, "Repl: not bound"); return c.p.setMessage(c.id, buf.print("Repl: {s}", .{exec.replId(&idbuf, pane)})); } if (std.mem.eql(u8, arg, "-")) { pane.repl = null; return c.p.setMessage(c.id, "Repl: unbound"); } const manifest = @import("grammar_manifest.zig"); const grammars = manifest.all; // Named as a code fence names it: `py`, `Python`, `sh`. const named: ?u8 = if (manifest.byName(arg)) |i| if (grammars[i].exts.len > 0) @intCast(i) else null else null; const lang: u8 = named orelse { // A few, whole, and where the rest are: a list cut to fit the // row would end mid-word. var w = std.Io.Writer.fixed(&buf.bytes); list: { // A list past the room is cut at its end. w.print("Repl: invalid language \"{s}\"; - or one like", .{@import("Messages.zig").clip(arg, 24)}) catch break :list; // Those that start as the word does first, a misspelling's // likeliest meaning (pithon: python). var shown: usize = 0; var known: usize = 0; for ([2]bool{ true, false }) |alike| for (grammars) |g| if (g.exts.len > 0) { const starts = arg.len > 0 and g.name[0] == std.ascii.toLower(arg[0]); if (starts != alike) continue; known += 1; if (shown < 6) { w.print(" {s}", .{g.name}) catch break :list; shown += 1; } }; w.print(" ({d} more)", .{known - shown}) catch break :list; } return c.p.reportFailure(c.id, w.buffered()); }; if (pane.repl) |r| if (r.lang == lang) return c.p.setMessage(c.id, buf.print("Repl: {s}", .{exec.replId(&idbuf, pane)})); // The lowest letter no other REPL of the language has: freed ones // come back. var letter: u8 = 'a'; while (letter <= 'z') : (letter += 1) { const taken = for (c.p.panes) |slot| { const other = slot orelse continue; if (other != pane) if (other.repl) |r| if (r.lang == lang and r.letter == letter) break true; } else false; if (!taken) break; } if (letter > 'z') return c.p.reportFailure(c.id, "Repl: every letter of the language is taken"); pane.repl = .{ .lang = lang, .letter = letter }; pane.repl_warned = false; c.p.setMessage(c.id, buf.print("Repl: {s}", .{exec.replId(&idbuf, pane)})); } }; /// Fold the active pane's column into the one on its right, keeping its panes. /// The horizontal mirror of the vertical stacking `New` does. pub const Joincol = struct { pub const scope: Scope = .session; pub fn run(c: Ctx) void { // The keyboard's column joins the one to its right; the last has none. const col = layout.keyboardColumn(c.p, c.p.view().active) orelse return; if (col + 1 >= c.p.view().ncol) return c.p.reportFailure(c.id, "Joincol: no column to the right"); // As Newcol is refused: a column that could not give each pane its // tag and 2 rows would leave a layout `size` refuses as it is. if (!layout.joinFits(c.p, col)) return c.p.reportFailure(c.id, "Joincol: no space: the joined column cannot give each pane its tag and 2 rows"); layout.joinCol(c.p, col); } }; /// Open the tutor, a document to work through. pub const Tutor = struct { pub const scope: Scope = .session; pub fn run(c: Ctx) void { const free = c.p.freeSlot() orelse return c.p.reportError(c.id, "Tutor", error.NoPaneSlots); _ = panes.openTutorView(c.p, free) catch |err| return c.p.reportError(c.id, "Tutor", err); exec.placeNew(c.p, c.id, c.id, free, .doc); // a doc like any other } }; /// Open the help: every key and every builtin. pub const Help = struct { pub const scope: Scope = .session; pub const output: OutputTraits = .{ .name = config.help_buffer }; pub fn run(c: Ctx) void { panes.Output.openHelp(c.p, c.id, "") catch |err| c.p.reportError(c.id, "help", err); } }; /// Open the startup file, `init`, in a pane: its pane when it is open, else /// the file, else a pane of that name for Save to make it and its directory. pub const Config = struct { pub const scope: Scope = .session; pub fn run(c: Ctx) void { const path = c.p.startupPath() orelse return c.p.reportFailure(c.id, "Config: no startup file here: no configuration directory"); var real_buf: [4096]u8 = undefined; const real = if (pardes.filesystem.resolveOs(path, &real_buf)) |r| r.path else null; for (c.p.panes, 0..) |slot, id| { const pane = slot orelse continue; const f = pane.file orelse continue; if (f.output != null) continue; if (!std.mem.eql(u8, f.path, path) and !(if (real) |r| std.mem.eql(u8, f.path, r) else false)) continue; return look.focusPaneLine(c.p, id, .{}, .keep); } if (real != null) return look.lookAt(c.p, c.id, path); // Not there yet: a pane named for it, which Save makes. const free = c.p.freeSlot() orelse return c.p.reportError(c.id, "Config", error.NoPaneSlots); panes.newScratchFor(c.p, c.id, .scratch); if (c.p.panes[free] == null) return; @import("ninep/pane.zig").nameBuffer(c.p, free, path, false) catch |err| return c.p.reportError(c.id, "Config", err); c.p.view().active = free; } }; /// Open the settings in effect, each a word to click, and the startup /// file's path. pub const DumpConfig = struct { pub const scope: Scope = .session; pub const output: OutputTraits = .{ .name = config.dump_config_buffer }; pub fn run(c: Ctx) void { panes.Output.openConfig(c.p, c.id) catch |err| c.p.reportError(c.id, "config", err); } }; /// Set how location rows are drawn, or show how they are when bare. pub const LocationsConfig = struct { pub const scope: Scope = .session; pub const takes_arg = true; pub const output: OutputTraits = .{ .name = "+LocationsConfig" }; pub fn run(c: Ctx) void { const argument = std.mem.trim(u8, c.arg orelse "", " \t\r\n"); const next = c.p.locations_config.parse(argument) catch |err| { c.p.reportError(c.id, "LocationsConfig", err); return; }; c.p.locations_config = next; // Bare, it is a question, and the window is the answer. With arguments // it is a setting, and a setting that opens a window is noise. if (argument.len != 0) return; report(c) catch |err| c.p.reportError(c.id, "LocationsConfig", err); } fn report(c: Ctx) !void { var out: std.Io.Writer.Allocating = .init(c.p.gpa); errdefer out.deinit(); try out.writer.writeAll("LocationsConfig "); try c.p.locations_config.write(&out.writer); try out.writer.writeByte('\n'); const content = try out.toOwnedSlice(); const dir = if (c.pane.file) |file| panes.Dir.ofName(file.path) else c.pane.cwdSlice(); try panes.Output.fillResults(c.p, c.id, dir, .{ .cmd = .LocationsConfig }, "", content, null); } }; /// Open the messages shown so far. pub const Messages = struct { pub const scope: Scope = .session; pub const output: OutputTraits = .{ .name = config.messages_buffer }; pub fn run(c: Ctx) void { panes.Output.openMessages(c.p, c.id) catch |err| c.p.reportError(c.id, "messages", err); } }; /// This build: its version, commit, jj change and build time (a stamped /// build's: a release or the ~/.local install), the zig that built it, its /// optimize mode, target, platform, grammars, whether the addons are compiled /// in, and its dependencies, printed into an output buffer. pub const Build = struct { pub const scope: Scope = .session; pub const output: OutputTraits = .{ .name = config.build_buffer }; pub fn run(c: Ctx) void { panes.Output.openBuild(c.p, c.id) catch |err| c.p.reportError(c.id, "build", err); } }; /// This build's version and what changed to reach it, printed into an output /// buffer the same way Config prints the live settings. pub const Changelog = struct { pub const scope: Scope = .session; pub const output: OutputTraits = .{ .name = config.changelog_buffer }; pub fn run(c: Ctx) void { panes.Output.openChangelog(c.p, c.id) catch |err| c.p.reportError(c.id, "changelog", err); } }; /// Open a minimap of the file in braille dots. pub const Mini = struct { pub const takes_arg = true; pub const requires_arg = true; // a file to map: bare, wrong #args (EINVAL) pub const output: OutputTraits = .{ .name = "Mini", .doc = true }; pub fn run(c: Ctx) void { panes.mini.open(c.p, c.id, c.arg orelse "") catch |err| c.p.reportError(c.id, "Mini", err); } }; // ---- search ---- /// A Find or Grep that finds nothing fails as one, in words 9ns reads as /// ENOENT (`not found`), the same for both. const e_search_miss_find = "Find: name not found"; const e_search_miss_grep = "Grep: text not found"; /// List the files below this pane's directory whose names hold its argument, in a +Search. pub const Find = struct { pub const takes_arg = true; // A script's Find names what to find (bare, it is a key's prompt). pub const requires_arg = true; pub fn run(c: Ctx) void { search(c, .find, e_search_miss_find); } }; /// Find's sibling: Find matches file NAMES under this pane's directory, Grep /// matches the LINES of those files, on the disk engine's worker. pub const Grep = struct { pub const takes_arg = true; pub const requires_arg = true; pub fn run(c: Ctx) void { search(c, .grep, e_search_miss_grep); } }; /// Find's and Grep's query pane under this pane, line 1 the source's word /// and the argument: bare (SPC f f) typed into; with a word (B2, a script) /// listed, the keyboard left where it was. A script's (a 9P write runs it /// to its end before it answers) that found nothing fails as one, opening /// nothing: a query pane it made goes as an Esc takes it, one it reused /// stays, its count 0; the write hears `not found`. fn search(c: Ctx, source: panes.Query.Source, miss: []const u8) void { const pat = std.mem.trim(u8, c.arg orelse "", " \t\r\n"); const reused = panes.Query.ofOwner(c.p, c.pane.serial) != null; panes.Query.open(c.p, c.id, source, pat, pat.len == 0); if (pat.len == 0 or !c.p.fs.serving) return; const qid = panes.Query.ofOwner(c.p, c.pane.serial) orelse return; if (c.p.panes[qid].?.query.?.total != 0) return; if (!reused) panes.Query.cancel(c.p, qid); c.p.reportFailure(c.id, miss); } /// Search in a query pane under this pane, line 1 the argument (`Panes`, /// `Symbols lay`, `All needle`, `/re`, any of its words); bare, `/`. pub const Search = struct { pub const takes_arg = true; pub const quiet = true; pub fn run(c: Ctx) void { const line = std.mem.trim(u8, c.arg orelse "", " \t\r\n"); const asked = panes.Query.parse(line) orelse panes.Query.parse(std.mem.concat(c.p.scratch.allocator(), u8, &.{ "/", line }) catch return).?; panes.Query.open(c.p, c.id, asked.source, asked.pat, true); } }; /// A query pane's Grep stopped at its 2000 lines goes on for 2000 more. pub const More = struct { pub const quiet = true; pub fn run(c: Ctx) void { if (!pardes.Stream.moreFor(c.p, c.id)) c.p.reportFailure(c.id, "More: no search is waiting at its cap"); } }; /// Pick an open pane by its name in a query pane under this one (SPC b b). pub const Panes = struct { pub const takes_arg = true; pub const quiet = true; pub fn run(c: Ctx) void { panes.Query.open(c.p, c.id, .panes, std.mem.trim(u8, c.arg orelse "", " \t\r\n"), true); } }; // ---- the window group ---- // The headers are above the panes in the same layout: Up from a pane with // nothing above it reaches its column's tag, then the workspace's, and Down // comes back the same way. Left and Right walk the column tags. /// Move the keyboard to the pane, or column tag, to the left. pub const Left = struct { pub fn run(c: Ctx) void { if (c.p.view().header != null) { if (c.p.headerColumn()) |column| if (column > 0) tagline.enterHeader(c.p, column - 1); return; } _ = layout.focusDir(c.p, c.id, .left); } }; /// Move the keyboard to the pane below, off a tag onto the pane under it. pub const Down = struct { pub fn run(c: Ctx) void { if (c.p.view().header != null) { const column = layout.findPane(c.p, c.id); if (c.p.headerColumn() == null and layout.columnBarHeight(c.p) > 0) return tagline.enterHeader(c.p, if (column) |at| at.col else 0); // Onto the top pane of the column the header stands over. const col = c.p.headerColumn() orelse if (column) |at| at.col else return; // An empty column's tag has nothing below it. if (col < c.p.view().ncol and c.p.view().cols[col].n == 0) return; tagline.exitHeader(c.p); if (col < c.p.view().ncol) c.p.view().active = c.p.view().cols[col].panes[0]; return; } _ = layout.focusDir(c.p, c.id, .down); } }; /// Move the keyboard to the pane above, and from a column's top pane to its tag. pub const Up = struct { pub fn run(c: Ctx) void { if (c.p.view().header != null) { if (c.p.headerColumn() != null and c.p.topBarHeight() > 0) tagline.enterHeader(c.p, null); return; } if (layout.focusDir(c.p, c.id, .up)) return; if (layout.columnBarHeight(c.p) > 0) { if (layout.findPane(c.p, c.id)) |at| tagline.enterHeader(c.p, at.col); } else if (c.p.topBarHeight() > 0) tagline.enterHeader(c.p, null); } }; /// Move the keyboard to the pane, or column tag, to the right. pub const Right = struct { pub fn run(c: Ctx) void { if (c.p.view().header != null) { if (c.p.headerColumn()) |column| if (column + 1 < c.p.view().ncol) tagline.enterHeader(c.p, column + 1); return; } _ = layout.focusDir(c.p, c.id, .right); } }; /// Emacs's follow-mode: one text across a chain of panes as consecutive /// pages, each going on where the one before ends, scrolled as one. Adds a /// page, a Zerox twin, at the end of the column right of the chain's last, /// or in a new column there; its tag has Unfollow. pub const Follow = struct { pub fn run(c: Ctx) void { if (@import("edit_cmd.zig").busyOn(c.p, c.id)) return c.p.reportFailure(c.id, "Follow: " ++ @import("edit_cmd.zig").e_busy); const f = if (c.pane.file) |*file| file else return c.p.reportFailure(c.id, "Follow: only a file pane takes it"); if (f.output != null or f.listing != null or f.mini != null) return c.p.reportFailure(c.id, "Follow: only a file pane takes it"); // One chain a text: the new page goes after its last, in column order. const v = c.p.view(); var last = c.id; for (v.cols[0..v.ncol]) |col| for (col.panes[0..col.n]) |id| { const other = if (c.p.panes[id].?.file) |*file| file else continue; if (f.twin != 0 and other.twin == f.twin and other.follow) last = id; }; if (!f.follow and last != c.id) return c.p.reportFailure(c.id, "Follow: this text has a chain: Follow on one of its panes"); const col = (layout.findPane(c.p, last) orelse return c.p.reportFailure(c.id, "Follow: the pane is not laid out")).col; const free = c.p.freeSlot() orelse return c.p.reportError(c.id, "Follow", error.NoPaneSlots); const made = panes.File.zerox(c.p, c.id, free) catch |err| return c.p.reportError(c.id, "Follow", err); const keep = v.active; if (col + 1 < v.ncol) { c.p.exec_column = col + 1; defer c.p.exec_column = null; exec.placeNew(c.p, c.id, null, free, .scratch); if (c.p.unplaced.isSet(free)) return; } else if (!layout.splitColumn(c.p, last, free, false)) { c.p.unplaced.set(free); return c.p.reportFailure(c.id, "Follow: no space for a column: this one is too narrow to split"); } // The keyboard stays on the page it was on. v.active = keep; if (layout.findPane(c.p, keep)) |at| c.p.setActiveColumn(at.col); f.follow = true; made.file.?.follow = true; c.pane.follow_scroll = f.scroll; made.follow_scroll = made.file.?.scroll; made.appendTag(" Unfollow") catch |err| c.p.reportError(c.id, "Follow", err); } }; /// Take this pane out of its Follow chain: it stays, a Zerox twin with the /// scroll it has, and the chain closes up behind it. pub const Unfollow = struct { pub fn run(c: Ctx) void { const f = if (c.pane.file) |*file| file else return c.p.reportFailure(c.id, "Unfollow: this pane is in no Follow chain"); if (!f.follow) return c.p.reportFailure(c.id, "Unfollow: this pane is in no Follow chain"); panes.File.unchain(c.pane); } }; /// Window mode: h/j/k/l move an outline between the panes; Enter or Esc /// focuses the outlined pane, `:` its tag, the letter shown on a pane that one; d is Del on it (then k or j between two), c Collapse. pub const Window = struct { pub fn run(c: Ctx) void { tagline.exitHeader(c.p); c.p.view().window_pick = if (c.p.panes[c.id] != null) c.id else c.p.view().active; } }; // ---- the jump group ---- /// Ctrl-o: one step back into the history. pub const Back = struct { pub const scope: Scope = .session; pub fn run(c: Ctx) void { Jump.jumpBy(c.p, -1); } }; /// Ctrl-i: one step forward again, up to wherever Back started. pub const Forward = struct { pub const scope: Scope = .session; pub fn run(c: Ctx) void { Jump.jumpBy(c.p, 1); } }; /// Select the next Look location across panes; Enter opens it. pub const LookNext = struct { pub const quiet = true; pub fn run(c: Ctx) void { look.lookWalk(c.p, 1); } }; /// Select the previous Look location across panes; Enter opens it. pub const LookPrev = struct { pub const quiet = true; pub fn run(c: Ctx) void { look.lookWalk(c.p, -1); } }; /// Go back to the last place jumped from in another pane. pub const Last = struct { pub fn run(c: Ctx) void { var i = c.p.view().jumps.n; while (i > 0) { i -= 1; const j = c.p.view().jumps.list[i]; if (j.serial == 0) continue; // a closed file's: Back reopens it, Last goes to a pane // Restore the cursor without recentering the pane's retained view. if (j.pane != c.id) return look.focusPaneLine(c.p, j.pane, .{ .line = j.line, .col = j.col }, .keep); } // Nothing on the jumplist to go back to, which is the ordinary case // for a pane that opened beside this one and was never focused. if (panes.neighbourPane(c.p, c.id)) |next| look.focusPaneLine(c.p, next, .{ .line = 0, .col = 0 }, .keep); } }; /// List the files opened lately, closed ones too, each a place to open again. pub const Recent = struct { pub const scope: Scope = .session; pub const takes_arg = true; pub fn run(c: Ctx) void { // The query pane under the pane the keyboard is in, line 1 // `Recent `, typed into; what follows the word narrows the files. if (c.p.panes[c.id] == null) return c.p.reportFailure(c.id, "Recent: open a pane to search from"); panes.Query.open(c.p, c.id, .recent, std.mem.trim(u8, c.arg orelse "", " \t\r\n"), true); } }; /// List the places jumped from, each a place to go. pub const Jumplist = struct { pub const scope: Scope = .session; pub const output: OutputTraits = .{ .name = config.jumps_buffer, .steps = true, .locations = true }; pub fn run(c: Ctx) void { panes.Output.openJumps(c.p, c.id) catch |err| c.p.reportError(c.id, "jumplist", err); } }; // ---- the language group ---- /// Go to the definition of the symbol under the cursor; with an argument /// (a 2-1 chord's selection), of that symbol, where it is nearest. pub const Def = struct { pub const takes_arg = true; /// Its answer says what it found, a jump or a list or why not; its /// name would only stack above it, as gd never did. pub const quiet = true; pub fn run(c: Ctx) void { c.p.lspRequest(c.id, .definition, std.mem.trim(u8, c.arg orelse "", " \t\r\n")); } }; /// List the references to the symbol under the cursor; with an argument /// (a 2-1 chord's selection), to that symbol, where it is nearest. pub const Refs = struct { pub const takes_arg = true; pub const quiet = true; // as Def pub fn run(c: Ctx) void { c.p.lspRequest(c.id, .references, std.mem.trim(u8, c.arg orelse "", " \t\r\n")); } }; /// Ask the language server about the symbol under the cursor. pub const Hover = struct { pub fn run(c: Ctx) void { c.p.lspRequest(c.id, .hover, ""); } }; /// List the language server's code actions for the cursor. pub const CodeAction = struct { pub fn run(c: Ctx) void { c.p.lspRequest(c.id, .code_action, ""); } }; /// Select every reference to the symbol under the cursor. pub const SelectRefs = struct { pub fn run(c: Ctx) void { c.p.lspRequest(c.id, .select_refs, ""); } }; /// List the file's symbols from the language server. pub const Symbols = struct { pub fn run(c: Ctx) void { c.p.lspRequest(c.id, .document_symbols, ""); } }; /// List the file's diagnostics from the language server. pub const Diagnostics = struct { pub fn run(c: Ctx) void { c.p.lspRequest(c.id, .diagnostics, ""); } }; /// List the workspace's diagnostics from the language server. pub const WsDiagnostics = struct { pub fn run(c: Ctx) void { c.p.lspRequest(c.id, .workspace_diagnostics, ""); } }; /// Run the file's language indexer at its project root, writing the index.scip the language words ask first. pub const Index = struct { pub fn run(c: Ctx) void { c.p.lspRequest(c.id, .index, ""); } }; /// Show outermost callers first, with signatures and call sites (gc). pub const Callstack = struct { pub fn run(c: Ctx) void { c.p.lspRequest(c.id, .callstack, ""); } }; /// List the callers of the function under the cursor. pub const Callers = struct { pub fn run(c: Ctx) void { c.p.lspRequest(c.id, .incoming_calls, ""); } }; /// List the functions the function under the cursor calls. pub const Callees = struct { pub fn run(c: Ctx) void { c.p.lspRequest(c.id, .outgoing_calls, ""); } }; /// List the supertypes of the type under the cursor. pub const Supertypes = struct { pub fn run(c: Ctx) void { c.p.lspRequest(c.id, .supertypes, ""); } }; /// List the subtypes of the type under the cursor. pub const Subtypes = struct { pub fn run(c: Ctx) void { c.p.lspRequest(c.id, .subtypes, ""); } }; /// Rename the symbol under the cursor everywhere, to its argument. pub const Rename = struct { pub const takes_arg = true; pub const requires_arg = true; pub fn run(c: Ctx) void { const a = std.mem.trim(u8, c.arg orelse "", " \t\r\n"); if (a.len > 0) return c.p.lspRequest(c.id, .rename, a); panes.startPrompt(c.p, c.pane, &c.pane.body, .{ .search = config.rename_marker }); } }; /// Search the workspace's symbols for its argument. pub const WsSymbols = struct { pub const takes_arg = true; pub const requires_arg = true; pub fn run(c: Ctx) void { const a = std.mem.trim(u8, c.arg orelse "", " \t\r\n"); if (a.len > 0) return c.p.lspRequest(c.id, .workspace_symbols, a); panes.startPrompt(c.p, c.pane, &c.pane.body, .{ .search = config.symbol_marker }); } }; /// Show which language servers serve this file and their state. pub const Lspinfo = struct { pub fn run(c: Ctx) void { c.p.lspRequest(c.id, .status, ""); } }; /// Explain how the last language server request was answered, step by step. pub const Lspwhy = struct { pub fn run(c: Ctx) void { c.p.lspRequest(c.id, .explain, ""); } }; test "Exit and Restore name a modified +New scratch as well as files" { const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true }); defer p.deinit(); const file = try p.setTestFile("saved\n"); file.file.?.saved_revision = file.file.?.revision -% 1; // modified file.file.?.saved_hash = 0; // edited: what it had is not what it has p.newScratchBelow(p.view().active); const scratch = &p.panes[p.view().active].?.file.?; scratch.content = try p.gpa.realloc(scratch.content, 120); @memset(scratch.content, 'n'); // past acme's 100 bytes, where it whines scratch.revision +%= 1; // typed into, never saved scratch.saved_hash = 0; // edited: what it had is not what it has p.fs.no_prompt = true; defer p.fs.no_prompt = false; try std.testing.expect(p.executeBuiltinLine(p.view().active, "Exit")); try std.testing.expect(!p.quit); // Each pane's message row names it; the write's refusal counts them. try std.testing.expectEqualStrings("2 unsaved panes: Modified (Exit again to discard)", p.fs.failure[0..p.fs.failure_len]); try std.testing.expect(std.mem.indexOf(u8, unsavedList(p), "test.txt: Modified") != null); const scratch_pane = p.panes[p.view().active].?; var named: [64]u8 = undefined; try std.testing.expect(std.mem.indexOf(u8, unsavedList(p), try std.fmt.bufPrint(&named, "{s} (pane {d})", .{ config.scratch_buffer, scratch_pane.serial })) != null); // Delcol, Restore and Exit name it the same way. p.fs.failure_len = 0; try std.testing.expect(p.executeBuiltinLine(p.view().active, "Delcol")); try std.testing.expect(std.mem.indexOf(u8, unsavedList(p), "Delcol again to discard") == null); try std.testing.expect(std.mem.indexOf(u8, unsavedList(p), named[0 .. config.scratch_buffer.len + 7]) != null); } test "Del and Delcol refuse a pane with unsaved text once, as acme's do, and close on the second" { const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true }); defer p.deinit(); const pane = try p.setTestFile("saved\n"); pane.file.?.saved_revision = pane.file.?.revision -% 1; // modified pane.file.?.saved_hash = 0; // edited: what it had is not what it has const serial = pane.serial; try std.testing.expect(p.executeBuiltinLine(p.view().active, "Delcol")); try std.testing.expect(p.paneBySerial(serial) != null); // A refused Delcol changes nothing: no +Unsaved (its records say it). try std.testing.expect(std.mem.indexOf(u8, unsavedList(p), "Delcol") == null); // Each word is warned on its own: Del asks too, then closes. try std.testing.expect(p.executeBuiltinLine(p.view().active, "Del")); try std.testing.expect(p.paneBySerial(serial) != null); try std.testing.expect(std.mem.endsWith(u8, unsavedList(p), ": Modified\n\nDel again to discard\n")); try std.testing.expect(p.executeBuiltinLine(p.view().active, "Del")); try std.testing.expect(p.paneBySerial(serial) == null); } test "a pane renamed but never edited has no text to lose: Del closes it at once" { const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true }); defer p.deinit(); p.newScratchBelow(p.view().active); const pane = try p.setTestFile("loaded\n"); pane.file.?.saved_revision = pane.file.?.revision -% 1; // dirty by the rename alone const serial = pane.serial; try std.testing.expect(p.executeBuiltinLine(0, "Del")); try std.testing.expect(p.paneBySerial(serial) == null); }