const std = @import("std"); const Kind = @import("Kind.zig"); const builtin = @import("builtin"); const libc = std.c; const pardes = @import("pardes.zig"); const exec = @import("exec.zig"); const Plumb = @import("Plumb.zig"); const config = @import("config.zig"); const diff = @import("diff.zig"); const platform_has_fs = filesystem.platform_has_fs; const layout = @import("layout.zig"); const modal = @import("modal.zig"); const tagline = @import("tagline.zig"); const filesystem = @import("fs.zig"); const panes = @import("panes.zig"); const mouse = @import("mouse.zig"); const normal = @import("normal.zig"); const edit = @import("edit.zig"); const colors = @import("colors.zig"); const Color = @import("surface.zig").Color; const Pane = panes.Pane; const MAX_PANES = pardes.MAX_PANES; const Layer = @import("Layer.zig"); const TagHit = pardes.TagHit; const BOX_H = pardes.BOX_H; const TAG_TEXT_INSET = pardes.TAG_TEXT_INSET; const Mouse = pardes.Mouse; const Key = pardes.Key; const Event = pardes.Event; const Pardes = pardes.Pardes; extern "c" fn execv(path: [*:0]const u8, argv: [*:null]const ?[*:0]const u8) c_int; const opener_path: ?[*:0]const u8 = switch (builtin.os.tag) { .linux => "/usr/bin/xdg-open", .macos => "/usr/bin/open", else => null, }; pub fn openLink(url: []const u8) void { const opener = opener_path orelse return; var buf: [1024]u8 = undefined; const url_z = std.fmt.bufPrintSentinel(&buf, "{s}", .{url}, 0) catch return; const pid = libc.fork(); if (pid < 0) return; if (pid == 0) { if (libc.fork() == 0) { @import("host_io.zig").resetChildSignals(); const argv: [3:null]?[*:0]const u8 = .{ opener, url_z.ptr, null }; _ = execv(opener, &argv); } libc._exit(0); } _ = libc.waitpid(pid, null, 0); } pub const Spot = struct { line: usize = 0, col: usize = 0, end_line: usize = 0, end_col: usize = 0, }; fn num(tok: []const u8, i: usize) struct { v: usize, end: usize } { var v: usize = 0; var j = i; while (j < tok.len and std.ascii.isDigit(tok[j])) : (j += 1) v = v *| 10 +| (tok[j] - '0'); return .{ .v = v, .end = j }; } pub fn parsePathLine(tok: []const u8) struct { path: []const u8, at: Spot, end: usize } { var sep: usize = 0; while (sep < tok.len) : (sep += 1) { if (tok[sep] != config.line_col_sep) continue; const l = num(tok, sep + 1); if (l.end == sep + 1) continue; // no digits after ':' const path = tok[0..sep]; var i = l.end; if (i < tok.len and tok[i] == config.range_sep) { const e = num(tok, i + 1); if (e.end == i + 1) continue; // a dash with no number is not a range if (e.end < tok.len and tok[e.end] != config.line_col_sep) continue; // junk after it return .{ .path = path, .at = .{ .line = l.v, .end_line = e.v }, .end = e.end }; } if (i < tok.len and tok[i] != config.line_col_sep) continue; // junk after the number var at: Spot = .{ .line = l.v }; if (i == tok.len) return .{ .path = path, .at = at, .end = i }; const c = num(tok, i + 1); if (c.end == i + 1) return .{ .path = path, .at = at, .end = i }; if (c.end < tok.len and tok[c.end] != config.line_col_sep and tok[c.end] != config.range_sep) return .{ .path = path, .at = at, .end = i }; at.col = c.v; i = c.end; if (i == tok.len or tok[i] != config.range_sep) return .{ .path = path, .at = at, .end = i }; const e = num(tok, i + 1); if (e.end == i + 1) return .{ .path = path, .at = at, .end = i }; at.end_line = at.line; at.end_col = e.v; var end = e.end; if (e.end < tok.len and tok[e.end] == config.line_col_sep) { const e2 = num(tok, e.end + 1); if (e2.end > e.end + 1) { at.end_line = at.end_col; at.end_col = e2.v; end = e2.end; } } return .{ .path = path, .at = at, .end = end }; } return .{ .path = tok, .at = .{}, .end = tok.len }; } pub const FileTarget = struct { path: []const u8, at: Spot, }; pub const Target = union(enum) { none, dir: []const u8, // resolved absolute path, in caller's buf file: FileTarget, /// A file a kind opens (Kind.forPath): a picture, a PDF; `at` the place /// written after it (`book.pdf:12:3`), the kind's to take. kind: struct { path: []const u8, kind: u8, at: Spot = .{} }, url: []const u8, pane: struct { id: usize, at: Spot }, }; pub const Span = struct { start: usize, end: usize }; const lead_trim = "([{<\"'`*"; const trail_trim = ")]}>\"'`*,;:.!?"; pub fn lineSpan(p: ?*pardes.Pardes, line: []const u8, cwd: []const u8, realbuf: *[4096]u8) ?Span { var lo: usize = 0; while (lo < line.len and (line[lo] == ' ' or line[lo] == '\t')) lo += 1; var hi = std.mem.trimEnd(u8, line, " \t\r").len; while (hi > lo) { var a = lo; var b = hi; while (a < b and std.mem.indexOfScalar(u8, lead_trim, line[a]) != null) a += 1; while (b > a and std.mem.indexOfScalar(u8, trail_trim, line[b - 1]) != null) b -= 1; const cand = line[a..b]; if (cand.len > 0 and parsePathLine(cand).end == cand.len) switch (resolve(p, cand, cwd, realbuf)) { .dir, .file, .kind => return .{ .start = a, .end = b }, .url, .pane => if (std.mem.indexOfAny(u8, cand, " \t") == null) return .{ .start = a, .end = b }, .none => {}, }; while (hi > lo and line[hi - 1] != ' ' and line[hi - 1] != '\t') hi -= 1; while (hi > lo and (line[hi - 1] == ' ' or line[hi - 1] == '\t')) hi -= 1; } return null; } pub fn resolve(p: ?*pardes.Pardes, word_raw: []const u8, cwd: []const u8, realbuf: *[4096]u8) Target { const trimmed = std.mem.trim(u8, word_raw, " \t\r\n"); const pl = parsePathLine(trimmed); const word = pl.path; if (word.len == 0) return .none; // POSIX resolves repeated slashes to the root directory, but bare // and // /// in text are comment markers. A single / remains a valid target. if (word.len > 1 and std.mem.indexOfNone(u8, word, "/") == null) return .none; if (word.len > config.pane_addr.len and std.mem.startsWith(u8, word, config.pane_addr)) { var id: usize = 0; for (word[config.pane_addr.len..]) |c| { if (!std.ascii.isDigit(c)) break; id = id *| 10 +| (c - '0'); } else { // `@p`: the pane's serial, as /index and the log name // it, not its slot; one that is not open names none. const slot = if (p) |pp| (pp.paneBySerial(@intCast(@min(id, std.math.maxInt(u32)))) orelse MAX_PANES) else id; return .{ .pane = .{ .id = slot, .at = pl.at } }; } } for (config.url_schemes) |scheme| { if (std.mem.startsWith(u8, trimmed, scheme)) return .{ .url = trimmed }; } const found = filesystem.resolve(p, word, cwd, realbuf) orelse return .none; if (found.dir) return .{ .dir = found.path }; if (p) |pp| if (pp.kinds.forPath(found.path)) |k| return .{ .kind = .{ .path = found.path, .kind = k, .at = pl.at } }; return .{ .file = .{ .path = found.path, .at = pl.at } }; } // ---- looking inside the editor: expanding the word under a click, the n/N // walk over look-able text, search results, the hover preview, and lookAt, // which opens or focuses what a word names ---- pub const LookHoverWait = struct { col: u16, row: u16, pane: usize, serial: u32, frames: u16 = 0, body_hit: ?Mouse.BodyHit = null, tag_hit: ?TagHit = null, }; pub const LookHoverPreview = struct { col: u16, row: u16, pane: usize, serial: u32, sel: ?Pane.Sel, file_word: ?FileWordSpan = null, body_hit: ?Mouse.BodyHit = null, tag_hit: ?TagHit = null, }; pub const FileWordSpan = struct { row: i32, lo: i32, hi: i32, // exclusive }; pub fn armLookWalk(p: *Pardes, id: usize) void { const pane = p.panes[id] orelse return; if (pane.file) |file| if (file.content.len == 0) return; p.look_walk_owner = pane.serial; } pub fn invalidateLookHover(p: *Pardes, id: usize) void { if (lookHoverPane(p) != id) return; p.view().raw_hover_intent = false; cancelLookHover(p); } pub const ExpandedWord = struct { lo: usize, hi: usize }; pub fn expandedWord(line: []const u8, col: usize) ?ExpandedWord { if (col >= line.len) return null; const b = config.wordBounds(line, col); const command_run = b.hi > b.lo and config.commandWord(line[b.lo..b.hi]) != null; if (!config.isFileChar(line[col]) and !command_run) return null; if (b.hi <= b.lo) return null; return .{ .lo = b.lo, .hi = b.hi }; } /// acme: a no-drag middle/right click expands to the word under it — /// file-ish, or a whole `` @`...` `` run (config.wordBounds is the spelling) pub fn expandedSel(p: *Pardes, pane: *Pane, at: Pane.Sel) ?Pane.Sel { var sl = at; if (sl.c0 != sl.c1 or sl.r0 != sl.r1) return sl; if (sl.r0 >= 0 and sl.r0 < pane.tag_rows) return tagWordSel(p, pane, sl); const text = edit.paneText(p, pane) catch return null; var it = std.mem.splitAny(u8, text, "\n"); var v: i32 = 0; while (it.next()) |line| : (v += 1) { if (v != sl.r0) continue; const display_col: usize = @intCast(@max(0, sl.c0)); const col = panes.File.renderedLineByteCol(pane, v, line, display_col); const b = expandedWord(line, col) orelse return null; sl.c0 = @intCast(panes.File.renderedLineDisplayCol(pane, v, line, b.lo)); sl.c1 = @intCast(panes.File.renderedLineDisplayCol(pane, v, line, b.hi) - 1); return sl; } return null; } /// A tag word is expanded in the tag's own text, so a word the wrapping /// broke across rows is still one word, as acme's frame wraps a tag /// without breaking its text. fn tagWordSel(p: *Pardes, pane: *Pane, at: Pane.Sel) ?Pane.Sel { const arena = p.scratch.allocator(); const shown = tagline.shownTag(p, arena, pane) catch return null; const whole = tagline.tagText(p, arena, pane) catch return null; const row: usize = @as(usize, @intCast(at.r0)) + pane.tag_top; const shown_line = modal.lineSlice(shown.text, row); const real = shown.toReal(modal.lineStartOffset(shown.text, row) + panes.File.rawAtDisplay(shown_line, @intCast(@max(0, at.c0)))); const start = if (std.mem.lastIndexOfScalar(u8, whole[0..@min(real, whole.len)], '\n')) |nl| nl + 1 else 0; const end = std.mem.indexOfScalarPos(u8, whole, start, '\n') orelse whole.len; const b = expandedWord(whole[start..end], real - start) orelse return null; const lo = shownCell(shown.text, shown.fromReal(start + b.lo), pane.tag_top); const hi = shownCell(shown.text, shown.fromReal(start + b.hi - 1), pane.tag_top); return .{ .state = at.state, .r0 = lo.row, .c0 = lo.col, .r1 = hi.row, .c1 = hi.col }; } fn shownCell(text: []const u8, off: usize, top: usize) struct { row: i32, col: i32 } { const before = text[0..@min(off, text.len)]; const row = std.mem.count(u8, before, "\n"); const line_start = if (std.mem.lastIndexOfScalar(u8, before, '\n')) |nl| nl + 1 else 0; return .{ .row = @as(i32, @intCast(row)) - @as(i32, @intCast(top)), .col = @intCast(panes.File.rawDisplayCol(text[line_start..], off - line_start)), }; } /// the word under the modal cursor as a pane-local selection (paneText /// coords: row 0 is the tag; file panes carry the line-number prefix) pub fn cursorWordSel(p: *Pardes, pane: *Pane) Pane.Sel { const w = pane.wrapRow(pane.body.cur_row, pane.body.cur_col); const vrow = w.row + @as(i32, pane.tag_rows); const vcol = if (pane.file != null) w.pad + panes.File.displayOffset(pane, pane.body.cur_row, w.at, pane.body.cur_col) + @as(i32, panes.File.gutterWidth(pane)) else blk: { const lines = edit.paneCursorLines(p, &pane.body) catch break :blk pane.body.cur_col; const local = pane.body.cur_row; if (local < 0 or @as(usize, @intCast(local)) >= lines.len) break :blk pane.body.cur_col; break :blk panes.File.lineDisplayOffset(lines[@intCast(local)], @intCast(@max(0, w.at)), @intCast(@max(0, pane.body.cur_col))); }; return .{ .state = .done, .c0 = vcol, .c1 = vcol, .r0 = vrow, .r1 = vrow }; } const SearchStart = enum { top, cursor }; pub fn submitSearch(p: *Pardes, id: usize) void { const pane = p.panes[id] orelse return; if (normal.selRegexArmed(pane)) |a| { // helix keeps the pattern in `/` if (a.pat.len > 0) { p.registers.put(p.gpa, '/', a.pat, 0, 1, true) catch |err| return p.reportError(id, "search", err); p.registers.last_search = '/'; } return if (panes.promptTarget(p, pane)) |t| normal.applySelRegex(p, pane, t, a.pat, a.mode); } const armed = pane.promptText() orelse return; const slash = std.mem.indexOfScalar(u8, armed, '/') orelse return; if (std.mem.startsWith(u8, armed, config.rename_marker)) return p.lspRequest(id, .rename, armed[slash + 1 ..]); if (std.mem.startsWith(u8, armed, config.symbol_marker)) return p.lspRequest(id, .workspace_symbols, armed[slash + 1 ..]); // A PDF's `/` and a terminal's: a text's is its query pane (Query.zig). _ = runSearch(p, id, armed[slash + 1 ..], .top, true) catch |err| return p.reportError(id, "search", err); var pattern: std.ArrayList(u8) = .empty; normal.appendSearchLiteral(&pattern, p.scratch.allocator(), armed[slash + 1 ..]) catch |err| return p.reportError(id, "search", err); p.registers.put(p.gpa, '/', pattern.items, 0, 1, true) catch |err| return p.reportError(id, "search", err); p.registers.last_search = '/'; lookFirstHit(p, id); } fn lookFirstHit(p: *Pardes, id: usize) void { const pane = p.panes[id] orelse return; const rid = pane.search_pane orelse return; const rp = p.panes[rid] orelse return; if ((rp.file orelse return).content.len == 0) return; p.view().active = rid; lookWalk(p, 1); if (p.view().active != rid) return; // walked out of the list; leave it there const txt = edit.currentSelText(p, rp) orelse return; // spent, exactly as the look chord spends it (handleKey) rp.body.vsel.active = false; rp.body.select = false; exec.runBuiltin(p, config.look_cmd, rid, "", txt); } /// Fills the results buffer, and answers how many rows a text or PDF /// search found. With `open_empty` false a text search that found nothing /// opens no buffer. A search of one pane's text (or its PDF) writes at /// most this many bytes of rows: past it, the rows stop and say where. pub const search_text_output_bytes = 16 << 20; pub fn runSearch(p: *Pardes, id: usize, pat_raw: []const u8, start: SearchStart, open_empty: bool) !usize { const pane = p.panes[id] orelse return 0; // Blanks at either end are the pattern's (a look of an indented line); // a builtin's argument comes trimmed already. const pat = std.mem.trimEnd(u8, pat_raw, "\r\n"); if (std.mem.trim(u8, pat, " \t").len == 0) return 0; const arena = p.scratch.allocator(); // where the pane lives: a file's directory, a shell's cwd — the // directory the results buffer is named in. From a column's or the // workspace's tag, the session's. const dir = if (p.exec_header) p.sessionDir() else Pardes.paneDir(pane); const out = try @import("memory.zig").unfilled(arena, search_text_output_bytes); var out_len: usize = 0; var nrows: usize = 0; var anchor: ?usize = null; if (pane.addon != null) { // A kind's own rows, if it has a search. const rows = Kind.search(p, id, pat) orelse ""; out_len = @min(rows.len, out.len); @memcpy(out[0..out_len], rows[0..out_len]); nrows = std.mem.count(u8, rows, "\n"); } else { const lines = try edit.paneCursorLines(p, &pane.body); // a real file names itself; a terminal or an output buffer has no path const has_path = if (pane.file) |f| f.output == null else false; var idbuf: [16]u8 = undefined; // relative to `dir`, like Find's rows — and `dir` IS this file's // own directory, so that is exactly its basename const loc: []const u8 = if (has_path) std.Io.Dir.path.basename(pane.file.?.path) else std.fmt.bufPrint(&idbuf, config.pane_addr ++ "{d}", .{pane.serial}) catch unreachable; // `@p` and a u32 fit 16 const cl: usize = @intCast(@max(0, pane.body.cur_row)); const cc: usize = @intCast(@max(0, pane.body.cur_col)); for (lines, 0..) |ln, i| { const at = std.ascii.findIgnoreCase(ln, pat) orelse continue; const row = std.fmt.bufPrint(out[out_len..], "{s}:{d}:{d}{c}{d} {s}\n", .{ loc, i + 1, at + 1, config.range_sep, at + pat.len, std.mem.trimEnd(u8, ln, " \t"), }) catch { // Past what it may write: the rows stop, and say where. if (nrows > 0) { const note = std.fmt.bufPrint(out[out_len..], "cut at {d} lines\n", .{nrows}) catch ""; out_len += note.len; nrows += @intFromBool(note.len > 0); } break; }; if (start == .cursor and (i < cl or (i == cl and at <= cc))) anchor = nrows; out_len += row.len; nrows += 1; } } // A word looked for that is nowhere opens nothing. if (!open_empty and nrows == 0) return 0; const content = try p.gpa.dupe(u8, out[0..out_len]); try panes.Output.fillResults(p, id, dir, .search, pat, content, anchor); return nrows; } pub fn jumpResult(p: *Pardes, id: usize, row: usize) bool { const pane = p.panes[id] orelse return false; const rid = pane.search_pane orelse return false; const rp = p.panes[rid] orelse return false; const rf = if (rp.file) |*f| f else return false; const tr = panes.Output.fileTraits(rf.output); const ln = modal.lineSlice(rf.content, row); if (ln.len == 0) return false; const r: i32 = @intCast(row); pane.search_row = row; // the visited result, selected back from its line's end rp.body.vsel = .{ .active = true, .row = r, .col = @intCast(ln.len), .explicit = true }; rp.body.nsel = 0; rp.body.cur_row = r; rp.body.cur_pinned = true; const off = rp.scroll(); const last = off + @as(i32, rp.rows) - 1; if (r < off) rp.scrollBy(r - off) else if (r > last) rp.scrollBy(r - last); var realbuf: [4096]u8 = undefined; const span = if (tr.commands) wholeRowSpan(ln) else lineSpan(p, ln, Pardes.paneDir(rp), &realbuf) orelse blk: { const target = panes.Output.location(ln); break :blk if (target.at.line > 0) Span{ .start = 0, .end = target.end } else null; }; if (span) |selected| { rp.body.cur_col = @intCast(selected.start); rp.look_at = .{ .row = r, .col0 = @intCast(selected.start), .col1 = @intCast(selected.end - 1), }; } else { rp.body.cur_col = 0; rp.look_at = null; } if (tr.commands) { exec.runBuiltin(p, config.exec_cmd, rid, "", std.mem.trim(u8, ln, " \t\r")); } else if (span) |selected| { lookAt(p, rid, ln[selected.start..selected.end]); // This is the newly visited result, not a selection carried into // the destination. Look cleared the previous source selection. rp.body.vsel = .{ .active = true, .row = r, .col = @intCast(ln.len), .explicit = true }; } armLookWalk(p, rid); return true; } const LookFrom = struct { row: i32, col: ?i32, strict: bool = false }; fn lookEdge(delta: i32) LookFrom { return .{ .row = if (delta > 0) 0 else std.math.maxInt(i32), .col = null }; } fn lookStand(pane: *Pane) LookFrom { if (pane.look_at) |s| if (s.row == pane.body.cur_row and s.col0 == pane.body.cur_col) return .{ .row = s.row, .col = s.col0, .strict = true }; // A selection on one row (a Restore brings the dot back as one, with no // walk remembered) is where the walk stands: from its start, past it // either way, as from a spot the walk landed on. const v = pane.body.vsel; if (v.active and v.explicit and v.row == pane.body.cur_row and v.col != pane.body.cur_col) return .{ .row = v.row, .col = @min(v.col, pane.body.cur_col), .strict = true }; return .{ .row = pane.body.cur_row, .col = pane.body.cur_col }; } fn lookWalkPanes(p: *Pardes, out: *[MAX_PANES]usize) []const usize { const v = p.view(); var n: usize = 0; // A command pane walked from (`make`'s errors): its own places first. if (commandPaneActive(p)) { out[0] = v.active; n = 1; } var i = p.n_look_src; while (i > 0) { i -= 1; const id = p.paneBySerial(p.look_src[i]) orelse continue; if (n > 0 and out[0] == id) continue; out[n] = id; n += 1; } const looked = n; for (p.panes, 0..) |slot, id| { const pane = slot orelse continue; const f = pane.file orelse continue; if (f.output == null) continue; for (out[0..looked]) |k| { if (k == id) break; } else { // insertion by serial descending — at most MAX_PANES // comparisons, which is not a sort worth naming var at = n; while (at > looked and p.panes[out[at - 1]].?.serial < pane.serial) : (at -= 1) out[at] = out[at - 1]; out[at] = id; n += 1; } } if (n == 0) { if (p.panes[v.active] == null) return out[0..0]; out[0] = v.active; n = 1; } return out[0..n]; } fn lookPast(col0: i32, from: LookFrom, on_start_row: bool, delta: i32) bool { if (!on_start_row) return true; const c = from.col orelse return true; if (delta > 0) return if (from.strict) col0 > c else col0 >= c; return if (from.strict) col0 < c else col0 <= c; } fn wholeRowSpan(ln: []const u8) ?Span { var lo: usize = 0; while (lo < ln.len and (ln[lo] == ' ' or ln[lo] == '\t')) lo += 1; const hi = std.mem.trimEnd(u8, ln, " \t\r").len; return if (hi > lo) .{ .start = lo, .end = hi } else null; } pub fn wordSpan(p: ?*pardes.Pardes, word: []const u8, cwd: []const u8, realbuf: *[4096]u8) ?Span { if (word.len == 0) return null; var lo: usize = 0; var hi: usize = word.len; while (lo < hi and std.mem.indexOfScalar(u8, lead_trim, word[lo]) != null) lo += 1; while (hi > lo and std.mem.indexOfScalar(u8, trail_trim, word[hi - 1]) != null) hi -= 1; if (lo < hi and resolve(p, word[lo..hi], cwd, realbuf) != .none) return .{ .start = lo, .end = hi }; if (lo == 0 and hi == word.len) return null; if (resolve(p, word, cwd, realbuf) == .none) return null; return .{ .start = 0, .end = word.len }; } fn lookSpanIn(p: *Pardes, pane: *Pane, from: LookFrom, delta: i32, budget: *usize) ?Pane.LookSpot { const lines = edit.paneCursorLines(p, &pane.body) catch return null; const nrows: i32 = @intCast(lines.len); if (nrows == 0) return null; const grain: panes.Output.Grain = if (pane.file) |*f| panes.Output.grain(f.output) else .word; const dir = Pardes.paneDir(pane); var realbuf: [4096]u8 = undefined; const start = std.math.clamp(from.row, 0, nrows - 1); var r = start; while (r >= 0 and r < nrows) : (r += delta) { if (budget.* == 0) return null; budget.* -= 1; const ln = lines[@intCast(r)]; if (pane.file) |*f| if (!panes.Output.isWalkRow(f, @intCast(r), ln)) continue; const on_start = r == start; switch (grain) { .word => { var best: ?Pane.LookSpot = null; var i: usize = 0; while (i < ln.len) { while (i < ln.len and (ln[i] == ' ' or ln[i] == '\t')) i += 1; const t0 = i; while (i < ln.len and ln[i] != ' ' and ln[i] != '\t') i += 1; if (i == t0) break; const sp = wordSpan(p, ln[t0..i], dir, &realbuf) orelse continue; const col0: i32 = @intCast(t0 + sp.start); if (!lookPast(col0, from, on_start, delta)) continue; best = .{ .row = r, .col0 = col0, .col1 = @intCast(t0 + sp.end - 1) }; if (delta > 0) break; // first one forward; keep the last one back } if (best) |b| return b; }, // one span per row, so there is nothing to keep and nothing to // scan past: the row either offers it or it does not .line, .whole => { const sp = span: { if (grain == .whole) break :span wholeRowSpan(ln); if (pane.file) |f| if (@as(usize, @intCast(r)) < f.location_rows.len) { const end = f.location_rows[@intCast(r)].location_end; if (end > 0) { const start_byte = if (f.output != null and std.meta.eql(f.output.?.from, panes.Output.Origin{ .query = .callstack })) @import("locations.zig").treePrefix(ln).end else 0; break :span @as(?Span, .{ .start = start_byte, .end = end }); } }; break :span lineSpan(p, ln, dir, &realbuf); } orelse continue; const col0: i32 = @intCast(sp.start); if (lookPast(col0, from, on_start, delta)) return .{ .row = r, .col0 = col0, .col1 = @intCast(sp.end - 1) }; }, } } return null; } /// A command pane has the keyboard: `n` there walks its own output. fn commandPaneActive(p: *Pardes) bool { const pane = p.panes[p.view().active] orelse return false; return pane.command != null and pane.file == null and p.view().header == null; } pub fn lookWalk(p: *Pardes, delta: i32) void { var buf: [MAX_PANES]usize = undefined; const order = lookWalkPanes(p, &buf); if (order.len == 0) return; // From a command pane the walk starts there, whoever walked last. const owner = if (commandPaneActive(p)) p.view().active else if (p.look_walk_owner) |serial| p.paneBySerial(serial) else null; const active_at = std.mem.indexOfScalar(usize, order, p.view().active) orelse 0; const at = if (owner) |wanted| std.mem.indexOfScalar(usize, order, wanted) orelse active_at else active_at; var from = lookStand(p.panes[order[at]] orelse return); var budget: usize = max_look_rows; var k: usize = 0; while (k <= order.len) : (k += 1) { // `+ 2 * len` only so the backward subtraction stays unsigned const idx = (if (delta > 0) at + k else at + 2 * order.len - k) % order.len; const pane = p.panes[order[idx]] orelse continue; if (lookSpanIn(p, pane, from, delta, &budget)) |spot| return landLookSpot(p, order[idx], pane, spot); if (budget == 0) return; // gave up mid-pane: stay put, stay reversible from = lookEdge(delta); } } fn landLookSpot(p: *Pardes, id: usize, pane: *Pane, spot: Pane.LookSpot) void { edit.pinPaneCursor(p, &pane.body); // fresh out of tty mode the cursor still tracks the shell pane.body.vsel = .{ .active = true, .row = spot.row, .col = spot.col1, .explicit = true }; pane.body.nsel = 0; pane.body.cur_row = spot.row; pane.body.cur_col = spot.col0; pane.body.cur_pinned = true; pane.look_at = spot; p.look_walk_owner = pane.serial; p.view().active = id; pane.ensureCursorVisible(); } pub fn cancelLookHover(p: *Pardes) void { p.look_hover_wait = null; p.look_hover_preview = null; } pub fn lookHoverPane(p: *const Pardes) ?usize { if (p.look_hover_preview) |preview| return preview.pane; if (p.look_hover_wait) |waiting| return waiting.pane; return null; } fn noteLookHover(p: *Pardes, col: u16, row: u16, body_hit: ?Mouse.BodyHit, tag_hit: ?TagHit) void { const id = mouse.paneAt(p, col, row) orelse return cancelLookHover(p); const pane = p.panes[id] orelse return cancelLookHover(p); _ = edit.pointerTextSelection(p, id, col, row, body_hit, tag_hit) orelse return cancelLookHover(p); if (p.look_hover_preview) |shown| if (shown.col == col and shown.row == row and shown.pane == id and shown.serial == pane.serial and mouse.sameBodyCell(shown.body_hit, body_hit) and Layer.sameCell(shown.tag_hit, tag_hit)) return; if (p.look_hover_wait) |waiting| if (waiting.col == col and waiting.row == row and waiting.pane == id and waiting.serial == pane.serial and mouse.sameBodyCell(waiting.body_hit, body_hit) and Layer.sameCell(waiting.tag_hit, tag_hit)) return; // Found nothing to open here a moment ago: the pointer resting on it // does not start another wait (and another frame) every frame. if (p.look_hover_refused) |refused| if (refused.col == col and refused.row == row and refused.pane == id and refused.serial == pane.serial and mouse.sameBodyCell(refused.body_hit, body_hit) and Layer.sameCell(refused.tag_hit, tag_hit)) return; p.look_hover_refused = null; cancelLookHover(p); p.look_hover_wait = .{ .col = col, .row = row, .pane = id, .serial = pane.serial, .body_hit = body_hit, .tag_hit = tag_hit }; } pub fn refreshLookHoverFromRaw(p: *Pardes) void { const v = p.view(); if (!v.pointer_inside or !v.raw_hover_intent) return; const mapped: struct { col: u16, row: u16 } = .{ .col = v.pointer_raw_col, .row = v.pointer_raw_row }; v.hover_col = mapped.col; v.hover_row = mapped.row; const body_hit: ?Mouse.BodyHit = if (v.pointer_body_hit) |mapped_hit| mouse.bodyHitForPane(p, mouse.paneAt(p, mapped.col, mapped.row) orelse return cancelLookHover(p), mapped_hit, false) orelse return cancelLookHover(p) else null; noteLookHover(p, mapped.col, mapped.row, body_hit, v.pointer_tag_hit); } pub fn advanceLookHover(p: *Pardes) void { const delay = config.look_preview_delay_frames; const waiting = if (p.look_hover_wait) |*w| w else return; waiting.frames +|= 1; if (waiting.frames < delay) return; const pane = p.panes[waiting.pane] orelse return cancelLookHover(p); if (pane.serial != waiting.serial) return cancelLookHover(p); const pointed = edit.pointerTextSelection(p, waiting.pane, waiting.col, waiting.row, waiting.body_hit, waiting.tag_hit) orelse { p.look_hover_refused = waiting.*; return cancelLookHover(p); }; const operand = exec.operandAt(p, pane, pointed.sel, true, true); if (operand.text == null or operand.text.?.len == 0) { p.look_hover_refused = waiting.*; return cancelLookHover(p); } var preview = operand.preview; if (preview) |*sel| sel.state = .done; p.look_hover_preview = .{ .col = waiting.col, .row = waiting.row, .pane = waiting.pane, .serial = waiting.serial, .sel = preview, .file_word = operand.file_word, .body_hit = waiting.body_hit, .tag_hit = waiting.tag_hit, }; p.look_hover_wait = null; } pub fn focusPaneLine(p: *Pardes, id: usize, at: Spot, landing: enum { center, keep }) void { if (id >= MAX_PANES) return; const pane = p.panes[id] orelse return; p.view().active = id; if (pane.collapsed) layout.toggleCollapse(p, id); pane.body.normal.clear(); // A kind's place is its `address`'s (lookKind). if (pane.addon != null) return; if (at.line == 0) return; if (pane.file) |*f| { if (at.line > panes.File.nlines(p.gpa, f)) return; if (landing == .center) { // center, clamp at top; a text that fits is shown whole const next = if (pane.textFits()) 0 else (at.line - 1) -| pane.rows / 2; if (next != f.scroll) { f.scroll = next; f.syntax_dirty = true; } } } pane.body.cur_row = @intCast(at.line - 1); pane.body.cur_col = if (at.col > 0) @intCast(at.col - 1) else 0; pane.body.cur_pinned = true; if (at.end_line != 0) return selectSpan(p, pane, at); pane.ensureCursorVisible(); } fn selectSpan(p: *Pardes, pane: *Pane, at: Spot) void { const text = edit.flatSurface(p, &pane.body) catch |err| return p.reportError(p.view().active, "look", err); // saturating, not `- 1`: `f.zig:0-5` is a legal thing to type and a // 1-based zero is the same nothing an absent number is const acol: i32 = @intCast(at.col -| 1); const ecol: i32 = if (at.end_col > 0) @intCast(at.end_col - 1) else std.math.maxInt(i32); const r = panes.Text.cellRange(text, @intCast(at.line -| 1), acol, @intCast(at.end_line -| 1), ecol); pane.body.setRange(text, 0, r, true); } fn openPaneTarget(p: *const Pardes, path: []const u8, at: Spot) ?Target { for (p.panes, 0..) |slot, i| { const tt = slot orelse continue; if (tt.addon) |k| if (std.mem.eql(u8, k.path, path)) { return .{ .pane = .{ .id = i, .at = at } }; }; const ff = if (tt.file) |*f| f else continue; if (!std.mem.eql(u8, ff.path, path)) continue; return .{ .pane = .{ .id = i, .at = at } }; } return null; } /// Navigation starts a new selection at the destination. pub fn clearNavigationSelection(p: *Pardes, pane: *Pane) void { const v = p.view(); pane.body.vsel = .{}; pane.body.nsel = 0; pane.body.select = false; pane.body.normal.clear(); pane.body.restore_cursor = false; pane.body.sticky_col = -1; for (0..pane.sel.len) |slot| pane.clearPointerSelection(slot); pane.sel = @splat(.{}); if (v.drag == .select and p.panes[v.drag.select.id] == pane) v.drag = .none; } /// The directories a relative name is looked for in, in order, as acme's /// look tries its window's and then the other windows' (Incl's come /// after, the caller's, as includename's): `first` (the pane's own, a /// plumb message's wdir), then the directory of each pane of the jump list /// but `from`, newest first, each once. pub const Dirs = struct { p: *Pardes, from: ?usize, seen: [MAX_PANES + 1][]const u8 = undefined, nseen: usize = 0, /// The next of the jump list's, counted from its newest. n: usize = 1, pub fn init(p: *Pardes, from: ?usize, first: ?[]const u8) Dirs { var d: Dirs = .{ .p = p, .from = from }; if (first) |dir| { d.seen[0] = dir; d.nseen = 1; d.n = 0; } return d; } pub fn next(d: *Dirs) ?[]const u8 { if (d.n == 0) { d.n = 1; return d.seen[0]; } const id = d.from orelse return null; const jumps = &d.p.view().jumps; cand: while (d.n <= jumps.n) { const k = jumps.list[jumps.n - d.n].pane; d.n += 1; if (k == id) continue; const dir = Pardes.paneDir(d.p.panes[k] orelse continue); for (d.seen[0..d.nseen]) |s| if (std.mem.eql(u8, s, dir)) continue :cand; d.seen[d.nseen] = dir; d.nseen += 1; return dir; } return null; } }; /// Resolve without changing focus or falling back to search. PDF links use /// the same location rules as an ordinary Look before offering a choice. fn resolveLookTarget(p: *Pardes, id: usize, txt: []const u8, realbuf: *[4096]u8) Target { const trimmed = std.mem.trim(u8, txt, " \t\r\n"); const pl = parsePathLine(trimmed); if (pl.path.len > 0) if (openPaneTarget(p, pl.path, pl.at)) |target| return target; var found: Target = .none; var dirs: Dirs = .init(p, id, if (p.panes[id]) |op| Pardes.paneDir(op) else null); while (dirs.next()) |dir| { if (pl.path.len > 0 and pl.path[0] != '/') { var joinbuf: [2048]u8 = undefined; if (std.fmt.bufPrint(&joinbuf, "{s}/{s}", .{ dir, pl.path }) catch null) |j| if (openPaneTarget(p, j, pl.at)) |target| return target; } found = resolve(p, txt, dir, realbuf); // `.`, `..`, `./x` are this pane's directory's, not another's. if (found != .none or pl.path.len == 0 or pl.path[0] == '/' or filesystem.dotRelative(pl.path)) break; } // Found nowhere else, a relative name is tried in Incl's directories, // as acme's includename tries its (look.c:500). if (found == .none and pl.path.len > 0 and pl.path[0] != '/' and !filesystem.dotRelative(pl.path)) for (p.incl.items) |dir| { found = resolve(p, txt, dir, realbuf); if (found != .none) break; }; return found; } fn locationText(p: *Pardes, path: []const u8, at: Spot) ?[]const u8 { if (std.mem.indexOfAny(u8, path, "\r\n") != null) return null; const arena = p.scratch.allocator(); if (at.line == 0) return arena.dupe(u8, path) catch null; if (at.end_line != 0) { if (at.col == 0 and at.end_col == 0) return std.fmt.allocPrint(arena, "{s}:{d}-{d}", .{ path, at.line, at.end_line }) catch null; return std.fmt.allocPrint(arena, "{s}:{d}:{d}-{d}:{d}", .{ path, at.line, at.col, at.end_line, at.end_col }) catch null; } if (at.col != 0) return std.fmt.allocPrint(arena, "{s}:{d}:{d}", .{ path, at.line, at.col }) catch null; return std.fmt.allocPrint(arena, "{s}:{d}", .{ path, at.line }) catch null; } fn canonicalLookLocation(p: *Pardes, id: usize, text: []const u8) ?[]const u8 { const trimmed = std.mem.trim(u8, text, " \t\r\n"); if (trimmed.len == 0) return null; var realbuf: [4096]u8 = undefined; switch (resolveLookTarget(p, id, trimmed, &realbuf)) { .none => return null, .url => |url| { if (url.len > 256) return null; for (url) |c| if (c <= 0x20 or c == 0x7f) return null; return p.scratch.allocator().dupe(u8, url) catch null; }, .file => |file| return locationText(p, file.path, file.at), .kind => |k| return locationText(p, k.path, .{}), .dir => |dir| return locationText(p, dir, .{}), .pane => |target| { if (target.id >= p.panes.len) return null; const pane = p.panes[target.id] orelse return null; if (pane.file) |file| return locationText(p, file.path, target.at); if (pane.addon) |k| if (k.path.len > 0) return locationText(p, k.path, target.at); var path: [32]u8 = undefined; return locationText(p, std.fmt.bufPrint(&path, config.pane_addr ++ "{d}", .{pane.serial}) catch unreachable, target.at); // `@p` and a u32 fit 32 }, } } /// A look that found nothing: said on the message row, logged as an `err` /// record, and marked so that /look reads back nothing (ninep/ctl.zig run). /// The most of a looked-at path or text a miss repeats; past it, its /// middle gives up to `…` (the Rerror cutter's rule), so the file's name at /// the end stays. const miss_path_cap = 256; fn missText(text: []const u8, buf: *[miss_path_cap + "…".len]u8) []const u8 { return pardes.ctlfs.fitErr(text, buf[0..miss_path_cap]); } fn missedLine(p: *Pardes, id: usize, path: []const u8, line: usize) void { var cut: [miss_path_cap + "…".len]u8 = undefined; missed(p, id, "{s} has no line {d}", .{ missText(path, &cut), line }); } /// Whether `:line:col`, `:line:col-col` or `:line:col-line:col` after a /// path names a column 0, which parsePathLine reads as no column. fn zeroColumn(rest: []const u8) bool { var fields = std.mem.splitScalar(u8, rest, ':'); _ = fields.next(); // before the first ':' _ = fields.next() orelse return false; // the line const col = fields.next() orelse return false; var ends = std.mem.splitScalar(u8, col, '-'); if (std.mem.eql(u8, ends.next().?, "0")) return true; if (ends.next()) |end| if (std.mem.eql(u8, end, "0")) return true; if (fields.next()) |end_col| if (std.mem.eql(u8, end_col, "0")) return true; return false; } /// Whether `text` ends in a `:line:col` place (each spelling zeroColumn /// knows) whose column is 0, line 0 included. fn zeroColumnTail(text: []const u8) bool { var i: usize = 0; while (std.mem.indexOfScalarPos(u8, text, i, ':')) |at| : (i = at + 1) { const rest = text[at..]; for (rest[1..]) |c| if (std.mem.indexOfScalar(u8, "0123456789:-", c) == null) break else { if (rest.len > 1 and std.ascii.isDigit(rest[1]) and zeroColumn(rest)) return true; }; } return false; } fn missed(p: *Pardes, id: usize, comptime fmt: []const u8, args: anytype) void { p.look_missed = true; var said: Kind.Buf(miss_path_cap + 64) = .{}; const why = said.print(fmt, args); var msg: Kind.Buf(miss_path_cap + 72) = .{}; // Shown on the pane; logged once, as the err below, not a msg too. p.fs.unlogged = true; p.setMessage(id, msg.print("Look: {s}", .{why})); p.fs.unlogged = false; const serial = if (p.panes[id]) |pane| pane.serial else 0; var rec: Kind.Buf(miss_path_cap + 96) = .{}; pardes.ctlfs.events.noteErrCounted(p, rec.print("{d} look: {s}", .{ serial, why })); } /// A plain word looked at in a pane, as acme's look3 does with one that /// names no file (look.c:210, search): its next place in that pane after /// the dot, wrapping to the top, is selected there. No +Search pane. fn lookWord(p: *Pardes, id: usize, pane: *Pane, word: []const u8) void { const ninep_pane = @import("ninep/pane.zig"); const f = pane.file orelse return; const text = f.content; const from: usize = @min(ninep_pane.dotOf(pane).q1, text.len); const at = std.mem.indexOfPos(u8, text, from, word) orelse (std.mem.indexOf(u8, text[0..@min(text.len, from + word.len -| 1)], word) orelse { var cut: [miss_path_cap + "…".len]u8 = undefined; return missed(p, id, "no match for \"{s}\"", .{missText(word, &cut)}); }); clearNavigationSelection(p, pane); ninep_pane.setDot(pane, .{ .q0 = @intCast(at), .q1 = @intCast(at + word.len) }); p.view().active = id; } /// `file:addr` or `:addr`, acme's look.c:450-543: a colon followed by an /// address character (addr.c:28, isaddrc) that is not a line spot this /// parser already reads (`file:12`, `file:12:5`). Not a URL. fn addressed(tok: []const u8) ?struct { path: []const u8, expr: []const u8 } { if (std.mem.indexOf(u8, tok, "://") != null) return null; const colon = std.mem.indexOfScalar(u8, tok, ':') orelse return null; const expr = tok[colon + 1 ..]; // A written look is a whole line: the path has no blanks, but a // pattern in the address may (`calc.py:/return a/`). if (std.mem.indexOfAny(u8, tok[0..colon], " \t") != null) return null; if (std.mem.indexOfAny(u8, expr, " \t") != null and std.mem.indexOfAny(u8, expr, "/?") == null) return null; if (expr.len == 0 or std.mem.indexOfScalar(u8, "0123456789+-/?$.#,;", expr[0]) == null) return null; // `file:12` is a path's line, looked at as a path; a bare `:12` (`:12:5`) // has no path, and is this pane's line, an address like any other. if (std.ascii.isDigit(expr[0])) { const pl = parsePathLine(tok); if (pl.at.line != 0 and pl.end == tok.len and pl.path.len > 0) return null; } return .{ .path = tok[0..colon], .expr = expr }; } pub fn searchStep(p: *Pardes, id: usize, delta: i32) bool { const pane = p.panes[id] orelse return false; const rid = pane.search_pane orelse return false; const rp = p.panes[rid] orelse return false; const rf = if (rp.file) |*f| f else return false; // one question covers both hazards: a freed slot can be reused by an // unrelated pane, and a buffer of PROSE has nowhere to step to const tr = panes.Output.fileTraits(rf.output); if (!tr.steps) return false; // fresh results: n starts at the first row, N has nothing behind it const nrows: i64 = @intCast(std.mem.count(u8, rf.content, "\n") + @intFromBool(rf.content.len > 0 and rf.content[rf.content.len - 1] != '\n')); var step: i64 = if (pane.search_row) |c| @as(i64, @intCast(c)) + delta else if (delta > 0) 0 else -1; if (delta == 0) return true; const direction: i64 = if (delta > 0) 1 else -1; while (step >= 0 and step < nrows) : (step += direction) { if (!panes.Output.isResultRow(rf, @intCast(step))) continue; _ = jumpResult(p, id, @intCast(step)); p.view().active = id; break; } return true; } /// A look at text that names nothing to open: a `./` name is a missing /// file, anything else a search for the text as written. /// `text` is what a word search looks for: the look as written, its blanks /// kept; `trimmed` what a name is read from. fn lookUnresolved(p: *Pardes, id: usize, pane: *Pane, trimmed: []const u8, text: []const u8) void { // A `./` or `../` name opened nothing: said, ENOENT, not searched // for as a word. What is missing is the pane's directory when // that is gone, else the file named. if (filesystem.dotRelative(trimmed)) { const dir = Pardes.paneDir(pane); var said: Kind.Buf(4096 + 104) = .{}; const gone = if (filesystem.localPath(dir)) |local| exec.kindOf(local) != .directory else false; if (gone) return p.reportFailure(id, said.print("look: {s}: no such directory", .{dir[0..@min(dir.len, 4096)]})); // A file not there is a miss, as `x` and `/abs/x` are: said and // logged, the write answered with nothing. var cut: [miss_path_cap + "…".len]u8 = undefined; return missed(p, id, "{s}: no such file", .{missText(trimmed, &cut)}); } // A raw terminal's clicks are its program's; a look written over // 9P is no keyboard input, and searches whatever the key mode. if (pane.addon != null or (pane.body.mode == .tty and !p.fs.serving)) return; if (text.len == 0) return; if (pane.file != null) return lookWord(p, id, pane, text); p.word_look = true; defer p.word_look = false; const rows = runSearch(p, id, text, .cursor, false) catch |err| { p.reportError(id, "search", err); return; }; if (rows == 0) { var cut: [miss_path_cap + "…".len]u8 = undefined; return missed(p, id, "no match for \"{s}\"", .{missText(trimmed, &cut)}); } clearNavigationSelection(p, pane); const at = pane.search_row; _ = searchStep(p, id, 1); if (at != null and pane.search_row == at) { pane.search_row = null; _ = searchStep(p, id, 1); } } /// Opens (or finds) `path` as Look would, `id`'s own pane when it is empty, /// and selects what `expr` addresses there from its dot. An address that /// does not evaluate moves nothing and says why (acme: no jump). fn lookAddress(p: *Pardes, id: usize, path: []const u8, expr: []const u8) void { const v = p.view(); const ninep_pane = @import("ninep/pane.zig"); const Addr = @import("ninep/addr.zig").Addr; var target = id; // A pane already open on the path is evaluated where it stands: Look's // own clean start would collapse its dot (and the looker's) before the // address ever read it, so `f:/re/` again would find the same match. var realbuf: [4096]u8 = undefined; const open: ?usize = if (path.len == 0) null else switch (resolveLookTarget(p, id, path, &realbuf)) { .pane => |t| if (t.id < MAX_PANES and p.panes[t.id] != null) t.id else null, else => null, }; // `@p:
`: that pane, or, not open, a miss said as one. const by_serial = std.mem.startsWith(u8, path, config.pane_addr); if (by_serial and open == null) return missed(p, id, "no pane {s}", .{path[0..@min(path.len, 32)]}); if (open) |o| target = o else if (path.len > 0) { // A path that names nothing to open: the whole of what was written // is looked for, as `zzq:2` is, and a miss quotes it as written. if (!by_serial and resolveLookTarget(p, id, path, &realbuf) == .none) return lookUnresolved(p, id, p.panes[id] orelse return, path.ptr[0 .. path.len + 1 + expr.len], path.ptr[0 .. path.len + 1 + expr.len]); const before = v.active; const failures = p.fs.failures; const was_missed = p.look_missed; lookAt(p, id, path); target = v.active; // Look said why it opened nothing (its placement refused, say): // that one failure is the look's, no miss of the address after it. if (p.fs.failures != failures or (p.look_missed and !was_missed)) return; // The path opened nothing (a search, or no such file): Look said so. if (target == before and target != id) return; } const pane = p.panes[target] orelse return; const f = pane.file orelse { if (pane.addon != null) return lookKind(p, id, target, expr, open == null and target != id); if ((by_serial or path.len == 0) and pane.isTerminal()) return lookTerminalAddress(p, id, target, expr); // Named as the pane is, the bare `:addr` (path empty) included. var serial_name: [32]u8 = undefined; const subject = if (pane.addon) |k| k.path else if (path.len > 0) path else std.fmt.bufPrint(&serial_name, config.pane_addr ++ "{d}", .{pane.serial}) catch unreachable; // `@p` and a u32 fit 32 var cut: [miss_path_cap + "…".len]u8 = undefined; return missed(p, id, "{s} is no text to address", .{missText(subject, &cut)}); }; if (!by_serial and path.len > 0 and (f.output != null or !std.mem.endsWith(u8, f.path, std.Io.Dir.path.basename(path)))) return; var a: Addr = .{ .text = f.content, .lim = null, .expr = expr }; // A miss names the file it was looked for in, and is that file's pane's. var cut: [miss_path_cap + "…".len]u8 = undefined; const name = missText(f.path, &cut); // A look whose address fails opens nothing: a pane it opened to read // the address in goes again, the miss said from the pane it came from. const opened_here = open == null and target != id; const r = a.address(ninep_pane.dotOf(pane)) orelse { // A line past the end says so as `file:N` does, whichever way it // was written: `:N has no line N`. if (std.fmt.parseInt(usize, expr, 10)) |line| { var placed: Kind.Buf(miss_path_cap + "…".len + 24) = .{}; const place = placed.print("{s}:{d}", .{ name, line }); if (!opened_here) return missedLine(p, target, place, line); p.removePane(target, null) catch |err| p.reportError(id, "look", err); if (p.panes[id] != null) v.active = id; return missedLine(p, id, place, line); } else |_| {} if (opened_here) return closeAndMiss(p, id, target, name, a.err); return missed(p, target, "{s}: {s}", .{ name, a.err }); }; if (a.i < expr.len or r.q0 > r.q1) { const why = if (r.q0 > r.q1) "addresses out of order" else "bad address syntax"; if (opened_here) return closeAndMiss(p, id, target, name, why); return missed(p, target, "{s}: {s}", .{ name, why }); } clearNavigationSelection(p, pane); ninep_pane.setDot(pane, r); v.active = target; } /// A place in a kind's pane, its `address`'s: one looked at in a list the /// kind made (`text`, a +PdfSections) handed with the list's name first. /// A miss is said as the kind said it (` has no page 99`), and a /// pane opened for it goes again, as for a file's line past its end. fn lookKind(p: *Pardes, id: usize, target: usize, expr_raw: []const u8, opened: bool) void { const slot = p.panes[target].?.addon.?; const expr = std.mem.trim(u8, expr_raw, " \t"); var buf: [512]u8 = undefined; const from: []const u8 = if (p.panes[id]) |src| if (src.file) |f| if (f.output) |o| if (o.from == .kind) o.arg() else "" else "" else "" else ""; const text = if (from.len > 0) std.fmt.bufPrint(&buf, "{s} {s}", .{ from, expr }) catch expr else expr; var said: Kind.Buf(160) = .{}; if (Kind.address(p, target, text, &said)) { if (p.panes[target]) |pane| clearNavigationSelection(p, pane); p.view().active = target; return; } var serial_name: [32]u8 = undefined; const subject = if (slot.path.len > 0) slot.path else std.fmt.bufPrint(&serial_name, config.pane_addr ++ "{d}", .{p.panes[target].?.serial}) catch unreachable; // `@p` and a u32 fit 32 var cut: [miss_path_cap + "…".len]u8 = undefined; const name = missText(subject, &cut); if (opened) { var kept: [miss_path_cap + "…".len]u8 = undefined; @memcpy(kept[0..name.len], name); p.removePane(target, null) catch |err| p.reportError(id, "look", err); if (p.panes[id] != null) p.view().active = id; return missed(p, id, "{s} {s}", .{ kept[0..name.len], if (said.len > 0) said.slice() else "is no text to address" }); } missed(p, id, "{s} {s}", .{ name, if (said.len > 0) said.slice() else "is no text to address" }); } /// A place as `address` takes it: `12`, `12:3`. fn spotText(at: Spot, buf: *[41]u8) []const u8 { if (at.col == 0) return std.fmt.bufPrint(buf, "{d}", .{at.line}) catch unreachable; // a usize fits 41 return std.fmt.bufPrint(buf, "{d}:{d}", .{ at.line, at.col }) catch unreachable; // two usizes fit 41 } fn closeAndMiss(p: *Pardes, id: usize, opened: usize, name: []const u8, why: []const u8) void { var kept: [miss_path_cap + "…".len]u8 = undefined; @memcpy(kept[0..name.len], name); p.removePane(opened, null) catch |err| p.reportError(id, "look", err); if (p.panes[id] != null) p.view().active = id; missed(p, id, "{s}: {s}", .{ kept[0..name.len], why }); } /// `@p:
`: any address over the terminal's body as its /// logical lines read (the lines a +Search lists as `@p:`), /// from its cursor; the match is selected there, as a +Search row's is. fn lookTerminalAddress(p: *Pardes, id: usize, target: usize, expr: []const u8) void { const Addr = @import("ninep/addr.zig").Addr; const pane = p.panes[target].?; const lines = edit.paneCursorLines(p, &pane.body) catch return missed(p, id, "{s}", .{"out of memory"}); var text: std.ArrayList(u8) = .empty; const arena = p.scratch.allocator(); const row: usize = @intCast(@max(0, pane.body.cur_row)); var dot: u32 = 0; for (lines, 0..) |ln, i| { if (i == row) dot = @intCast(text.items.len + @min(ln.len, @as(usize, @intCast(@max(0, pane.body.cur_col))))); text.appendSlice(arena, ln) catch |err| return p.reportError(id, "look", err); text.append(arena, '\n') catch |err| return p.reportError(id, "look", err); } var a: Addr = .{ .text = text.items, .lim = null, .expr = expr }; const r = a.address(.{ .q0 = dot, .q1 = dot }) orelse return missed(p, id, "{s}", .{a.err}); if (a.i < expr.len or r.q0 > r.q1) return missed(p, id, "{s}", .{if (r.q0 > r.q1) "addresses out of order" else "bad address syntax"}); const from = spotAt(text.items, r.q0); var at: Spot = .{ .line = from.line, .col = from.col }; if (r.q1 > r.q0) { // The last byte of the match, 1-based and inclusive, as a row's range. const to = spotAt(text.items, r.q1 - 1); at.end_line = to.line; at.end_col = to.col; } clearNavigationSelection(p, pane); focusPaneLine(p, target, at, .center); } /// The 1-based line and column of byte `q` of `text`. fn spotAt(text: []const u8, q: u32) struct { line: usize, col: usize } { const upto = text[0..@min(q, text.len)]; const line = std.mem.count(u8, upto, "\n") + 1; const start = if (std.mem.lastIndexOfScalar(u8, upto, '\n')) |nl| nl + 1 else 0; return .{ .line = line, .col = upto.len - start + 1 }; } /// A remembered place in `path` (Recent, the jumplist): the file opened or /// focused, then `at` clamped to it as it is now, a line past the end its /// last line, never a miss; a selection's two ends restored where they /// still fit. pub fn reopenAt(p: *Pardes, from: usize, path: []const u8, at: Spot) void { lookAt(p, from, path); const id = p.view().active; const pane = p.panes[id] orelse return; // A kind's place is its `address`'s (a PDF's page), quietly. if (pane.addon) |k| if (std.mem.eql(u8, k.path, path)) { var said: Kind.Buf(160) = .{}; var place: [41]u8 = undefined; if (at.line > 0) _ = Kind.address(p, id, spotText(.{ .line = at.line }, &place), &said); return; }; const f = if (pane.file) |*file| file else return; if (!std.mem.eql(u8, f.path, path)) return; // The empty "line" after a final newline is no line to land on. const n = @max(1, panes.File.nlines(p.gpa, f) - @intFromBool(std.mem.endsWith(u8, f.content, "\n"))); const clamp = struct { fn spot(text: []const u8, lines: usize, line: usize, col: usize) [2]usize { const l = std.math.clamp(line, 1, lines); // Its last character at most, never the newline after it, as // addr's `L:C` clamps. const width = @max(1, modal.lineSlice(text, l - 1).len); return .{ l, std.math.clamp(col, 1, width) }; } }; const head = clamp.spot(f.content, n, at.line, at.col); var to: Spot = .{ .line = head[0], .col = head[1] }; if (at.end_line != 0) { const end = clamp.spot(f.content, n, at.end_line, at.end_col); to.end_line = end[0]; to.end_col = end[1]; } clearNavigationSelection(p, pane); focusPaneLine(p, id, to, .center); // Said when the file no longer has the line, closed or open: the place // is its last line now. if (at.line > n or at.end_line > n) { var said: Kind.Buf(miss_path_cap + 64) = .{}; var cut: [miss_path_cap + "…".len]u8 = undefined; p.setMessage(id, said.print("{s} has {d} lines now: at its last", .{ missText(path, &cut), n })); } } /// Whether `pane` is the Recent query pane or the Jumplist list, whose rows /// are remembered places: a look at one clamps to the file as it is now. fn isRecentList(pane: *const Pane) bool { // A query pane over the recent files: its rows are remembered places. if (pane.query) |q| if (q.source == .recent) return true; const f = pane.file orelse return false; const o = f.output orelse return false; return std.meta.eql(o.from, panes.Output.Origin{ .cmd = .Jumplist }); } /// Whether `pane` is the History list, whose rows name dumps. pub fn isHistoryList(pane: *const Pane) bool { const f = pane.file orelse return false; const o = f.output orelse return false; return std.meta.eql(o.from, panes.Output.Origin{ .cmd = .History }); } // ---- a look on a diff line ---- /// The lines of a pane showing a diff, a .diff or .patch file or a /// finished command pane whose output is one (ansi.DiffOutput); null for /// any other pane. Good until the next step. pub fn diffLines(p: *Pardes, pane: *Pane) ?[]const []const u8 { if (pane.file) |*f| { if (pane.colorAlgo() != .diff) return null; return panes.File.cursorLines(p.scratch.allocator(), pane, f) catch null; } if (!pane.isTerminal()) return null; return p.diff_output.lines(p, pane); } /// The look address a diff line names (diff.targetAt): `path` for a /// `diff --git`, `---` or `+++` line, `path:N` for a `@@` line (its first /// new line) and a hunk line (its new line; a removed line's, the new line /// now standing where it was). The look of it is a regular one, as of that /// text selected by hand. Null for a line no part of a file section. pub fn diffAddress(pane: *const Pane, lines: []const []const u8, row: usize, buf: []u8) ?[]const u8 { const target = diff.targetAt(lines, row, pane.file == null) orelse return null; return target.address(buf); } /// What a click at byte `col` of line `row` of a diff pane takes: a file /// or hunk header anywhere, or a hunk line on its `+`/`-`/` ` prefix, is /// the address the line names (diffAddress); a hunk line's code is words, /// from `word_from` on, the prefix never one of them. Null when the line is /// no part of a diff. const DiffClick = struct { address: ?[]const u8 = null, word_from: usize = 0 }; /// What a click at byte `col` of row `row` takes, the one answer for every /// way a click arrives (the mouse, exec.operandAt; an empty look written /// back to `event`, events.expandAt; a whole line written to `look`): the /// address a row's producer gave it (a query pane's row on its address, /// Query.rowAddress), else the one the pane's language reads in the line (a /// diff's: diffClickIn); or where its words start, the address no part of /// them. `line` is the row's text it was read from, and the address's text /// in it ends at `end`. Null for a row that names no address. pub const RowAddress = struct { address: ?[]const u8 = null, word_from: usize = 0, line: []const u8, end: usize }; pub fn rowAddressAt(p: *Pardes, pane: *Pane, row: usize, col: usize, buf: []u8) ?RowAddress { if (panes.Query.rowAddress(pane, row, col, buf)) |address| { const f = &pane.file.?; return .{ .address = address, .line = modal.lineSlice(f.content, row), .end = f.location_rows[row].location_end }; } const lines = diffLines(p, pane) orelse return null; if (row >= lines.len) return null; const click = diffClickIn(pane, lines, row, col, buf) orelse return null; return .{ .address = click.address, .word_from = click.word_from, .line = lines[row], .end = lines[row].len }; } fn diffClickIn(pane: *const Pane, lines: []const []const u8, row: usize, col: usize, buf: []u8) ?DiffClick { if (row >= lines.len) return null; const line = lines[row]; const address = diffAddress(pane, lines, row, buf) orelse return null; const target = diff.targetAt(lines, row, pane.file == null) orelse return null; const prefixed = line.len > 0 and std.mem.indexOfScalar(u8, "+- ", line[0]) != null; switch (target.kind) { .context, .added, .removed => if (!(col == 0 and prefixed)) return .{ .word_from = @intFromBool(prefixed) }, else => {}, } return .{ .address = address }; } /// A look written over 9P of a whole line of a pane whose rows name /// addresses (a diff's, a query pane's: rowAddressAt), the cursor's line /// first, then the first after it: what a click on its first column takes. /// A blank context line (` `) is a line too. fn lineAddress(p: *Pardes, pane: *Pane, operand: []const u8, buf: []u8) ?[]const u8 { const text = std.mem.trimEnd(u8, operand, "\r\n"); if (text.len == 0) return null; const lines = (if (pane.query != null) panes.File.cursorLines(p.scratch.allocator(), pane, &pane.file.?) catch null else diffLines(p, pane)) orelse return null; const cur: usize = @intCast(@max(0, pane.body.cur_row)); for (0..lines.len) |k| { const i = (cur + k) % lines.len; if (std.mem.eql(u8, std.mem.trimEnd(u8, lines[i], "\r"), text)) return (rowAddressAt(p, pane, i, 0, buf) orelse return null).address; } return null; } fn noteLookSource(p: *Pardes, id: usize) void { const pane = p.panes[id] orelse return; var w: usize = 0; for (p.look_src[0..p.n_look_src]) |s| { if (s == pane.serial) continue; p.look_src[w] = s; w += 1; } if (w == p.look_src.len) { std.mem.copyForwards(u32, p.look_src[0 .. w - 1], p.look_src[1..w]); w -= 1; } p.look_src[w] = pane.serial; p.n_look_src = w + 1; p.look_walk_owner = pane.serial; } /// After a look at `path:N` focused its pane: a line past the end focuses /// nothing, leaves no pane it opened, and is a miss; a bare line number /// selects the line, its newline included, as acme's does. fn settleLine(p: *Pardes, id: usize, path: []const u8, at: Spot, before: usize, opened: ?usize) void { const shown = p.panes[p.view().active] orelse return; const f = if (shown.file) |*file| file else return; if (at.line > panes.File.nlines(p.gpa, f)) { if (opened) |free| p.removePane(free, null) catch |err| p.reportError(id, "look", err); if (p.panes[before] != null) p.view().active = before; return missedLine(p, id, path, at.line); } if (at.line > 0 and at.col == 0 and at.end_line == 0) { const start = modal.lineStartOffset(f.content, at.line - 1); const next = std.mem.indexOfScalarPos(u8, f.content, start, '\n'); const end = if (next) |i| i + 1 else f.content.len; @import("ninep/pane.zig").setDot(shown, .{ .q0 = @intCast(start), .q1 = @intCast(end) }); } } fn focusPaneByPath(p: *Pardes, path: []const u8, at: Spot) bool { const target = openPaneTarget(p, path, at) orelse return false; clearNavigationSelection(p, p.panes[target.pane.id].?); focusPaneLine(p, target.pane.id, target.pane.at, .center); return true; } /// A file that is there but would not open: said with its path, `look: /// : permission denied`, the path cut in its middle when long. fn lookOpenFailed(p: *Pardes, id: usize, path: []const u8, err: anyerror) void { if (@import("Messages.zig").dialReason(err) != null) return p.reportError(id, path, err); var cut: [miss_path_cap + "…".len]u8 = undefined; // Not there, on a peer's mount as on this host: a miss, the write // answered, as any path to no file is. const remote_missing = err == error.Remote and std.mem.indexOf(u8, @import("9p_io.zig").Client.lastSaid(), "not exist") != null; if (err == error.FileNotFound or err == error.NotFound or remote_missing) return missed(p, id, "{s}: no such file", .{missText(path, &cut)}); var said: Kind.Buf(miss_path_cap + 16) = .{}; p.reportError(id, said.print("look: {s}", .{missText(path, &cut)}), err); } pub fn lookAt(p: *Pardes, id: usize, operand_raw: []const u8) void { const v = p.view(); const pane = p.panes[id] orelse return; // `~/x`, `~/x:12`, `~/x:/re/`: home, before anything reads the text. // Anything else as written: a look of ` return x` is of those blanks // too (the path, address and command readings below trim for // themselves). var home_buf: [4096]u8 = undefined; const stripped = std.mem.trim(u8, operand_raw, " \t\r\n"); const operand = if (stripped.len > 0 and stripped[0] == '~') filesystem.expandHome(stripped, &home_buf) else std.mem.trimEnd(u8, operand_raw, "\r\n"); // A +History line names a dump of the state file's (`Restore