//! A file pane's text: its content and undo history, display columns, line //! index, syntax highlights and the body it fills. const panes = @import("panes.zig"); const std = @import("std"); const vaxis = @import("vaxis"); const builtin = @import("builtin"); const pardes = @import("pardes.zig"); const config = @import("config.zig"); const Pardes = pardes.Pardes; const Surface = pardes.Surface; const modal = @import("modal.zig"); const filesystem = @import("fs.zig"); const syntax = @import("syntax.zig"); const diff = @import("diff.zig"); const tracy = @import("tracy.zig"); const dump = @import("dump.zig"); const limits = @import("memory.zig").limits; const locations = @import("locations.zig"); const Colors = @import("colors.zig"); const Tables = @import("Tables.zig"); const Stream = @import("Stream.zig"); const Pane = panes.Pane; const Output = panes.Output; const Mini = panes.mini; const terminal = panes.terminal; const Text = panes.Text; const SYNTAX_CONTEXT_AFTER_ROWS: usize = 2; const long_paint: usize = 16 << 10; /// Content and primary selection at one file edit boundary. Keeping only the /// primary avoids putting Text.max_selections ranges in every history entry. pub const Snapshot = struct { content: []u8, cur_row: i32, cur_col: i32, vsel: Text.CharSel, /// The pane's name then, as History.gen counts its renames, and whether /// and as what the text was saved under it: an undo across a load into /// the pane under another name (Get file, Edit's e) puts the name back /// with the text, and the dirty state that went with them, as acme's /// undo does. No allocation a step: a name is kept once, at its rename. gen: u32 = 0, clean: bool = false, saved_hash: ?u64 = null, saved_len: ?usize = null, fn deinit(s: Snapshot, gpa: std.mem.Allocator) void { pardes.memory.freeUnfilled(gpa, s.content); } }; /// The pane's text, place and name now, for an undo or redo step. fn snapshotOf(gpa: std.mem.Allocator, pane: *const Pane, f: *const State) ?Snapshot { return .{ .content = pardes.memory.dupeUnfilled(gpa, f.content) catch return null, .cur_row = pane.body.cur_row, .cur_col = pane.body.cur_col, .vsel = pane.body.vsel, .gen = f.history.gen, .clean = f.revision == f.saved_revision, .saved_hash = f.saved_hash, .saved_len = f.saved_len, }; } /// A rename (ninep/pane.zig nameBuffer): the name it ends, kept for an undo /// back across it; `old` is the History's from here (owned), freed if it /// cannot be kept. pub fn noteRenamed(gpa: std.mem.Allocator, history: *History, old: []u8) void { history.names.append(gpa, .{ .gen = history.gen, .path = old }) catch gpa.free(old); history.gen +%= 1; } /// After a step's text went in: if it was under another name, that name /// back, and the step's saved state with it (Get file, Edit's e). fn restoreName(p: *Pardes, pane: *Pane, f: *State, snap: Snapshot) void { const history = f.history; if (snap.gen == history.gen) return; // The latest name kept for that generation. var at = history.names.items.len; const path = while (at > 0) { at -= 1; if (history.names.items[at].gen == snap.gen) break history.names.items[at].path; } else return; if (std.mem.eql(u8, path, f.path)) { history.gen = snap.gen; return; } const id = for (p.panes, 0..) |slot, i| { if (slot == pane) break i; } else return; // nameBuffer frees nothing of `path`: it keeps the name it ends. const back = p.gpa.dupe(u8, path) catch return; defer p.gpa.free(back); pardes.ctlfs.pane.nameBuffer(p, id, back, false) catch return; history.gen = snap.gen; f.saved_hash = snap.saved_hash; f.saved_len = snap.saved_len; f.saved_revision = if (snap.clean) f.revision else f.revision -% 1; f.disk_newer = null; f.disk_newer_warned = false; if (filesystem.localPath(path) != null) p.emit(.{ .watch = .{ .pane = @intCast(id), .on = true } }); } pub const History = struct { pub const replica = .{ .len = .{ .{ "undo", "undo_len" }, .{ "redo", "redo_len" } } }; undo: [limits.undo_max]Snapshot = undefined, undo_len: usize = 0, redo: [limits.undo_max]Snapshot = undefined, redo_len: usize = 0, /// The text `undo` and `redo` hold, kept near limits.undo_bytes. bytes: usize = 0, /// The names the file had, each with the rename generation it ended /// (Snapshot.gen), and the generation now. names: std.ArrayList(struct { gen: u32, path: []u8 }) = .empty, gen: u32 = 0, pub fn create(gpa: std.mem.Allocator) !*History { const history = try gpa.create(History); history.undo_len = 0; history.redo_len = 0; history.bytes = 0; history.names = .empty; history.gen = 0; return history; } pub fn destroy(history: *History, gpa: std.mem.Allocator) void { for (history.undo[0..history.undo_len]) |snap| snap.deinit(gpa); for (history.redo[0..history.redo_len]) |snap| snap.deinit(gpa); for (history.names.items) |name| gpa.free(name.path); history.names.deinit(gpa); gpa.destroy(history); } }; /// A file pane's backing: owned content, its derived caches, and undo history. pub const State = struct { /// What the replay digest leaves out (src/walk.zig): what is made again /// from the text whenever it is wanted. pub const replica = .{ .derived = .{ "line_starts", "highlights", "highlight_start", "syntax_dirty", "node_tree", "node_tree_revision", "node_history", "tables" } }; path: []u8, content: []u8, revision: u32 = 0, /// Revision last known to match disk, after Save or an external reload. /// Equal means the screen matches disk. saved_revision: u32 = 0, /// The text at `saved_revision`, hashed as the first edit after it /// replaces it: an edit that brings the text back to it is clean again, /// as an undo to the save point is in acme. saved_hash: ?u64 = null, /// The length of the text `saved_hash` is of, when it is of one: an /// edit to another length cannot be back to it, and is not hashed. saved_len: ?usize = null, watch_after_save: bool = false, /// The file changed on disk under unsaved edits, which were kept (see /// `changed`): its hash, so the same change is said once, until a Save /// or get settles it. A Save warns once before overwriting it, as acme's /// Put does (exec.c:577, "modified since last read"). disk_newer: ?u64 = null, disk_newer_warned: bool = false, /// Its file was deleted on disk: said once (`deleted`) until it is /// written or found again. disk_gone: bool = false, /// A +Pager pane (`pardes -`): no line numbers, its program's colours /// through Filter until it is toggled off. pager: bool = false, /// A +Pager whose text is a diff (`git diff`, `show`, `log -p`): drawn /// and looked at as a diff (Pane.colorAlgo). pager_diff: bool = false, /// A +Pager's colours, as its program printed them (pager.zig): drawn /// over its text by recolorSyntax, never read over 9P. ponytail: any /// edit drops them (setContentSpan); shifting them through the splice, /// as pane.zig's shiftOne moves dot, would keep them. pager_spans: []pardes.pager.Span = &.{}, /// The rows and spans an edit dropped, with the text they were for: an /// edit (an undo) back to that very text takes them again. dropped_marks: ?DroppedMarks = null, /// Seconds of the last content change, for the filesystem's stat; zero until edited. mtime: u32 = 0, /// Non-null for a generated output buffer rather than an on-disk file. output: ?Output.State = null, /// A directory pane's entries (Dir.zig), its output `.dir`. listing: ?panes.Dir.State = null, mini: ?Mini.State = null, scroll: usize = 0, /// `line_starts[i]` is line i's byte offset. Empty means not built yet. line_starts: []usize = &.{}, /// One tree_sitter_gpa-owned syntax.Syn byte per highlighted source byte. highlights: []u8 = &.{}, location_rows: []locations.Row = &.{}, /// The last edit's splice: what the text at `revision` kept of the one /// before it at either end (`old_len` long). A pane's places shift by it /// rather than search the whole text again (Places.shift). splice: struct { revision: u32 = 0, head: usize = 0, tail: usize = 0, old_len: usize = 0 } = .{}, highlight_start: usize = 0, syntax_dirty: bool = true, tree_context: bool = false, context_declarations: []syntax.ContextDeclaration = &.{}, context_revision: ?u32 = null, /// The whole file's parse for the keys that walk its nodes (Alt-o and /// kin), made on the first of them after an edit and kept until the next /// one: `syntax.parseTree`'s, opaque here. node_tree: ?*anyopaque = null, node_tree_revision: u32 = 0, /// helix's object_selections: what Alt-o grew from, for Alt-i to go back /// to; gpa-owned ranges and the primary's index. node_history: std.ArrayList(NodeStep) = .empty, /// A markdown text's pipe tables, laid out in their rows (Tables.zig): /// found again on the first body drawn after an edit. tables: Tables = .{}, history: *History, /// Zerox's group: the panes on one buffer share `content`, `history` /// and (while it is the one index) `line_starts`, each with its own /// scroll, cursor and syntax; 0, none. See `zerox`. twin: u32 = 0, }; pub const NodeStep = struct { ranges: []modal.Selection, primary: usize }; pub fn dumpPane( p: *Pardes, arena: std.mem.Allocator, pane: *const Pane, file: *const State, tag: []const u8, body: []const u8, scroll: usize, origin: []const u8, origin_arg: []const u8, ) !dump.Pane { const dirty = file.revision != file.saved_revision; const on_disk = onDisk(file.path); // A clean file's text is its file's: read from disk when restored, so // a change made there since is what comes back. Any other is kept, once. const from_disk = file.output == null and !dirty and on_disk; // What an unsaved pane's text was read against: the disk as it is, or, // when a change there was seen already, something it is not. const disk_hash: ?u64 = if (file.output != null or !dirty or !on_disk) null else if (file.disk_newer) |newer| newer +% 1 else blk: { const bytes = filesystem.read(p, file.path) catch break :blk null; defer p.gpa.free(bytes); break :blk std.hash.Wyhash.hash(0, bytes); }; return .{ .kind = .file, .tag = tag, .body = body, .scroll = scroll, .cols = pane.cols, .rows = pane.rows, .vweight = pane.vweight, .collapsed = pane.collapsed, .file = .{ .tree_context = file.tree_context, // A query pane's rows are its own (line 1 the query, gutter // numbers), not location rows Restore reads: it comes back as // plain text. .location_rows = if (pane.query != null) &.{} else try dumpLocationRows(arena, file.location_rows), .path = file.path, .content_b64 = if (from_disk) "" else try dump.encodeBytes(arena, file.content), .dirty = dirty, .disk_hash = disk_hash, .on_disk = on_disk, .origin = origin, .origin_arg = origin_arg, .mini_source = if (file.mini) |mini| mini.source else "", .mini_colors_b64 = if (file.mini) |mini| try dump.encodeBytes(arena, mini.colors) else "", }, }; } fn dumpLocationRows(arena: std.mem.Allocator, rows: []const locations.Row) ![]const dump.LocationRow { const saved = try arena.alloc(dump.LocationRow, rows.len); for (rows, saved) |row, *out| out.* = .{ .kind = @fromBackingInt(@intCast(@backingInt(row.kind))), .declaration = row.declaration, .mark_occurrence = row.mark_occurrence, .source_column = row.source_column, .path = row.path, .line = row.at.line, .col = row.at.col, .end_line = row.at.end_line, .end_col = row.at.end_col, .location_end = row.location_end, .code_start = row.code_start, .colors_b64 = try dump.encodeBytes(arena, row.colors), }; return saved; } fn sameSavedLocation(a: dump.LocationRow, b: dump.LocationRow) bool { return std.mem.eql(u8, a.path, b.path) and a.line == b.line and a.col == b.col and a.end_line == b.end_line and a.end_col == b.end_col; } fn restoreLocationRows(gpa: std.mem.Allocator, content: []const u8, saved: []const dump.LocationRow) ![]locations.Row { return restoreOutputLocationRows(gpa, content, saved, false); } fn restoreOutputLocationRows(gpa: std.mem.Allocator, content: []const u8, saved: []const dump.LocationRow, callstack: bool) ![]locations.Row { if (saved.len == 0) return &.{}; if (saved.len > std.mem.count(u8, content, "\n") + 1) return error.InvalidLocationRows; const rows = try gpa.alloc(locations.Row, saved.len); var initialized: usize = 0; errdefer { for (rows[0..initialized]) |row| { gpa.free(row.path); gpa.free(row.colors); } gpa.free(rows); } var lines = std.mem.splitScalar(u8, content, '\n'); var previous_line: []const u8 = ""; for (saved, rows, 0..) |row, *out, index| { const line = lines.next() orelse return error.InvalidLocationRows; if ((!callstack and row.path.len == 0) or row.path.len >= 4096 or row.location_end > row.code_start or row.code_start > line.len or (row.kind == .match and row.location_end == 0) or (row.declaration and row.kind != .context) or row.line > std.math.maxInt(i32) or row.col > std.math.maxInt(i32) or row.end_line > std.math.maxInt(i32) or row.end_col > std.math.maxInt(i32)) return error.InvalidLocationRows; if (callstack) { if (row.location_end > 0) { const prefix = locations.treePrefix(line); const parsed = locations.parseRaw(line[prefix.end..]); if (row.kind != .match or parsed.at.line == 0 or !std.mem.eql(u8, parsed.path, row.path) or parsed.at.line != row.line or parsed.at.col != row.col or parsed.at.end_line != row.end_line or parsed.at.end_col != row.end_col or prefix.end + parsed.end != row.location_end or prefix.end + parsed.code_start != row.code_start) return error.InvalidLocationRows; } else if (row.kind == .preview) { if (index == 0 or saved[index - 1].kind != .match or !sameSavedLocation(saved[index - 1], row)) return error.InvalidLocationRows; } else if (row.kind != .context or (row.path.len == 0 and (row.line != 0 or row.code_start != line.len))) return error.InvalidLocationRows; } else { const inline_row = row.code_start > row.location_end and row.code_start > 0 and line[row.code_start - 1] == '\t'; const address_row = !inline_row and row.location_end > 0 and row.code_start == line.len; const source_row = row.location_end == 0 and row.code_start == 0; if (!inline_row and !address_row and !source_row) return error.InvalidLocationRows; if (row.kind == .preview) { if (!source_row or index == 0) return error.InvalidLocationRows; const previous = saved[index - 1]; if (previous.kind != .match or previous.location_end == 0 or previous.code_start != previous_line.len or previous_line[previous_line.len - 1] == '\t' or !sameSavedLocation(previous, row)) return error.InvalidLocationRows; } if (address_row) { if (index + 1 >= saved.len) return error.InvalidLocationRows; const following = saved[index + 1]; const expected: @TypeOf(row.kind) = if (row.kind == .match) .preview else .context; if (following.kind != expected or following.code_start != 0 or following.location_end != 0 or following.declaration != row.declaration or !sameSavedLocation(row, following)) return error.InvalidLocationRows; } } const code_len = line.len - row.code_start; if (row.colors_b64.len > std.base64.standard.Encoder.calcSize(code_len)) return error.InvalidLocationRows; const colors = try dump.decodeBytes(gpa, row.colors_b64); errdefer gpa.free(colors); if (colors.len != 0 and colors.len != code_len) return error.InvalidLocationRows; for (colors) |color| if (color > @backingInt(syntax.Syn.comment)) return error.InvalidLocationRows; const path = try gpa.dupe(u8, row.path); out.* = .{ .kind = @fromBackingInt(@intCast(@backingInt(row.kind))), .declaration = row.declaration, .mark_occurrence = row.mark_occurrence, .source_column = row.source_column, .path = path, .at = .{ .line = row.line, .col = row.col, .end_line = row.end_line, .end_col = row.end_col }, .location_end = row.location_end, .code_start = row.code_start, .colors = colors, }; initialized += 1; previous_line = line; } if (lines.next()) |remaining| if (remaining.len != 0 or lines.next() != null) return error.InvalidLocationRows; return rows; } test "a clean pane whose file was never on disk comes back clean from a Restore; one whose file has gone is said deleted" { if (comptime !pardes.hosted) return; for ([_]bool{ false, true }) |was_on_disk| { const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true }); defer p.deinit(); while (p.nextEffect()) |_| {} const id = p.freeSlot().?; const pane = try restore(p, id, .{ .kind = .file, .tag = "", .body = "", .file = .{ .path = "/tmp/pardes-never-written/init", .content = "", .on_disk = was_on_disk }, }); try std.testing.expectEqual(was_on_disk, pane.file.?.disk_gone); try std.testing.expectEqual(pane.file.?.saved_revision, pane.file.?.revision); } } test "location metadata restore rejects offsets and invalid syntax bytes" { const gpa = std.testing.allocator; var row: dump.LocationRow = .{ .kind = .context, .path = "x.zig", .line = 1, .location_end = 0, .code_start = 3, }; const rows = try restoreLocationRows(gpa, "| \tx\n", &.{row}); defer locations.freeRows(gpa, rows); try std.testing.expectEqualStrings("x.zig", rows[0].path); row.code_start = 8; try std.testing.expectError(error.InvalidLocationRows, restoreLocationRows(gpa, "| \tx\n", &.{row})); row.code_start = 3; row.colors_b64 = "/w=="; try std.testing.expectError(error.InvalidLocationRows, restoreLocationRows(gpa, "| \tx\n", &.{row})); row.colors_b64 = ""; row.kind = .match; try std.testing.expectError(error.InvalidLocationRows, restoreLocationRows(gpa, "| \tx\n", &.{row})); } test "stacked location metadata requires matching adjacent preview ownership" { const gpa = std.testing.allocator; const header = "x.c:2:1-3"; const content = header ++ "\nfoo\n"; const match: dump.LocationRow = .{ .kind = .match, .path = "x.c", .line = 2, .col = 1, .end_line = 2, .end_col = 3, .location_end = header.len, .code_start = header.len }; const preview: dump.LocationRow = .{ .kind = .preview, .path = "x.c", .line = 2, .col = 1, .end_line = 2, .end_col = 3, .location_end = 0, .code_start = 0 }; const restored = try restoreLocationRows(gpa, content, &.{ match, preview }); defer locations.freeRows(gpa, restored); try std.testing.expectEqual(.preview, restored[1].kind); try std.testing.expectEqual(restored[0].at, restored[1].at); try std.testing.expectError(error.InvalidLocationRows, restoreLocationRows(gpa, "foo\n", &.{preview})); try std.testing.expectError(error.InvalidLocationRows, restoreLocationRows(gpa, header ++ "\n", &.{match})); var inline_match = match; inline_match.code_start += 1; try std.testing.expectError(error.InvalidLocationRows, restoreLocationRows(gpa, header ++ "\t\nfoo\n", &.{ inline_match, preview })); var wrong = preview; wrong.path = "other.c"; try std.testing.expectError(error.InvalidLocationRows, restoreLocationRows(gpa, content, &.{ match, wrong })); wrong = preview; wrong.line = 3; try std.testing.expectError(error.InvalidLocationRows, restoreLocationRows(gpa, content, &.{ match, wrong })); wrong = preview; wrong.code_start = 1; try std.testing.expectError(error.InvalidLocationRows, restoreLocationRows(gpa, content, &.{ match, wrong })); } pub fn graphemeDisplayWidth(grapheme: []const u8) usize { if (std.mem.eql(u8, grapheme, "\t")) return config.tab_now; if (grapheme.len == 1 and grapheme[0] >= 0x20 and grapheme[0] < 0x7f) return 1; if (std.unicode.utf8ValidateSlice(grapheme)) return @max(1, @as(usize, vaxis.gwidth.gwidth(grapheme, .unicode))); // vaxis's gwidth counts back a replacement rune's 3 bytes over the one // invalid byte it stood for (`\xee` before `e\u{301}` overflowed it): // each invalid byte is a cell, as surface.zig draws it, and each valid // run between is measured alone. var width: usize = 0; var run: usize = 0; var i: usize = 0; while (i < grapheme.len) { const n = std.unicode.utf8ByteSequenceLength(grapheme[i]) catch 0; if (n > 0 and i + n <= grapheme.len and std.unicode.utf8ValidateSlice(grapheme[i .. i + n])) { i += n; continue; } if (run < i) width += vaxis.gwidth.gwidth(grapheme[run..i], .unicode); width += 1; i += 1; run = i; } if (run < grapheme.len) width += vaxis.gwidth.gwidth(grapheme[run..], .unicode); return @max(1, width); } test "an invalid byte in a grapheme is one cell, and never reaches vaxis's width" { try std.testing.expectEqual(@as(usize, 2), graphemeDisplayWidth("\xeee\xcc\x81")); try std.testing.expectEqual(@as(usize, 3), graphemeDisplayWidth("\xee\xffe")); try std.testing.expectEqual(@as(usize, 3), graphemeDisplayWidth("\u{4e16}\x80")); // The whole path the 9P fuzzer took: a body holding it, fitted to a width. const text = "\xeee\xcc\x81"; try std.testing.expectEqual(@as(usize, 4), fitEnd(text, 0, 10)); } pub fn displayWidth(text: []const u8) usize { var width: usize = 0; var at: usize = 0; while (at < text.len) { const end = modal.nextGrapheme(text, at); width +|= graphemeDisplayWidth(text[at..end]); at = end; } return width; } /// Source byte at a zero-based display column. Every cell occupied by a tab /// maps back to that one tab byte. pub fn byteAtDisplay(text: []const u8, display_col: usize) usize { var col: usize = 0; var at: usize = 0; while (at < text.len) { const end = modal.nextGrapheme(text, at); const next = col +| graphemeDisplayWidth(text[at..end]); if (display_col < next) return at; col = next; at = end; } return text.len; } /// File cursor columns may live past EOL. Tabs expand before that boundary; /// every virtual column after it remains one screen cell. pub fn rawDisplayCol(line_text: []const u8, raw_col: usize) usize { const bounded = modal.graphemeStart(line_text, @min(raw_col, line_text.len)); return displayWidth(line_text[0..bounded]) +| (raw_col -| line_text.len); } /// Walked only as far as the column: a row's last byte, a million bytes /// into a line, is found without measuring the rest of it. Only a line /// that ends before the column is measured whole (it is short). pub fn rawAtDisplay(line_text: []const u8, display_col: usize) usize { const at = byteAtDisplay(line_text, display_col); if (at < line_text.len) return at; return line_text.len +| (display_col -| displayWidth(line_text)); } pub fn byteAtDisplayFrom(line_text: []const u8, from_raw: usize, display_col: usize) usize { if (from_raw >= line_text.len) return from_raw +| display_col; const from = modal.graphemeStart(line_text, from_raw); return from +| rawAtDisplay(line_text[from..], display_col); } /// The display columns from `from_raw` to `to_raw` on a line. Widths add /// (a tab is `tab_width` wherever it stands), so only the text between /// the two is measured, never the line from its start: a selection a /// million bytes into a line draws as fast as one at its start. pub fn lineDisplayOffset(line_text: []const u8, from_raw: usize, to_raw: usize) i32 { const lo = @min(from_raw, to_raw); const hi = @max(from_raw, to_raw); const a = modal.graphemeStart(line_text, @min(lo, line_text.len)); const b = modal.graphemeStart(line_text, @min(hi, line_text.len)); const past = (hi -| line_text.len) - (lo -| line_text.len); const width: usize = displayWidth(line_text[a..b]) +| past; return if (to_raw >= from_raw) @intCast(width) else -@as(i32, @intCast(width)); } pub fn lineDisplayEndOffset(line_text: []const u8, from_raw: usize, at_raw: usize) i32 { const start = lineDisplayOffset(line_text, from_raw, at_raw); if (at_raw >= line_text.len) return start; const at = modal.graphemeStart(line_text, at_raw); const end = modal.nextGrapheme(line_text, at); return start + @as(i32, @intCast(graphemeDisplayWidth(line_text[at..end]))) - 1; } pub fn sourceLine(pane: *const Pane, row: i32) []const u8 { const f = if (pane.file) |*file| file else return ""; if (row < 0) return ""; const line: usize = @intCast(row); if (f.line_starts.len == 0) return modal.lineSlice(f.content, line); if (line >= f.line_starts.len) return ""; const start = f.line_starts[line]; const end = if (line + 1 < f.line_starts.len) f.line_starts[line + 1] - 1 else f.content.len; return f.content[start..end]; } test "indexed source rows match uncached scans across content changes" { const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true }); defer p.deinit(); const pane = try p.setTestFile(""); const file = &pane.file.?; for ([_][]const u8{ "", "one", "one\n", "a\r\nλ界\nlast", "\n\n", "\tλ e\u{301}\n\r\n" }) |content| { setContent(p, file, try p.gpa.dupe(u8, content)); // An edit carries a built index forward; it must equal a fresh one. if (file.line_starts.len > 0) { const carried = file.line_starts; defer p.gpa.free(carried); file.line_starts = &.{}; try std.testing.expectEqualSlices(usize, try lineIndex(p.gpa, file), carried); p.gpa.free(file.line_starts); file.line_starts = &.{}; } const rows = lineCount(content) + 2; for ([_]bool{ false, true }) |indexed| { if (indexed) _ = try lineIndex(p.gpa, file); try std.testing.expectEqualStrings("", sourceLine(pane, -1)); for (0..rows) |row| try std.testing.expectEqualStrings( modal.lineSlice(content, row), sourceLine(pane, @intCast(row)), ); if (!indexed) try std.testing.expectEqual(@as(usize, 0), file.line_starts.len); } } } /// The pads `row` is laid out with in this pane: a row of a markdown /// table (Tables.zig) of its text as it is now, when the table fits the /// width a wrapping body has (a wider one is shown as its source, wrapped); /// else none. Every mapping between a file row's bytes and its cells goes /// through here, so the drawn row, the caret and a click cannot disagree. pub fn rowPads(pane: *const Pane, row: i32, out: *[Tables.max_pads]Tables.Pad) []const Tables.Pad { const table = rowTable(pane, row) orelse return &.{}; return pane.file.?.tables.padsOf(table, @intCast(row), sourceLine(pane, row), out); } /// The table `row` is laid out in, in this pane (`rowPads`). pub fn rowTable(pane: *const Pane, row: i32) ?*const Tables.Table { const f = if (pane.file) |*file| file else return null; if (row < 0 or f.tables.list.items.len == 0 or !f.tables.current(f)) return null; const table = f.tables.find(@intCast(row)) orelse return null; const width = wrapWidth(pane, pane.body_wrapped); if (width > 0 and table.width > width) return null; return table; } pub fn displayOffset(pane: *const Pane, row: i32, from_raw: i32, to_raw: i32) i32 { const line_text = sourceLine(pane, row); const from: usize = @intCast(@max(0, from_raw)); const to: usize = @intCast(@max(0, to_raw)); var buf: [Tables.max_pads]Tables.Pad = undefined; return lineDisplayOffset(line_text, from, to) + Tables.between(rowPads(pane, row, &buf), from, to); } pub fn displayEndOffset(pane: *const Pane, row: i32, from_raw: i32, at_raw: i32) i32 { const line_text = sourceLine(pane, row); const from: usize = @intCast(@max(0, from_raw)); const at: usize = @intCast(@max(0, at_raw)); var buf: [Tables.max_pads]Tables.Pad = undefined; return lineDisplayEndOffset(line_text, from, at) + Tables.between(rowPads(pane, row, &buf), from, at); } pub fn byteAtRowDisplay(pane: *const Pane, row: i32, from_raw: i32, display_col: i32) i32 { const line_text = sourceLine(pane, row); var buf: [Tables.max_pads]Tables.Pad = undefined; const pads = rowPads(pane, row, &buf); if (pads.len > 0) return @intCast(Tables.byteAt(line_text, pads, @intCast(@max(0, from_raw)), @intCast(@max(0, display_col)))); return @intCast(byteAtDisplayFrom(line_text, @intCast(@max(0, from_raw)), @intCast(@max(0, display_col)))); } pub fn gutterWidth(pane: *const Pane) u16 { if (pane.file == null) return 0; const file = &pane.file.?; // A +Pager, and a +Diff (hunks.zig), show no line numbers, as a // pager and delta show none. if (file.pager) return 0; if (file.output) |o| if (std.meta.eql(o.from, Output.Origin{ .cmd = .Diff })) return 0; // A query pane's rows carry their own line numbers (Query.zig). if (pane.query != null) return 0; var lines = if (file.line_starts.len > 0) file.line_starts.len else lineCount(file.content); var digits: u16 = 1; while (lines >= 10) : (lines /= 10) digits += 1; return @max(config.PREFIX_W, digits + 1); } /// Convert between rendered cells and UTF-8 byte columns. Tag rows always /// need grapheme conversion; file body rows additionally skip the gutter. pub fn renderedLineByteCol(pane: *const Pane, row: i32, line_text: []const u8, display_col: usize) usize { if (row < pane.tag_rows) return rawAtDisplay(line_text, display_col); if (pane.file == null) return rawAtDisplay(line_text, display_col); const prefix = @min(@as(usize, gutterWidth(pane)), line_text.len); if (display_col <= prefix) return display_col; return prefix +| rawAtDisplay(line_text[prefix..], display_col - prefix); } pub fn renderedLineDisplayCol(pane: *const Pane, row: i32, line_text: []const u8, byte_col: usize) usize { if (row < pane.tag_rows) return rawDisplayCol(line_text, byte_col); if (pane.file == null) return rawDisplayCol(line_text, byte_col); const prefix = @min(@as(usize, gutterWidth(pane)), line_text.len); if (byte_col <= prefix) return byte_col; return prefix +| rawDisplayCol(line_text[prefix..], byte_col - prefix); } test "the ASCII arm of graphemeDisplayWidth matches the gwidth it skips" { const ref = struct { fn width(grapheme: []const u8) usize { if (std.mem.eql(u8, grapheme, "\t")) return config.tab_now; return @max(1, @as(usize, vaxis.gwidth.gwidth(grapheme, .unicode))); } }.width; var one: [1]u8 = undefined; var b: u8 = 0; while (b < 0x80) : (b += 1) { one[0] = b; try std.testing.expectEqual(ref(one[0..1]), graphemeDisplayWidth(one[0..1])); } for ([_][]const u8{ "e\u{301}", "a\u{903}", "1\u{fe0f}\u{20e3}", "\u{4e16}", "\u{1f642}", "\u{1f1e6}\u{1f1e7}", "\xff", }) |g| try std.testing.expectEqual(ref(g), graphemeDisplayWidth(g)); // Two invalid bytes are two cells, as surface.zig draws them, where // vaxis's own count gives the pair one. try std.testing.expectEqual(@as(usize, 2), graphemeDisplayWidth("\xe4\xb8")); } test "the ASCII run in fitEnd survives an exhaustive byte sweep" { const reference = struct { fn fitEnd(text: []const u8, start: usize, width: usize) usize { var end = start; var used: usize = 0; while (end < text.len) { const next_end = modal.nextGrapheme(text, end); const next_used = used +| graphemeDisplayWidth(text[end..next_end]); if (next_used > width) return if (end == start) next_end else end; used = next_used; end = next_end; } return end; } }.fitEnd; const neighbours = [_][]const u8{ "", "z", "\u{301}", "\u{200d}\u{1f680}", "\u{903}", "\u{fe0f}", "\u{4e16}", "\u{1f642}", "\u{1f1e6}\u{1f1e7}", "\xff", "\xe4\xb8", "\xe4\x28\xb8", }; var buf: [16]u8 = undefined; // The same pair again behind an ASCII prefix, so a break can land exactly at the run boundary // as well as before it and inside the multi-byte cluster that follows it. var prefixed: [18]u8 = undefined; prefixed[0] = 'a'; prefixed[1] = 'b'; var b: u8 = 0; while (b < 0x80) : (b += 1) { buf[0] = b; for (neighbours) |tail| { @memcpy(buf[1..][0..tail.len], tail); const pair = buf[0 .. 1 + tail.len]; @memcpy(prefixed[2..][0..pair.len], pair); for ([_][]const u8{ pair, prefixed[0 .. 2 + pair.len] }) |text| { var width: usize = 0; while (width <= text.len + 3) : (width += 1) { var start: usize = 0; while (start <= text.len) : (start += 1) { std.testing.expectEqual( reference(text, start, width), fitEnd(text, start, width), ) catch |e| { std.debug.print("fitEnd({any}, {d}, {d})\n", .{ text, start, width }); return e; }; } } } } } } fn fitEnd(text: []const u8, start: usize, width: usize) usize { var end = start; var used: usize = 0; while (used < width and end < text.len) { const b = text[end]; if (b < 0x20 or b >= 0x7f) break; if (end + 1 < text.len and text[end + 1] >= 0x80) break; used += 1; end += 1; } while (end < text.len) { const next_end = modal.nextGrapheme(text, end); const next_used = used +| graphemeDisplayWidth(text[end..next_end]); if (next_used > width) return if (end == start) next_end else end; used = next_used; end = next_end; } return end; } test "the ASCII run in fitEnd cuts where the grapheme walk would" { const reference = struct { fn fitEnd(text: []const u8, start: usize, width: usize) usize { var end = start; var used: usize = 0; while (end < text.len) { const next_end = modal.nextGrapheme(text, end); const next_used = used +| graphemeDisplayWidth(text[end..next_end]); if (next_used > width) return if (end == start) next_end else end; used = next_used; end = next_end; } return end; } }.fitEnd; const cases = [_][]const u8{ "", "hello world", // the fast path must hand over at the first non-ASCII byte, mid-run "abc\u{00e9}def", // a wide glyph is two columns, so a width boundary can land inside it "ab\u{4e16}\u{754c}cd", // a cluster the fast path must not split "a\u{0301}bc", // tabs and controls are excluded from the fast path by the range test "ab\tcd", "ab\rcd", // an ASCII byte followed by a continuation byte is NOT its own cluster "e\u{0301}x", "\u{1f1e6}\u{1f1e7}ok", }; for (cases) |text| { var width: usize = 0; while (width <= text.len + 3) : (width += 1) { var start: usize = 0; while (start <= text.len) : (start += 1) { try std.testing.expectEqual( reference(text, start, width), fitEnd(text, start, width), ); } } } } pub fn lineCount(content: []const u8) usize { return std.mem.count(u8, content, "\n") + 1; } // Content changes invalidate this lazily rebuilt byte-offset index. pub fn lineIndex(gpa: std.mem.Allocator, f: *State) ![]const usize { if (f.line_starts.len > 0) return f.line_starts; // Exact allocation: deinitPane frees `line_starts` itself, so the stored // slice must span the complete allocation rather than spare capacity. const starts = try gpa.alloc(usize, lineCount(f.content)); starts[0] = 0; var i: usize = 1; var off: usize = 0; while (std.mem.indexOfScalarPos(u8, f.content, off, '\n')) |nl| { off = nl + 1; starts[i] = off; i += 1; } f.line_starts = starts; return starts; } /// The line index of `new` from `old`'s: an edit replaces one span, so /// line starts before it stand, starts after it shift, and only the span /// is scanned. Rebuilding scanned the whole file on every keystroke. /// The bytes a splice left alone at either end, when its caller knows them. pub const Span = struct { head: usize, tail: usize }; fn editedLineStarts(gpa: std.mem.Allocator, starts: []const usize, old: []const u8, new: []const u8, known: ?Span) ![]usize { const span = known orelse spanOf(old, new); const head = span.head; const tail = span.tail; // A start s follows the newline at s-1: kept while that newline is in // the common head, shifted while it is in the common tail. const kept = std.sort.upperBound(usize, starts, head, struct { fn order(key: usize, item: usize) std.math.Order { return std.math.order(key, item); } }.order); const old_tail_at = old.len - tail; const moved = starts.len - std.sort.upperBound(usize, starts, old_tail_at, struct { fn order(key: usize, item: usize) std.math.Order { return std.math.order(key, item); } }.order); const middle = new[head .. new.len - tail]; const out = try gpa.alloc(usize, kept + std.mem.count(u8, middle, "\n") + moved); @memcpy(out[0..kept], starts[0..kept]); var i = kept; var off: usize = 0; while (std.mem.indexOfScalarPos(u8, middle, off, '\n')) |nl| { off = nl + 1; out[i] = head + off; i += 1; } for (starts[starts.len - moved ..]) |start| { out[i] = start + new.len - old.len; i += 1; } return out; } test "edited line index equals a rebuilt one" { const gpa = std.testing.allocator; var prng = std.Random.DefaultPrng.init(7); const r = prng.random(); var text: std.ArrayList(u8) = .empty; defer text.deinit(gpa); for (0..300) |_| try text.append(gpa, "ab\n"[r.uintLessThan(usize, 3)]); for (0..2000) |_| { var old_state: State = undefined; old_state.content = text.items; old_state.line_starts = &.{}; const starts = try lineIndex(gpa, &old_state); defer gpa.free(starts); // one random replace, like any edit through setContent const at = r.uintAtMost(usize, text.items.len); const del = r.uintAtMost(usize, @min(8, text.items.len - at)); var ins: [8]u8 = undefined; const ins_len = r.uintAtMost(usize, 8); for (ins[0..ins_len]) |*c| c.* = "ab\n"[r.uintLessThan(usize, 3)]; const old = try gpa.dupe(u8, text.items); defer gpa.free(old); try text.replaceRange(gpa, at, del, ins[0..ins_len]); // As a splice that says what it kept, and as one that does not. const known: Span = .{ .head = at, .tail = old.len - at - del }; const told = try editedLineStarts(gpa, starts, old, text.items, known); defer gpa.free(told); const edited = try editedLineStarts(gpa, starts, old, text.items, null); try std.testing.expectEqualSlices(usize, edited, told); defer gpa.free(edited); var fresh_state: State = undefined; fresh_state.content = text.items; fresh_state.line_starts = &.{}; const fresh = try lineIndex(gpa, &fresh_state); defer gpa.free(fresh); try std.testing.expectEqualSlices(usize, fresh, edited); } } /// line count, O(1) once the index is warm pub fn nlines(gpa: std.mem.Allocator, f: *State) usize { const idx = lineIndex(gpa, f) catch return lineCount(f.content); return idx.len; } /// byte offset of line `row`, or content.len past the end — modal /// .lineStartOffset's contract exactly, without its walk pub fn lineStart(gpa: std.mem.Allocator, f: *State, row: usize) usize { const idx = lineIndex(gpa, f) catch return modal.lineStartOffset(f.content, row); return if (row >= idx.len) f.content.len else idx[row]; } pub fn cursorLines(arena: std.mem.Allocator, pane: *Pane, f: *State) ![]const []const u8 { const index = try lineIndex(pane.gpa, f); const lines = try arena.alloc([]const u8, index.len); for (index, 0..) |start, i| { const end = if (i + 1 < index.len) index[i + 1] - 1 else f.content.len; lines[i] = f.content[start..end]; } return lines; } /// Use the file's line index only when `text` is its complete live content. /// Edit-buffer fragments and other temporary text retain modal's scan path. fn contentIndex(t: *Text, text: []const u8) ?[]const usize { if (t.what != .body) return null; const pane = t.pane() orelse return null; const f = if (pane.file) |*file| file else return null; if (text.ptr != f.content.ptr or text.len != f.content.len) return null; return lineIndex(pane.gpa, f) catch null; } pub fn textOffset(t: *Text, text: []const u8, cursor: modal.Cursor) usize { const index = contentIndex(t, text) orelse return modal.offsetAt(text, cursor); const row = @min(cursor.row, index.len - 1); const start = index[row]; const end = if (row + 1 < index.len) index[row + 1] - 1 else text.len; return start + modal.graphemeStart(text[start..end], @min(cursor.col, end - start)); } pub fn textLineStart(t: *Text, text: []const u8, row: usize) usize { const index = contentIndex(t, text) orelse return modal.lineStartOffset(text, row); return if (row >= index.len) text.len else index[row]; } pub fn textLine(t: *Text, text: []const u8, row: usize) []const u8 { const index = contentIndex(t, text) orelse return modal.lineSlice(text, row); if (row >= index.len) return ""; const start = index[row]; const end = if (row + 1 < index.len) index[row + 1] - 1 else text.len; return text[start..end]; } test "indexed text rows preserve fragment and allocation failure semantics" { var allocator = std.testing.FailingAllocator.init(std.testing.allocator, .{}); const p = try Pardes.init(allocator.allocator(), .{ .tty_only = true }); defer p.deinit(); const pane = try p.setTestFile("first\n\tλ界\n\nlast\n"); const text = pane.file.?.content; allocator.fail_index = allocator.alloc_index; for (0..lineCount(text) + 2) |row| try std.testing.expectEqualStrings(modal.lineSlice(text, row), textLine(&pane.body, text, row)); try std.testing.expectEqual(@as(usize, 0), pane.file.?.line_starts.len); allocator.fail_index = std.math.maxInt(usize); _ = try lineIndex(p.gpa, &pane.file.?); allocator.fail_index = allocator.alloc_index; const allocations = allocator.allocations; for ([_][]const u8{ text, text[2..], text[0..8], "other\nrows\n\n", "" }) |fragment| { for (0..lineCount(fragment) + 2) |row| try std.testing.expectEqualStrings( modal.lineSlice(fragment, row), textLine(&pane.body, fragment, row), ); } try std.testing.expectEqual(allocations, allocator.allocations); } pub fn textLineCount(t: *Text, text: []const u8) usize { const index = contentIndex(t, text) orelse return modal.cursorLineCount(text); return index.len; } pub fn textPosition(t: *Text, text: []const u8, offset: usize) modal.Cursor { const index = contentIndex(t, text) orelse return modal.positionAt(text, offset); const bounded = @min(offset, text.len); const row = std.sort.upperBound(usize, index, bounded, struct { fn cmp(key: usize, item: usize) std.math.Order { return std.math.order(key, item); } }.cmp) - 1; const start = index[row]; const end = if (row + 1 < index.len) index[row + 1] - 1 else text.len; return .{ .row = row, .col = modal.graphemeStart(text[start..end], @min(bounded - start, end - start)) }; } pub fn open(p: *Pardes, id: usize, path: []const u8, line: usize) !*Pane { std.debug.assert(p.panes[id] == null and !p.reserved_slots[id]); const path_copy = try p.gpa.dupe(u8, path); errdefer p.gpa.free(path_copy); const pane = try terminal.createDoc(p.gpa, p.screen_w, p.screen_h); errdefer p.gpa.destroy(pane); const history = try History.create(p.gpa); errdefer p.gpa.destroy(history); p.reserved_slots[id] = true; defer p.reserved_slots[id] = false; const content = try filesystem.read(p, path); errdefer p.gpa.free(content); const total = lineCount(content); const scroll: usize = if (line > 0 and line <= total) line - 1 else 0; pane.file = .{ .path = path_copy, .content = content, .scroll = scroll, .history = history }; pane.body.cur_pinned = true; pane.body.cur_row = @intCast(scroll); p.installPane(id, pane); if (filesystem.localPath(path) != null) p.emit(.{ .watch = .{ .pane = @intCast(id), .on = true } }); return pane; } pub fn restore(p: *Pardes, id: usize, src: dump.Pane) !*Pane { const saved = src.file.?; if (saved.mini_source.len > 0) { const encoded_limit = std.base64.standard.Encoder.calcSize(Mini.max_output_bytes); if (saved.mini_source.len >= 4096 or saved.content.len > Mini.max_output_bytes or saved.content_b64.len > encoded_limit or saved.mini_colors_b64.len > encoded_limit) return error.InvalidMini; } // A clean file's text is read from its file: one changed on disk since // the dump comes back changed, never as the old text marked clean (and // a dump from before, which kept it, is read so too). Gone from disk, the // dump's text if it kept one. const from_disk: ?[]u8 = if (Output.fromWord(saved.origin) == null and !saved.dirty and saved.on_disk and saved.mini_source.len == 0 and filesystem.localPath(saved.path) != null) filesystem.read(p, saved.path) catch null else null; const content: []u8 = if (from_disk) |bytes| bytes else if (saved.content_b64.len > 0) try dump.decodeBytes(p.gpa, saved.content_b64) else try p.gpa.dupe(u8, saved.content); errdefer p.gpa.free(content); const path = try p.gpa.dupe(u8, saved.path); errdefer p.gpa.free(path); const output: ?Output.State = if (Output.fromWord(saved.origin)) |origin| blk: { var value: Output.State = .{ .from = origin }; try Output.setArg(&value, saved.origin_arg); break :blk value; } else null; if (saved.location_rows.len != 0 and output == null) return error.InvalidLocationRows; const is_callstack = if (output) |state| std.meta.eql(state.from, Output.Origin{ .query = .callstack }) else false; const location_rows = try restoreOutputLocationRows(p.gpa, content, saved.location_rows, is_callstack); errdefer locations.freeRows(p.gpa, location_rows); var mini: ?Mini.State = null; errdefer if (mini) |*state| state.deinit(p.gpa); if (saved.mini_source.len > 0) { if (output == null or !std.meta.eql(output.?.from, Output.Origin{ .cmd = .Mini })) return error.InvalidMini; const source = try p.gpa.dupe(u8, saved.mini_source); errdefer p.gpa.free(source); const colors = try dump.decodeBytes(p.gpa, saved.mini_colors_b64); errdefer p.gpa.free(colors); if (colors.len != content.len or colors.len > Mini.max_output_bytes) return error.InvalidMini; for (colors) |color| if (color > @backingInt(syntax.Syn.comment)) return error.InvalidMini; mini = .{ .source = source, .colors = colors }; } else if (saved.mini_colors_b64.len > 0) return error.InvalidMini; const history = try History.create(p.gpa); errdefer p.gpa.destroy(history); const pane = try p.newDocPane(id); pane.file = .{ .path = path, .content = content, .output = output, .mini = mini, .location_rows = location_rows, .scroll = src.scroll, .revision = @intFromBool(saved.dirty), // Restored with unsaved text, it has text to lose as an edited pane // has: a hash its text does not match, so Exit, Restore, Del and // get ask first (builtins.warnModifiedIn reads only edited panes). .saved_hash = if (saved.dirty) std.hash.Wyhash.hash(0, content) +% 1 else null, .history = history, }; pane.file.?.tree_context = saved.tree_context and supportsContext(pane); pane.body.cur_pinned = true; pane.body.cur_row = @intCast(src.scroll); // Its dot as it was, where the view the dump kept shows it. if (saved.dot) |dot| if (dot[0] <= dot[1] and dot[1] <= content.len) { const a = modal.positionAt(content, dot[0]); const h = modal.positionAt(content, if (dot[1] > dot[0]) modal.prevGrapheme(content, dot[1]) else dot[0]); pane.body.vsel = .{ .active = dot[1] > dot[0], .row = @intCast(a.row), .col = @intCast(a.col), .explicit = true }; pane.body.cur_row = @intCast(h.row); pane.body.cur_col = @intCast(h.col); }; pane.cols = @max(1, src.cols); pane.rows = @max(1, src.rows); // A directory pane is its directory as it is now, laid out at the next // sync; one that cannot be read keeps the text the dump kept. if (output) |o| if (o.from == .dir) { const f = &pane.file.?; if (panes.Dir.read(p.gpa, panes.Dir.ofName(path))) |names| { f.listing = .{ .names = names, .revision = f.revision }; } else |_| f.listing = .{ .names = &.{}, .revision = f.revision -% 1 }; }; if (output == null and filesystem.localPath(path) != null) p.emit(.{ .watch = .{ .pane = @intCast(id), .on = true, .mode = .baseline_disk } }); // Its file gone from disk since the dump: its text is nowhere else now, // so it comes back as one deleted on disk, dirty, and Del, Exit and // Restore ask before throwing it away. // One never on disk (Config's new file, a name not yet saved) is // restored as it was: clean, and nothing deleted. if (output == null and saved.on_disk and !onDisk(path)) deleted(p, @intCast(id)); // Unsaved, and its file changed on disk since the text was read: said, // and its first Save asks before overwriting the newer file. if (saved.disk_hash) |read_against| if (output == null and onDisk(path)) { if (filesystem.read(p, path)) |bytes| { defer p.gpa.free(bytes); if (std.hash.Wyhash.hash(0, bytes) != read_against) changed(p, @intCast(id), bytes); } else |_| {} }; // An older dump says nothing of what the text was read against: its // first Save asks, as for a file changed on disk, rather than guess. if (saved.dirty and saved.disk_hash == null and output == null and onDisk(path)) { if (filesystem.read(p, path)) |bytes| { defer p.gpa.free(bytes); const f = &pane.file.?; f.disk_newer = std.hash.Wyhash.hash(0, bytes); f.disk_newer_warned = false; } else |_| {} } return pane; } /// Whether `path` names a file on this host's disk now. fn onDisk(path: []const u8) bool { if (comptime !pardes.hosted) return false; const local = filesystem.localPath(path) orelse return false; return @import("exec.zig").kindOf(local) != null; } pub fn deinit(p: *Pardes, pane: *Pane, file: *State) void { if (file.output == null) for (p.panes, 0..) |slot, id| { if (slot == pane) p.emit(.{ .watch = .{ .pane = @intCast(id), .on = false } }); }; // A twin's text, undo and shared index stay with the twins left. var twins: [pardes.MAX_PANES]usize = undefined; const ntwins = twinsOf(p, file, &twins); const index_shared = for (twins[0..ntwins]) |id| { if (p.panes[id].?.file.?.line_starts.ptr == file.line_starts.ptr) break true; } else false; p.gpa.free(file.path); if (ntwins == 0) p.gpa.free(file.content); if (file.listing) |listing| p.gpa.free(listing.names); if (file.mini) |*mini| mini.deinit(p.gpa); if (file.line_starts.len > 0 and !index_shared) p.gpa.free(file.line_starts); if (file.highlights.len > 0) p.tree_sitter_gpa.free(file.highlights); p.gpa.free(file.pager_spans); locations.freeRows(p.gpa, file.location_rows); if (file.dropped_marks) |m| m.deinit(p.gpa); if (file.context_declarations.len > 0) p.tree_sitter_gpa.free(file.context_declarations); if (file.node_tree) |tree| syntax.freeTree(tree); for (file.node_history.items) |step| p.gpa.free(step.ranges); file.node_history.deinit(p.gpa); file.tables.deinit(p.gpa); if (ntwins > 0) return; file.history.destroy(p.gpa); } fn reportEdit(p: *Pardes, f: *State, new: []const u8) void { if (p.fs.listeners == 0) return; const id = for (p.panes, 0..) |slot, i| { const pane = slot orelse continue; if (pane.file) |*state| if (state == f) break i; } else return; pardes.ctlfs.events.noteReplace(p, id, false, f.content, new); } pub const DroppedMarks = struct { len: usize, hash: u64, rows: []locations.Row, spans: []pardes.pager.Span, fn deinit(m: DroppedMarks, gpa: std.mem.Allocator) void { locations.freeRows(gpa, m.rows); gpa.free(m.spans); } }; pub fn setContent(p: *Pardes, f: *State, new: []u8) void { setContentSpan(p, f, new, null); } /// `setContent` for a splice that knows what it left alone at either end, /// so the line index is not found again by comparing the whole text. pub fn setContentSpan(p: *Pardes, f: *State, new: []u8, span_in: ?Span) void { // Twins (Zerox) take the same splice: where it is, found once here when // the caller did not say, is what the line index wants anyway. var twins: [pardes.MAX_PANES]usize = undefined; const ntwins = twinsOf(p, f, &twins); // The views not live keep their place in it as twins do (views.zig). const viewed = pardes.views.several(p); const span: ?Span = span_in orelse if (ntwins > 0 or viewed) spanOf(f.content, new) else null; var parked: ParkedPlaces = .{}; if (viewed) parked.before(p, f, span.?, new.len); defer if (viewed) parked.after(p); var moved: [pardes.MAX_PANES]struct { cursor: usize, scroll: usize } = undefined; for (twins[0..ntwins], 0..) |id, i| { const t = p.panes[id].?; const tf = &t.file.?; const at = lineStart(p.gpa, tf, @intCast(@max(0, t.body.cur_row))) + @as(usize, @intCast(@max(0, t.body.cur_col))); moved[i] = .{ .cursor = spliced(@min(at, f.content.len), f.content.len, new.len, span.?), .scroll = spliced(lineStart(p.gpa, tf, tf.scroll), f.content.len, new.len, span.?) }; } const old_starts = f.line_starts.ptr; if (f.location_rows.len > 0 or f.pager_spans.len > 0) { if (f.dropped_marks) |m| m.deinit(p.gpa); f.dropped_marks = .{ .len = f.content.len, .hash = std.hash.Wyhash.hash(0, f.content), .rows = f.location_rows, .spans = f.pager_spans }; f.location_rows = &.{}; f.pager_spans = &.{}; } else if (f.dropped_marks) |m| if (m.len == new.len and m.hash == std.hash.Wyhash.hash(0, new)) { f.location_rows = m.rows; f.pager_spans = m.spans; f.dropped_marks = null; }; for (p.panes) |slot| if (slot) |pane| { if (pane.file) |*file| if (file == f) { for (0..pane.sel.len) |button| { pane.clearPointerSelection(button); pane.sel[button].state = .none; } }; }; reportEdit(p, f, new); if (f.mini) |*mini| mini.deinit(p.gpa); f.mini = null; // Found once for the line index and the places both (32 bytes a step). const known = span orelse spanOf(f.content, new); const starts: []usize = if (f.line_starts.len > 0) editedLineStarts(p.gpa, f.line_starts, f.content, new, known) catch &.{} else &.{}; const old_len = f.content.len; // ponytail: a whole-text hash per edit that keeps the saved length; a // rolling hash when that too matters. if (f.revision == f.saved_revision or f.saved_hash == null) { f.saved_hash = std.hash.Wyhash.hash(0, f.content); f.saved_len = f.content.len; } // Raw: `free` overwrites a safe build's freed memory, a whole file's // worth per keystroke. if (f.content.len > 0) p.gpa.rawFree(f.content, .of(u8), @returnAddress()); f.content = new; f.revision +%= 1; f.splice = .{ .revision = f.revision, .head = known.head, .tail = known.tail, .old_len = old_len }; if (f.saved_hash) |h| if ((f.saved_len orelse new.len) == new.len and std.hash.Wyhash.hash(0, new) == h) { f.saved_revision = f.revision; }; // The clock the session that recorded read (src/tape.zig). f.mtime = pardes.tape.value(.mtime, pardes.ctlfs.events.now, .{}); if (f.line_starts.len > 0) p.gpa.free(f.line_starts); f.line_starts = starts; if (f.highlights.len > 0) p.tree_sitter_gpa.free(f.highlights); f.highlights = &.{}; f.highlight_start = 0; f.syntax_dirty = true; if (f.pager) f.pager_diff = looksLikeDiff(new[0..@min(new.len, 64 * 1024)]); for (twins[0..ntwins], 0..) |id, i| { const t = p.panes[id].?; const tf = &t.file.?; // Its own index, built while the shared one was empty, goes; the // shared one, freed above, is replaced. if (tf.line_starts.len > 0 and tf.line_starts.ptr != old_starts) p.gpa.free(tf.line_starts); tf.content = f.content; tf.line_starts = f.line_starts; tf.revision = f.revision; tf.saved_revision = f.saved_revision; tf.saved_hash = f.saved_hash; tf.saved_len = f.saved_len; tf.mtime = f.mtime; if (tf.highlights.len > 0) p.tree_sitter_gpa.free(tf.highlights); tf.highlights = &.{}; tf.highlight_start = 0; tf.syntax_dirty = true; locations.freeRows(p.gpa, tf.location_rows); tf.location_rows = &.{}; if (tf.mini) |*mini| mini.deinit(p.gpa); tf.mini = null; for (0..t.sel.len) |button| { t.clearPointerSelection(button); t.sel[button].state = .none; } t.body.vsel.active = false; t.body.msel.active = false; t.body.nsel = 0; const cursor = positionIn(p.gpa, tf, moved[i].cursor); t.body.cur_row = @intCast(cursor.row); t.body.cur_col = @intCast(cursor.col); tf.scroll = positionIn(p.gpa, tf, moved[i].scroll).row; } } /// Each other view's cursor and scroll on a text being changed, as offsets /// moved by the splice (`spliced`), put back as places in the new text once /// it is in: a view not live keeps its place, as a twin does. Its /// selections go, as a twin's do. const ParkedPlaces = struct { const max = pardes.MAX_PANES * pardes.views.max; at: [max]struct { pane: *Pane, view: u8, cursor: usize, scroll: usize } = undefined, n: usize = 0, fn before(pp: *ParkedPlaces, p: *Pardes, f: *State, span: Span, new_len: usize) void { for (p.panes) |slot| { const pane = slot orelse continue; const tf = if (pane.file) |*file| file else continue; if (tf != f and (f.twin == 0 or tf.twin != f.twin)) continue; for (0..pardes.views.max) |k| { if (k == p.view or !pardes.views.isOpen(p, @intCast(k)) or pp.n == max) continue; const v = &pane.pv[k]; const at = lineStart(p.gpa, tf, @intCast(@max(0, v.body.cur_row))) + @as(usize, @intCast(@max(0, v.body.cur_col))); pp.at[pp.n] = .{ .pane = pane, .view = @intCast(k), .cursor = spliced(@min(at, f.content.len), f.content.len, new_len, span), .scroll = spliced(@min(lineStart(p.gpa, tf, v.scroll), f.content.len), f.content.len, new_len, span), }; pp.n += 1; } } } fn after(pp: *ParkedPlaces, p: *Pardes) void { for (pp.at[0..pp.n]) |a| { const tf = &(a.pane.file orelse continue); const v = &a.pane.pv[a.view]; const cursor = positionIn(p.gpa, tf, @min(a.cursor, tf.content.len)); v.body.cur_row = @intCast(cursor.row); v.body.cur_col = @intCast(cursor.col); v.body.vsel.active = false; v.body.msel.active = false; v.body.nsel = 0; v.scroll = positionIn(p.gpa, tf, @min(a.scroll, tf.content.len)).row; } } }; /// Where an offset into the old text is in the new, after the splice that /// kept `span` at either end: past it, moved by what it added; inside it, /// at its start, as acme moves a clone's q0 (textinsert, textdelete). fn spliced(at: usize, old_len: usize, new_len: usize, span: Span) usize { if (at <= span.head) return at; if (at >= old_len - span.tail) return at - (old_len - span.tail) + (new_len - span.tail); return span.head; } /// What `old` and `new` agree on at either end. /// What `new` kept of `old` at either end, compared 32 bytes at a time /// (a byte at a time was most of a `d` in a 7 MB file). pub fn spanOf(old: []const u8, new: []const u8) Span { const block = 32; const n = @min(old.len, new.len); var head: usize = 0; while (head + block <= n and std.mem.eql(u8, old[head..][0..block], new[head..][0..block])) head += block; while (head < n and old[head] == new[head]) head += 1; var tail: usize = 0; while (tail + block <= n - head and std.mem.eql(u8, old[old.len - tail - block ..][0..block], new[new.len - tail - block ..][0..block])) tail += block; while (tail < n - head and old[old.len - 1 - tail] == new[new.len - 1 - tail]) tail += 1; return .{ .head = head, .tail = tail }; } test "spanOf by blocks finds the byte loop's ends" { var prng: std.Random.DefaultPrng = .init(5); const random = prng.random(); var a: [160]u8 = undefined; var b: [160]u8 = undefined; for (0..4000) |_| { const la = random.uintLessThan(usize, a.len); const lb = random.uintLessThan(usize, b.len); for (a[0..la]) |*c| c.* = "ab"[random.uintLessThan(usize, 2)]; const keep = @min(la, lb); @memcpy(b[0..keep], a[0..keep]); for (b[keep..lb]) |*c| c.* = "ab"[random.uintLessThan(usize, 2)]; if (lb > 0 and random.boolean()) b[random.uintLessThan(usize, lb)] ^= 1; const old = a[0..la]; const new = b[0..lb]; const n = @min(old.len, new.len); const head = std.mem.indexOfDiff(u8, old[0..n], new[0..n]) orelse n; var tail: usize = 0; while (tail < n - head and old[old.len - 1 - tail] == new[new.len - 1 - tail]) tail += 1; try std.testing.expectEqual(Span{ .head = head, .tail = tail }, spanOf(old, new)); } } fn positionIn(gpa: std.mem.Allocator, f: *State, at: usize) struct { row: usize, col: usize } { const index = lineIndex(gpa, f) catch { const c = modal.positionAt(f.content, at); return .{ .row = c.row, .col = c.col }; }; const row = std.sort.upperBound(usize, index, at, struct { fn order(key: usize, item: usize) std.math.Order { return std.math.order(key, item); } }.order) -| 1; return .{ .row = row, .col = at - index[row] }; } /// The other panes on `f`'s buffer (Zerox), by id. pub fn twinsOf(p: *Pardes, f: *const State, out: *[pardes.MAX_PANES]usize) usize { if (f.twin == 0) return 0; var n: usize = 0; for (p.panes, 0..) |slot, id| { const pane = slot orelse continue; const other = if (pane.file) |*file| file else continue; if (other == f or other.twin != f.twin) continue; out[n] = id; n += 1; } return n; } /// acme's Zerox: pane `to` made on `from`'s buffer, its text, undo and /// dirty state shared, its scroll and cursor its own. An edit in either is /// spliced into both (setContentSpan, O(the edit) more); what Save and the /// disk watch change on one is copied to the others after each step /// (syncTwins). An event reader on one hears no edit made in another. pub fn zerox(p: *Pardes, from: usize, to: usize) !*Pane { const src = p.panes[from].?; const f = &src.file.?; const path = try p.gpa.dupe(u8, f.path); errdefer p.gpa.free(path); if (f.twin == 0) { const group = try p.gpa.dupe(u8, f.path); errdefer p.gpa.free(group); try p.twin_groups.append(p.gpa, .{ .id = p.next_twin, .saved_revision = f.saved_revision, .saved_hash = f.saved_hash, .saved_len = f.saved_len, .disk_newer = f.disk_newer, .disk_gone = f.disk_gone, .path = group }); f.twin = p.next_twin; p.next_twin +%= 1; } const pane = try p.newDocPane(to); pane.file = .{ .path = path, .content = f.content, .line_starts = f.line_starts, .history = f.history, .revision = f.revision, .saved_revision = f.saved_revision, .saved_hash = f.saved_hash, .saved_len = f.saved_len, .disk_newer = f.disk_newer, .disk_gone = f.disk_gone, .mtime = f.mtime, .scroll = f.scroll, .tree_context = f.tree_context, .twin = f.twin, }; pane.body.cur_row = src.body.cur_row; pane.body.cur_col = src.body.cur_col; pane.body.cur_pinned = true; if (filesystem.localPath(path) != null) p.emit(.{ .watch = .{ .pane = @intCast(to), .on = true } }); return pane; } /// A twin closed: it keeps a text of its own until it is torn down (a /// retired pane is drawn going), and the twins keep the shared one, its /// undo and its index. pub fn leaveTwins(p: *Pardes, f: *State) void { var twins: [pardes.MAX_PANES]usize = undefined; const n = twinsOf(p, f, &twins); f.twin = 0; if (n == 0) return; const shared_index = for (twins[0..n]) |id| { if (p.panes[id].?.file.?.line_starts.ptr == f.line_starts.ptr) break true; } else false; if (shared_index) f.line_starts = &.{}; f.content = p.gpa.dupe(u8, f.content) catch p.gpa.alloc(u8, 0) catch &.{}; f.history = History.create(p.gpa) catch f.history; // The one left is no twin now (syncTwins drops the group). if (n == 1) p.panes[twins[0]].?.file.?.twin = 0; } /// Restore's: pane `id`, restored on its own, back on pane `of`'s buffer /// as the Zerox twin it was dumped as (dump.File.twin_of). Not a file pane /// there (a dump edited by hand), it stays on its own. pub fn relink(p: *Pardes, of: usize, id: usize, dot: ?[2]u32) void { const src = p.panes[of] orelse return; const pane = p.panes[id] orelse return; const sf = if (src.file) |*file| file else return; const f = if (pane.file) |*file| file else return; if (sf.output != null or f.output != null or sf.mini != null) return; if (sf.twin == 0) { const group = p.gpa.dupe(u8, sf.path) catch return; p.twin_groups.append(p.gpa, .{ .id = p.next_twin, .saved_revision = sf.saved_revision, .saved_hash = sf.saved_hash, .saved_len = sf.saved_len, .disk_newer = sf.disk_newer, .disk_gone = sf.disk_gone, .path = group }) catch return p.gpa.free(group); sf.twin = p.next_twin; p.next_twin +%= 1; } p.gpa.free(f.content); if (f.line_starts.len > 0) p.gpa.free(f.line_starts); f.history.destroy(p.gpa); f.content = sf.content; f.line_starts = sf.line_starts; f.history = sf.history; f.revision = sf.revision; f.saved_revision = sf.saved_revision; f.saved_hash = sf.saved_hash; f.saved_len = sf.saved_len; f.twin = sf.twin; if (f.highlights.len > 0) p.tree_sitter_gpa.free(f.highlights); f.highlights = &.{}; f.syntax_dirty = true; // Its dot as dumped, read now that its text is back. if (dot) |d| if (d[0] <= d[1] and d[1] <= f.content.len) { const a = modal.positionAt(f.content, d[0]); const h = modal.positionAt(f.content, if (d[1] > d[0]) modal.prevGrapheme(f.content, d[1]) else d[0]); pane.body.vsel = .{ .active = d[1] > d[0], .row = @intCast(a.row), .col = @intCast(a.col), .explicit = true }; pane.body.cur_row = @intCast(h.row); pane.body.cur_col = @intCast(h.col); }; } pub const TwinGroup = struct { id: u32, saved_revision: u32, saved_hash: ?u64, saved_len: ?usize, disk_newer: ?u64, disk_gone: bool, path: []u8, }; /// After each step: what a Save, a get, the disk watch or a rename changed /// on one twin is copied to the others; a group down to one pane is no /// group. O(panes) a step, and nothing at all with no twins. pub fn syncTwins(p: *Pardes) void { var g: usize = 0; while (g < p.twin_groups.items.len) { const group = &p.twin_groups.items[g]; var members: [pardes.MAX_PANES]*State = undefined; var member_panes: [pardes.MAX_PANES]*Pane = undefined; var n: usize = 0; for (p.panes) |slot| { const pane = slot orelse continue; const f = if (pane.file) |*file| file else continue; if (f.twin == group.id) { members[n] = f; member_panes[n] = pane; n += 1; } } if (n < 2) { if (n == 1) members[0].twin = 0; p.gpa.free(group.path); _ = p.twin_groups.swapRemove(g); continue; } for (members[0..n]) |f| { if (f.saved_revision == group.saved_revision and f.saved_hash == group.saved_hash and f.saved_len == group.saved_len and f.disk_newer == group.disk_newer and f.disk_gone == group.disk_gone and std.mem.eql(u8, f.path, group.path)) continue; // This one changed: the group, and every other twin, take it. if (!std.mem.eql(u8, f.path, group.path)) { const path = p.gpa.dupe(u8, f.path) catch break; p.gpa.free(group.path); group.path = path; } group.saved_revision = f.saved_revision; group.saved_hash = f.saved_hash; group.saved_len = f.saved_len; group.disk_newer = f.disk_newer; group.disk_gone = f.disk_gone; for (members[0..n], member_panes[0..n]) |other, other_pane| { if (other == f) continue; other.saved_revision = f.saved_revision; other.saved_hash = f.saved_hash; other.saved_len = f.saved_len; other.disk_newer = f.disk_newer; other.disk_gone = f.disk_gone; if (!std.mem.eql(u8, other.path, f.path)) { const path = p.gpa.dupe(u8, f.path) catch continue; p.gpa.free(other.path); other.path = path; // Renamed, each twin says so, as the one renamed did. pardes.ctlfs.events.noteLog(p, .rename, other_pane); } } break; } // Tests hold the twins to one text, one revision, every step. if (builtin.is_test) for (members[1..n]) |other| { std.debug.assert(other.content.ptr == members[0].content.ptr and other.content.len == members[0].content.len); std.debug.assert(other.revision == members[0].revision); }; g += 1; } } /// Whether `head`, a text's first bytes, holds a diff: a `diff` header, or /// a unified hunk's `---`, `+++` and `@@` lines. pub fn looksLikeDiff(head: []const u8) bool { if (std.mem.startsWith(u8, head, "diff ") or std.mem.indexOf(u8, head, "\ndiff ") != null) return true; const minus = std.mem.indexOf(u8, head, "--- ") orelse return false; const plus = std.mem.indexOfPos(u8, head, minus, "\n+++ ") orelse return false; return std.mem.indexOfPos(u8, head, plus, "\n@@ ") != null; } test "a +Pager pane holding a diff is drawn and looked at as one; holding other text, as text" { const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true }); defer p.deinit(); const pane = try p.setTestFile(""); const f = &pane.file.?; p.gpa.free(f.path); f.path = try p.gpa.dupe(u8, "/tmp/+Pager"); f.pager = true; setContent(p, f, try p.gpa.dupe(u8, "commit abc\n\ndiff --git a/x b/x\n--- a/x\n+++ b/x\n@@ -1 +1 @@\n-a\n+b\n")); try std.testing.expect(pane.colorAlgo() == .diff); try std.testing.expect(pardes.look.diffLines(p, pane) != null); setContent(p, f, try p.gpa.dupe(u8, "commit abc\n\n a plain log\n")); try std.testing.expect(pane.colorAlgo() != .diff); } test "a pager's text is a diff when it holds a diff header or a unified hunk" { try std.testing.expect(looksLikeDiff("commit abc\nAuthor: x\n\n msg\n\ndiff --git a/f b/f\n")); try std.testing.expect(looksLikeDiff("--- a/f\n+++ b/f\n@@ -1 +1 @@\n-a\n+b\n")); try std.testing.expect(!looksLikeDiff("commit abc\nAuthor: x\n\n plain log\n")); } pub fn restoreSnap(pane: *Pane, f: *State, snap: Snapshot) void { const n = nlines(pane.gpa, f); const row: usize = @min(@as(usize, @intCast(@max(0, snap.cur_row))), n - 1); const llen = modal.lineSlice(f.content, row).len; pane.body.cur_row = @intCast(row); pane.body.cur_col = @intCast(@min(@as(usize, @intCast(@max(0, snap.cur_col))), llen)); pane.body.vsel = snap.vsel; pane.body.msel.active = false; pane.body.cur_pinned = true; pane.body.sticky_col = -1; pane.ensureCursorVisible(); } /// Bounded in steps and in bytes: the oldest go first, though the one /// pushed always stays. fn pushHistory(gpa: std.mem.Allocator, history: *History, slots: []Snapshot, len: *usize, snap: Snapshot) void { while (len.* > 0 and (len.* == slots.len or history.bytes + snap.content.len > limits.undo_bytes)) { history.bytes -= slots[0].content.len; slots[0].deinit(gpa); std.mem.copyForwards(Snapshot, slots[0 .. len.* - 1], slots[1..len.*]); len.* -= 1; } slots[len.*] = snap; len.* += 1; history.bytes += snap.content.len; } pub fn pushUndo(p: *Pardes, pane: *Pane) void { const f = if (pane.file) |*file| file else return; const history = f.history; if (history.undo_len > 0) { const last = history.undo[history.undo_len - 1]; if (std.mem.eql(u8, last.content, f.content) and last.gen == history.gen) return; } const snap = snapshotOf(p.gpa, pane, f) orelse return; for (history.redo[0..history.redo_len]) |item| { history.bytes -= item.content.len; item.deinit(p.gpa); } history.redo_len = 0; pushHistory(p.gpa, history, &history.undo, &history.undo_len, snap); } pub fn undo(p: *Pardes, pane: *Pane) void { const f = if (pane.file) |*file| file else return; const history = f.history; if (history.undo_len == 0) return; const current = snapshotOf(p.gpa, pane, f) orelse return; pushHistory(p.gpa, history, &history.redo, &history.redo_len, current); history.undo_len -= 1; const previous = history.undo[history.undo_len]; history.bytes -= previous.content.len; // the file's text now setContent(p, f, previous.content); restoreName(p, pane, f, previous); restoreSnap(pane, f, previous); } pub fn redo(p: *Pardes, pane: *Pane) void { const f = if (pane.file) |*file| file else return; const history = f.history; if (history.redo_len == 0) return; const current = snapshotOf(p.gpa, pane, f) orelse return; pushHistory(p.gpa, history, &history.undo, &history.undo_len, current); history.redo_len -= 1; const next = history.redo[history.redo_len]; history.bytes -= next.content.len; // the file's text now setContent(p, f, next.content); restoreName(p, pane, f, next); restoreSnap(pane, f, next); } /// A pane's file deleted on disk: the text stays, and it says so once, /// ` deleted on disk (Save writes it again)`, logged `changed /// deleted`. pub fn deleted(p: *Pardes, id: u8) void { const taped = pardes.tape.enter(p, .{ .file_deleted = id }); defer pardes.tape.leave(p, taped); const pane = p.panes[id] orelse return; const f = if (pane.file) |*file| file else return; if (f.disk_gone) return; f.disk_gone = true; var said: [limits.host_path_cap + 64]u8 = undefined; p.setMessage(id, std.fmt.bufPrint(&said, "{s} deleted on disk (Save writes it again)", .{f.path}) catch "deleted on disk (Save writes it again)"); var rec: [32]u8 = undefined; pardes.ctlfs.events.notePath(p, "changed", std.fmt.bufPrint(&rec, "{d} deleted", .{pane.serial}) catch ""); } /// A file rewritten on disk. A clean buffer takes the new text, committed /// onto the same undo history as typed edits. A buffer with unsaved edits /// is never reloaded under them: it keeps its text and stays dirty, and /// says so once (` changed on disk (get reloads it, Save overwrites /// it)`, logged `changed `); get then asks before throwing /// the edits away and Save before overwriting the newer file. acme reloads /// nothing by itself: its get asks (winclean) and its Put refuses a file /// modified since it was read (exec.c:577). pub fn changed(p: *Pardes, id: u8, bytes: []const u8) void { const pane = p.panes[id] orelse return; const f = if (pane.file) |*file| file else return; f.disk_gone = false; if (std.mem.eql(u8, f.content, bytes)) return; if (f.saved_hash) |saved| if (f.revision != f.saved_revision and std.hash.Wyhash.hash(0, f.content) != saved) { const disk = std.hash.Wyhash.hash(0, bytes); // The disk holds what the text was read or saved as: no news, only // a watch looking again (an undo back to this name, a restart). if (disk == saved) return; if (f.disk_newer == disk) return; f.disk_newer = disk; f.disk_newer_warned = false; var said: [limits.host_path_cap + 64]u8 = undefined; p.setMessage(id, std.fmt.bufPrint(&said, "{s} changed on disk (get reloads it, Save overwrites it)", .{f.path}) catch "changed on disk (get reloads it, Save overwrites it)"); var rec: [16]u8 = undefined; pardes.ctlfs.events.notePath(p, "changed", std.fmt.bufPrint(&rec, "{d}", .{pane.serial}) catch ""); return; }; f.disk_newer = null; // Logged as the dirty case is, with what became of it. var rec: [32]u8 = undefined; pardes.ctlfs.events.notePath(p, "changed", std.fmt.bufPrint(&rec, "{d} reloaded", .{pane.serial}) catch ""); const new = p.gpa.dupe(u8, bytes) catch return; pushUndo(p, pane); setContent(p, f, new); f.saved_revision = f.revision; // restoreSnap only consumes cursor/selection from this synthetic snapshot. restoreSnap(pane, f, .{ .content = undefined, .cur_row = pane.body.cur_row, .cur_col = pane.body.cur_col, .vsel = pane.body.vsel, }); } /// re-highlight the visible window of any file whose syntax went stale /// (edit, scroll, load) — visible-range-first so big files stay snappy /// The declarations a TreeContext pane's context rows are drawn from, for /// its text as it is now: found in the step (Pardes.sync), never only by a /// render, since the view's geometry is made of them (`geometry`). pub fn refreshContext(p: *Pardes, pane: *Pane, f: *State) void { if (!f.tree_context or !supportsContext(pane) or f.context_revision == f.revision) return; const declarations = syntax.contextDeclarations(p.tree_sitter_gpa, f.path, f.content) catch return; if (f.context_declarations.len > 0) p.tree_sitter_gpa.free(f.context_declarations); f.context_declarations = declarations; f.context_revision = f.revision; } pub fn refreshHighlights(p: *Pardes) void { const tz = tracy.zone(@src(), "refreshHighlights"); defer tz.end(); for (p.panes) |slot| { const pane = slot orelse continue; if (pane.file == null) continue; const f = &pane.file.?; if (f.mini != null) { f.syntax_dirty = false; continue; } if (!f.syntax_dirty) continue; if (!p.settings.colors) { if (f.highlights.len > 0) p.tree_sitter_gpa.free(f.highlights); f.highlights = &.{}; f.highlight_start = 0; f.syntax_dirty = false; continue; } // ponytail: a stretch over `long_paint` bytes (a minified line) is // painted only around the caret, so a key typed in a 500 KB line // parses 16 KB, not the line (190 ms a key in ReleaseSafe; 25 ms at // 64 KB, so 16, still eight views of 80x25); its first // tokens may be coloured as if the line began there. The upgrade: an // incremental parse of the whole text, edited in place. const caret = @min(f.content.len, lineStart(p.gpa, f, @intCast(@max(0, pane.body.cur_row))) + @as(usize, @intCast(@max(0, pane.body.cur_col)))); const around = struct { fn clamp(a: usize, b: usize, at: usize) [2]usize { if (b - a <= long_paint) return .{ a, b }; const lo = std.math.clamp(at -| long_paint / 2, a, b - long_paint); return .{ lo, lo + long_paint }; } }; const need = around.clamp(lineStart(p.gpa, f, f.scroll), @max(lineStart(p.gpa, f, f.scroll), lineStart(p.gpa, f, f.scroll + pane.rows + SYNTAX_CONTEXT_AFTER_ROWS)), caret); const need_start = need[0]; const need_end = need[1]; if ((!f.tree_context or (f.highlight_start == 0 and f.highlights.len == f.content.len)) and f.highlights.len > 0 and need_start >= f.highlight_start and need_end <= f.highlight_start + f.highlights.len) { f.syntax_dirty = false; if (!f.tree_context and pane.colorAlgo() == .source) paintAhead(p, pane, f); continue; } // A view far from what is painted (a jump: ge, a Look) paints only // itself on the frame, a third of the work; the stretch around it // comes painted ahead (paintAhead) where there are workers. const far = f.highlights.len == 0 or need_end <= f.highlight_start or need_start >= f.highlight_start + f.highlights.len; const slack: usize = if (far and p.host.vtable.search != null) 0 else if (f.highlights.len == 0) 0 else pane.rows; const whole = pane.colorAlgo() == .locations or f.tree_context; // Painted ahead on a worker (Stream.paintAhead): taken, no parse. if (!whole and pane.colorAlgo() == .source) if (Stream.takeAhead(p, pane.serial, f.revision, need_start, need_end)) |got| { if (f.highlights.len > 0) p.tree_sitter_gpa.free(f.highlights); f.highlights = got.styles; f.highlight_start = got.start; f.syntax_dirty = false; p.stream.painted_ahead += 1; paintAhead(p, pane, f); continue; }; if (pane.colorAlgo() == .source and !whole) p.stream.painted_on_loop += 1; const wide_start = if (whole) 0 else lineStart(p.gpa, f, f.scroll -| slack); const wide_end = if (whole) f.content.len else @max(wide_start, lineStart(p.gpa, f, f.scroll + pane.rows + SYNTAX_CONTEXT_AFTER_ROWS + slack)); const window = if (whole) [2]usize{ wide_start, wide_end } else around.clamp(wide_start, wide_end, caret); const start = window[0]; const end = window[1]; const new_highlights = (switch (pane.colorAlgo()) { .none => @as([]u8, &.{}), .diff => syntax.highlightDiff(p.tree_sitter_gpa, f.content, start, end), .locations => if (f.location_rows.len > 0) syntax.highlightLocationRows(p.tree_sitter_gpa, f.content, f.location_rows) else syntax.highlightLocations(p.tree_sitter_gpa, f.content, start, end), else => syntax.highlightFileRange(p.tree_sitter_gpa, f.path, f.content, start, end), }) catch { f.syntax_dirty = false; continue; }; if (f.highlights.len > 0) p.tree_sitter_gpa.free(f.highlights); f.highlights = new_highlights; f.highlight_start = if (f.highlights.len > 0) start else 0; f.syntax_dirty = false; if (!whole and pane.colorAlgo() == .source) paintAhead(p, pane, f); } } /// The stretch a scroll of `pane` is heading into, the view and three more /// the way it last went, asked of a worker (Stream.paintAhead) so it is /// painted by the time the view gets there. From the view itself: two /// views out, an upward stretch stopped short of the view's own bottom /// rows, and a half page up (or down) missed it by a line and painted on /// the frame, 11-17 ms in ReleaseSafe. fn paintAhead(p: *Pardes, pane: *Pane, f: *State) void { const seen = &p.stream.ahead_seen; // A view standing still (typing in it) needs nothing ahead: each edit // is a new revision, and a paint asked at every keystroke was a copy // of the stretch and a worker's start on the loop per key. if (seen.serial == pane.serial and f.scroll == seen.scroll) return; if (seen.serial == pane.serial) seen.dir = if (f.scroll > seen.scroll) 1 else -1; if (seen.serial != pane.serial) seen.dir = 1; seen.serial = pane.serial; seen.scroll = f.scroll; const rows: usize = pane.rows; const start = lineStart(p.gpa, f, if (seen.dir > 0) f.scroll else f.scroll -| 3 * rows); const end = @max(start, lineStart(p.gpa, f, f.scroll + (if (seen.dir > 0) 4 * rows else rows) + SYNTAX_CONTEXT_AFTER_ROWS)); // Painted already, as far as that goes. if (f.highlights.len > 0 and start >= f.highlight_start and end <= f.highlight_start + f.highlights.len) return; Stream.paintAhead(p, pane.serial, f.revision, f.path, f.content, start, end); } test "a long line is painted only around the caret" { if (!syntax.enabled) return; const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 24 }); defer p.deinit(); const line = try std.testing.allocator.alloc(u8, 600 << 10); defer std.testing.allocator.free(line); for (line, 0..) |*c, i| c.* = if (i % 2 == 0) '1' else ','; const pane = try p.setTestFile(line); p.gpa.free(pane.file.?.path); pane.file.?.path = try p.gpa.dupe(u8, "/tmp/long.json"); pane.body.cur_col = 300 << 10; var arena: std.heap.ArenaAllocator = .init(std.testing.allocator); defer arena.deinit(); _ = try p.render(arena.allocator()); const f = &pane.file.?; try std.testing.expect(f.highlights.len == long_paint); try std.testing.expect(f.highlight_start <= 300 << 10 and f.highlight_start + f.highlights.len >= 300 << 10); } test "a caret deep in a long line scrolls the view sideways to it, measured from the view's edge" { const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 24 }); defer p.deinit(); p.settings.wrap = false; const line = try std.testing.allocator.alloc(u8, 500 << 10); defer std.testing.allocator.free(line); @memset(line, 'a'); const pane = try p.setTestFile(line); var arena: std.heap.ArenaAllocator = .init(std.testing.allocator); defer arena.deinit(); _ = try p.render(arena.allocator()); // Right, far: the caret ends a margin in from the right edge. pane.body.cur_col = 400_000; pane.ensureCursorVisible(); const w: i32 = @as(i32, pane.cols) - @as(i32, gutterWidth(pane)); const hmargin: i32 = @min(config.scroll_off, @divTrunc(w - 1, 2)); try std.testing.expectEqual(@as(i32, 400_000 - (w - 1 - hmargin)), pane.hscroll); // Back left of the view: a margin in from the left edge. pane.body.cur_col = 100_000; pane.ensureCursorVisible(); try std.testing.expectEqual(@as(i32, 100_000 - hmargin), pane.hscroll); // At the start: none. pane.body.cur_col = 1; pane.ensureCursorVisible(); try std.testing.expectEqual(@as(i32, 0), pane.hscroll); } pub fn supportsContext(pane: *const Pane) bool { const file = pane.file orelse return false; return file.output == null and file.mini == null and syntax.supportsPath(file.path); } fn prepareContextRows(pane: *Pane, file: *State) void { pane.context_rows = 0; if (!file.tree_context or !supportsContext(pane) or pane.rows > pane.wrap_line.len) return; const capacity = @min(pane.rows -| 1, pane.context_row_limit orelse std.math.maxInt(u16)); // retain an ordinary body row for (file.context_declarations) |declaration| { if (declaration.start_line >= file.scroll) break; if (declaration.end_line < file.scroll) continue; var row = declaration.start_line; while (row <= declaration.header_end_line and row < file.scroll) : (row += 1) { if (pane.context_rows >= capacity) return; if (pane.context_rows > 0 and row <= pane.wrap_line[pane.context_rows - 1]) continue; pane.wrap_line[pane.context_rows] = @intCast(row); pane.context_rows += 1; } } } pub fn wrapWidth(pane: *const Pane, wrap: bool) usize { if (!wrap or pane.rows > pane.wrap_line.len) return 0; return @max(1, @as(usize, pane.cols -| gutterWidth(pane)) -| 1); } pub const VisualRow = struct { start: usize, end: usize }; pub fn visualRow(line: []const u8, col: usize, width: usize) VisualRow { if (width == 0) return .{ .start = 0, .end = line.len }; var start: usize = 0; while (true) { const end = fitEnd(line, start, width); if (col < end or end >= line.len) return .{ .start = start, .end = end }; start = end; } } /// The body's text as it is shown: its geometry's rows, each a line's /// number and its stretch of the line. pub fn bodyText(arena: std.mem.Allocator, pane: *Pane, f: *State) ![]const u8 { geometry(pane); const out = try arena.alloc(u8, pane.geometry_len); const filled = fillBody(out, pane, f, wrapWidth(pane, pane.view.wrap), false); std.debug.assert(filled == out.len); return out; } /// The pane's view geometry for its state as it is now: the wrap map (the /// line, column and pad each body row starts at), the context rows, and how /// many rows the body layer has. Made again when anything it is made of /// changes (`geometryKey`), by whoever asks first, the render or a step that /// reads it: so a core that never draws has the geometry of one that does /// (docs/next-daemon.md). What it reads of the session is the pane's `view`, /// which each step sets. pub fn geometry(pane: *Pane) void { const f = if (pane.file) |*file| file else return; const key = geometryKey(pane, f); if (pane.geometry_key == key) return; pane.geometry_key = key; pane.body_rows = 0; pane.body_visible_rows = 0; pane.context_row_limit = null; pane.geometry_len = mapRows(pane, f); // A body with context rows is a layer taller than the grid's rows, its // context rows at the tagline's height (body_layer.joinBody). const v = pane.view; if (!v.layered or pane.collapsed or v.rect_h <= pane.tag_rows) return; const logical_rows = @min(@as(usize, pane.rows) + pane.context_rows, pane.wrap_line.len); if (pane.context_rows == 0 or logical_rows <= pane.context_rows) return; pane.body_rows = @intCast(logical_rows); const bh: usize = @max(1, v.body_h); const th: usize = std.math.clamp(v.tagline_h, 1, bh); const body_pixels = @as(usize, v.rect_h - pane.tag_rows) * bh; const limit: u16 = @intCast(@min(pane.context_rows, (body_pixels -| bh) / th)); pane.context_row_limit = limit; pane.body_visible_rows = @intCast(@min(logical_rows, limit + @max(1, (body_pixels -| @as(usize, limit) * th) / bh))); pane.geometry_len = mapRows(pane, f); } /// One walk of the rows the body shows, recording the wrap map: the bytes /// its text takes. fn mapRows(pane: *Pane, f: *State) usize { const width = wrapWidth(pane, pane.view.wrap); pane.body_wrapped = width > 0; f.tables.ensure(pane.gpa, f); prepareContextRows(pane, f); return fillBody(null, pane, f, width, true); } /// Everything the geometry is made of, hashed: the text (its revision and /// length), where it is scrolled, the pane's size, its tables as far as /// they have been read, its context declarations, the session's view. fn geometryKey(pane: *const Pane, f: *const State) u64 { const t = &f.tables; const facts = .{ f.revision, f.content.len, f.scroll, pane.hscroll, pane.rows, pane.cols, pane.tag_rows, pane.collapsed, pane.query != null, f.pager, f.mini != null, f.output != null, if (f.output) |o| pardes.walk.digest(Output.Origin, &o.from) else 0, std.hash.Wyhash.hash(0, f.path), f.tree_context, f.context_revision orelse 0, f.context_declarations.len, f.line_starts.len, t.revision orelse 0, t.list.items.len, if (t.pending) |r| r.at else std.math.maxInt(usize), pane.view.wrap, pane.view.layered, pane.view.body_h, pane.view.tagline_h, pane.view.rect_h, }; // One hash of them laid out as words: every reader of the map asks for // this key, a hundred times a frame. var words: [facts.len]u64 = undefined; inline for (facts, &words) |fact, *w| w.* = if (@TypeOf(fact) == bool) @intFromBool(fact) else if (@typeInfo(@TypeOf(fact)).int.signedness == .signed) @bitCast(@as(i64, fact)) else fact; // Never the "made for nothing" key a reset leaves (`geometry_key = 0`). return std.hash.Wyhash.hash(0x9e0, std.mem.sliceAsBytes(&words)) | 1; } /// Run the file-body row walk. With no destination it is the exact sizing /// pass; with one it fills that allocation and records the wrapping map. fn fillBody(dst: ?[]u8, pane: *Pane, f: *State, width: usize, record_wrap: bool) usize { if (record_wrap) pane.wrap_n = 0; const prefix_width = gutterWidth(pane); const total = nlines(pane.gpa, f); var body_line: usize = f.scroll; var body_at: usize = 0; var written: usize = 0; for (0..if (pane.body_rows > 0) pane.body_rows else pane.rows) |i| { if (i > 0) { if (dst) |out| out[written] = '\n'; written += 1; } const context = i < pane.context_rows; const row = if (context) @as(usize, @intCast(pane.wrap_line[i])) else body_line; const at = if (context) 0 else body_at; const text = if (row < total) sourceLine(pane, @intCast(row)) else ""; var guide_buffer: [1024]u8 = undefined; const guide = if (at > 0 and width > 1 and f.output != null and std.meta.eql(f.output.?.from, Output.Origin{ .query = .callstack })) locations.treeContinuation(text, &guide_buffer, width - 1) else ""; const pad = displayWidth(guide); // Headers use one screen row per source row, preserving signatures // without allowing a long ancestor to consume the whole viewport. const end = if (width == 0 or context) text.len else fitEnd(text, at, width - pad); const cut = if (pane.hscroll > 0 and width == 0) modal.graphemeStart(text, @min(@as(usize, @intCast(pane.hscroll)), text.len)) else at; if ((width > 0 or pane.context_rows > 0) and record_wrap) { pane.wrap_line[i] = @intCast(row); pane.wrap_col[i] = @intCast(cut); pane.wrap_pad[i] = @intCast(pad); pane.wrap_n = @intCast(i + 1); } if (row < total) { var lbuf: [@max(config.PREFIX_W, 32)]u8 = undefined; const prefix = lbuf[0..prefix_width]; @memset(prefix, ' '); if (at == 0 and prefix.len > 0) { var lineno = row + 1; var digit: usize = prefix.len - 1; while (true) { digit -= 1; prefix[digit] = '0' + @as(u8, @intCast(lineno % 10)); lineno /= 10; if (lineno == 0) break; } } if (dst) |out| @memcpy(out[written..][0..prefix.len], prefix); written += prefix.len; if (dst) |out| @memcpy(out[written..][0..guide.len], guide); written += guide.len; // A table row's pads are blanks before their bytes: the row // drawn as the column functions above measure it. var pad_buf: [Tables.max_pads]Tables.Pad = undefined; var from = cut; for (rowPads(pane, @intCast(row), &pad_buf)) |table_pad| { if (table_pad.at <= cut) continue; if (table_pad.at > end) break; if (dst) |out| @memcpy(out[written..][0 .. table_pad.at - from], text[from..table_pad.at]); written += table_pad.at - from; if (dst) |out| @memset(out[written..][0..table_pad.cells], ' '); written += table_pad.cells; from = table_pad.at; } const shown = text[from..end]; if (dst) |out| @memcpy(out[written..][0..shown.len], shown); written += shown.len; } if (!context) { if (width > 0 and end < text.len) { body_at = end; } else { body_line += 1; body_at = 0; } } } return written; } pub fn drawGutter(p: *Pardes, s: *Surface, pane: *Pane, r: pardes.Rect, tx: u16, tw: u16, body_h: u16, active: bool) void { const prefix_width = gutterWidth(pane); const goff = pane.scroll(); const gcur = terminal.gridCursor(pane); const gcrow = if (pane.body.cur_pinned) pane.body.cur_row else @as(i32, gcur.y) + goff; const typing_body = pane.focus == .body and (pane.prompt == .none or pane.prompt == .del_side or pane.prompt == .repl_choice); const cur_line: i32 = if (active and typing_body) gcrow else std.math.minInt(i32); // the body's first row, the way renderPane derives it (Tagbottom) const body_y = p.bodyTop(pane, r); const context_bg = p.theme().tag_bg; for (0..@min(pane.context_rows, body_h)) |context_row| { for (0..tw) |col| { const cell = s.at(tx + @as(u16, @intCast(col)), body_y + @as(u16, @intCast(context_row))); cell.default = false; cell.style.bg = .{ .rgb = context_bg }; if (p.settings.tree_context_tag_style) cell.style.font_role = .tagline; } } var vr: u16 = 0; while (vr < body_h) : (vr += 1) { const row_line: i32 = if (pane.wrap_n == 0) goff + @as(i32, vr) else if (vr < pane.wrap_n) pane.wrap_line[vr] else std.math.maxInt(i32); const on_cursor = row_line == cur_line; var c: u16 = 0; while (c < prefix_width and c < tw) : (c += 1) { const cell = s.at(tx + c, body_y + vr); cell.default = false; // paints blank gutter rows too cell.style.fg = .{ .rgb = if (on_cursor) p.theme().lineno_active orelse p.theme().lineno else p.theme().lineno }; cell.style.bold = on_cursor; } } } const SynStyle = struct { fg: [3]u8, bold: bool }; /// How added and removed diff lines are told apart in every theme: a row /// ground a little way from the page toward green or red (the theme's own /// ANSI green and red where it has a palette), and the prefix column in /// that hue, pushed toward the ink until it reads on that ground. The /// syntax colours are drawn over the ground unchanged. pub const DiffTints = struct { added_bg: [3]u8, removed_bg: [3]u8, /// The words a changed line changed (hunks.zig), on a stronger ground. added_emph_bg: [3]u8, removed_emph_bg: [3]u8, /// A +Diff line added or removed whole: a faint ground. added_line_bg: [3]u8, removed_line_bg: [3]u8, added_fg: [3]u8, removed_fg: [3]u8, pub fn of(p: *Pardes) DiffTints { const th = p.theme(); const page = th.bg orelse th.tag_bg; const ink = th.fg orelse th.tag_fg; const green: [3]u8 = if (th.palette) |pal| pal[2] else .{ 0x2e, 0xa0, 0x43 }; const red: [3]u8 = if (th.palette) |pal| pal[1] else .{ 0xcf, 0x22, 0x2e }; const added_bg = Colors.mixOklab(page, green, 0.18); const removed_bg = Colors.mixOklab(page, red, 0.18); return .{ .added_bg = added_bg, .removed_bg = removed_bg, .added_emph_bg = Colors.mixOklab(page, green, 0.28), .removed_emph_bg = Colors.mixOklab(page, red, 0.28), .added_line_bg = Colors.mixOklab(page, green, 0.07), .removed_line_bg = Colors.mixOklab(page, red, 0.07), .added_fg = legible(green, ink, added_bg), .removed_fg = legible(red, ink, removed_bg), }; } fn legible(hue: [3]u8, ink: [3]u8, ground: [3]u8) [3]u8 { var fg = hue; var step: usize = 0; while (step < 4 and Colors.contrast(fg, ground) < 3) : (step += 1) fg = Colors.mixOklab(fg, ink, 0.4); return fg; } /// The row ground and prefix ink for a line's style byte, if it is an /// added or removed line. pub fn forStyle(t: *const DiffTints, style: u8) ?struct { bg: [3]u8, fg: [3]u8, emph_bg: [3]u8, line_bg: [3]u8 } { if (style & syntax.diff_added != 0) return .{ .bg = t.added_bg, .fg = t.added_fg, .emph_bg = t.added_emph_bg, .line_bg = t.added_line_bg }; if (style & syntax.diff_removed != 0) return .{ .bg = t.removed_bg, .fg = t.removed_fg, .emph_bg = t.removed_emph_bg, .line_bg = t.removed_line_bg }; return null; } }; fn synStyle(p: *Pardes, sy: syntax.Syn) ?SynStyle { return switch (sy) { .none => null, .keyword => .{ .fg = p.theme().kw, .bold = p.settings.syntax_bold }, .string => .{ .fg = p.theme().str, .bold = false }, .number => .{ .fg = p.theme().num, .bold = false }, .comment => .{ .fg = p.theme().comment, .bold = false }, }; } /// syntax colors: recolor each content cell from its tree-sitter style byte; /// content starts after the lineno gutter pub fn recolorSyntax(p: *Pardes, s: *Surface, pane: *Pane, f: *State, r: pardes.Rect, tx: u16, tw: u16, body_h: u16) void { const highlights = if (f.mini) |mini| mini.colors else f.highlights; const highlight_start = if (f.mini != null) 0 else f.highlight_start; const spans = f.pager_spans; if (highlights.len == 0 and f.output == null and spans.len == 0) return; const prefix_width = gutterWidth(pane); const tz_recolor = tracy.zone(@src(), "synRecolor"); defer tz_recolor.end(); // A diff's rows, and a +Diff's (hunks.zig): their markers coloured. // A diff's whole row is tinted; a +Diff tints only the words a // changed line changed. const algo = pane.colorAlgo(); const tints: ?DiffTints = if ((algo == .diff or algo == .locations) and highlights.len > 0) DiffTints.of(p) else null; const row_tint = algo == .diff; var filtered_storage: terminal.FilteredColors = undefined; const filtered: ?*terminal.FilteredColors = if (comptime terminal.enabled) (if (pane.tty_filter and spans.len > 0) blk: { filtered_storage = .init(p, null); break :blk &filtered_storage; } else null) else null; // indexed start, same as bodyText — an empty tail simply paints nothing var flines = std.mem.splitScalar(u8, f.content[lineStart(p.gpa, f, f.scroll)..], '\n'); const total = nlines(p.gpa, f); const body_y = p.bodyTop(pane, r); var vr: u16 = 0; while (vr < body_h) : (vr += 1) { var base: usize = undefined; var line: []const u8 = undefined; var hs: usize = @intCast(@max(0, pane.hscroll)); var limit: usize = undefined; if (pane.wrap_n == 0) { line = flines.next() orelse break; base = @intFromPtr(line.ptr) - @intFromPtr(f.content.ptr); limit = line.len; } else { if (vr >= pane.wrap_n) break; const lrow: usize = @intCast(@max(0, pane.wrap_line[vr])); if (lrow >= total) break; base = lineStart(p.gpa, f, lrow); const lend = if (lrow + 1 < total) lineStart(p.gpa, f, lrow + 1) -| 1 else f.content.len; line = f.content[base..lend]; hs = @intCast(pane.wrap_col[vr]); limit = if (vr + 1 < pane.wrap_n and pane.wrap_line[vr + 1] == pane.wrap_line[vr]) @min(line.len, @as(usize, @intCast(pane.wrap_col[vr + 1]))) else line.len; } hs = modal.graphemeStart(line, @min(hs, line.len)); const row_index: usize = @intCast(@max(0, pane.wrapAt(vr).line)); const metadata: ?locations.Row = if (row_index < f.location_rows.len) f.location_rows[row_index] else null; const decoration = Output.decorateRow(f.output, line, metadata); const chrome: ?*const pardes.ChromeTheme = if (decoration.plain()) null else p.bodyChrome(); // An added or removed line's row, every wrapped row of it, is tinted. const tint = if (tints) |*t| if (base >= highlight_start and base - highlight_start < highlights.len) t.forStyle(highlights[base - highlight_start]) else null else null; if (tint) |t| if (prefix_width < tw) { // A +Diff line added or removed whole: faintly (hunks.zig). const whole = highlights[base - highlight_start] & syntax.diff_whole != 0; if (row_tint or whole) s.tint(tx + @as(u16, @intCast(prefix_width)), body_y + vr, tw -| @as(u16, @intCast(prefix_width)), if (row_tint) t.bg else t.line_bg, null); }; // A +Pager's own colours (pager.zig) on every row but one the diff // look tints: an added or removed line is drawn as pardes draws a // diff, and git's red and green on it would only fight the tint. var span_at = if (tint != null) spans.len else std.sort.partitionPoint(pardes.pager.Span, spans, base + hs, struct { fn before(at: usize, span: pardes.pager.Span) bool { return span.end <= at; } }.before); var c: usize = 0; const pad: usize = if (vr < pane.wrap_n) pane.wrap_pad[vr] else 0; for (0..@min(pad, tw -| prefix_width)) |col| { s.at(tx + @as(u16, @intCast(prefix_width + col)), body_y + vr).style.fg = .{ .rgb = p.bodyChrome().diagnostic_info }; } var screen_c: usize = pad; var table_buf: [Tables.max_pads]Tables.Pad = undefined; const table_pads = rowPads(pane, @intCast(row_index), &table_buf); var table_at: usize = 0; while (hs + c < limit and prefix_width + screen_c < tw) { while (table_at < table_pads.len and table_pads[table_at].at < hs + c) table_at += 1; if (table_at < table_pads.len and table_pads[table_at].at == hs + c and hs + c > hs) { screen_c += table_pads[table_at].cells; table_at += 1; if (prefix_width + screen_c >= tw) break; } const grapheme_end = @min(limit, modal.nextGrapheme(line, hs + c)); const cells = graphemeDisplayWidth(line[hs + c .. grapheme_end]); const idx = base + hs + c; if (idx >= highlight_start) { const hidx = idx - highlight_start; if (hidx < highlights.len) { if (if (tint != null and hs + c == 0) SynStyle{ .fg = tint.?.fg, .bold = true } else synStyle(p, @fromBackingInt(@intCast(highlights[hidx] & syntax.syn_bits)))) |ss| { var fill: usize = 0; while (fill < cells and prefix_width + screen_c + fill < tw) : (fill += 1) { const cell = s.at(tx + @as(u16, @intCast(prefix_width + screen_c + fill)), body_y + vr); if (cell.default) continue; cell.style.fg = .{ .rgb = ss.fg }; cell.style.bold = ss.bold; } } if (tint) |t| if (highlights[hidx] & syntax.diff_emph != 0) { var fill: usize = 0; while (fill < cells and prefix_width + screen_c + fill < tw) : (fill += 1) s.at(tx + @as(u16, @intCast(prefix_width + screen_c + fill)), body_y + vr).style.bg = .{ .rgb = t.emph_bg }; }; } } // Results keep their exact live text. Only the location, // matched source range and diagnostic label gain emphasis. if (if (chrome) |ch| decoration.styleAt(ch, hs + c) else null) |style| { var fill: usize = 0; while (fill < cells and prefix_width + screen_c + fill < tw) : (fill += 1) { const cell = s.at(tx + @as(u16, @intCast(prefix_width + screen_c + fill)), body_y + vr); if (cell.default) continue; cell.style.fg = style.fg; cell.style.bold = style.bold; if (style.bg != .default) cell.style.bg = style.bg; } } while (span_at < spans.len and spans[span_at].end <= idx) span_at += 1; if (span_at < spans.len and spans[span_at].start <= idx) { const st = spans[span_at].style; var fill: usize = 0; while (fill < cells and prefix_width + screen_c + fill < tw) : (fill += 1) { const cell = s.at(tx + @as(u16, @intCast(prefix_width + screen_c + fill)), body_y + vr); if (cell.default) continue; // As a terminal pane's cell: through Filter, or a // palette colour through the theme's sixteen and // truecolor as it is. if (filtered) |colors| { if (st.fg != .default) cell.style.fg = colors.spanColor(st.fg, false); if (st.bg != .default) cell.style.bg = colors.spanColor(st.bg, true); } else { if (st.fg != .default) cell.style.fg = if (st.fg == .index) terminal.palColor(p, st.fg.index) else st.fg; if (st.bg != .default) cell.style.bg = if (st.bg == .index) terminal.palColor(p, st.bg.index) else st.bg; } cell.style.bold = cell.style.bold or st.bold; cell.style.dim = st.dim; cell.style.italic = st.italic; cell.style.blink = st.blink; cell.style.reverse = st.reverse; cell.style.invisible = st.invisible; cell.style.strikethrough = st.strikethrough; if (st.ul != .off) cell.style.ul = st.ul; } } screen_c += cells; c = grapheme_end - hs; } } } /// What finished command panes printed, kept while it cannot change: a /// copy of the terminal's rows, and whether they are a diff. Taken once /// when a finished pane is first drawn, so neither a frame nor a look dumps /// the whole scrollback again; a still running command is shown as it /// printed. Keyed by the pane and its width (a resize rewraps every row); /// a rerun in the pane drops it (exec.runCommand). pub const DiffOutput = struct { const Entry = struct { serial: u32, cols: u16, is_diff: bool, /// The rows joined by '\n'; `rows` are slices of it. text: []u8, rows: [][]const u8, used: u64, }; slots: [4]?Entry = @splat(null), clock: u64 = 0, pub fn reset(o: *DiffOutput, gpa: std.mem.Allocator) void { for (&o.slots) |*slot| { if (slot.*) |e| { gpa.free(e.text); gpa.free(e.rows); } slot.* = null; } } /// A pane's command runs again: what it printed before is gone. pub fn drop(o: *DiffOutput, gpa: std.mem.Allocator, serial: u32) void { for (&o.slots) |*slot| if (slot.*) |e| if (e.serial == serial) { gpa.free(e.text); gpa.free(e.rows); slot.* = null; }; } /// A finished command pane's rows when they are a diff, else null. pub fn lines(o: *DiffOutput, p: *Pardes, pane: *Pane) ?[]const []const u8 { if (pane.command == null or !pane.command_done or pane.command_pty or pane.terminal == null) return null; o.clock += 1; for (&o.slots) |*slot| if (slot.*) |*e| if (e.serial == pane.serial and e.cols == pane.cols) { e.used = o.clock; return if (e.is_diff) e.rows else null; }; const shown = terminal.shellRows(p, pane) catch return null; const is_diff = diff.looksLikeDiff(shown); var total: usize = 0; if (is_diff) for (shown) |row| { total += row.len + 1; }; const text = p.gpa.alloc(u8, total) catch return null; const rows = p.gpa.alloc([]const u8, if (is_diff) shown.len else 0) catch { p.gpa.free(text); return null; }; var at: usize = 0; for (rows, 0..) |*row, i| { @memcpy(text[at..][0..shown[i].len], shown[i]); row.* = text[at..][0..shown[i].len]; at += shown[i].len; text[at] = '\n'; at += 1; } // An empty slot, else the least recently used. var oldest: usize = 0; for (&o.slots, 0..) |*slot, i| { const e = slot.* orelse { oldest = i; break; }; if (e.used < o.slots[oldest].?.used) oldest = i; } if (o.slots[oldest]) |old| { p.gpa.free(old.text); p.gpa.free(old.rows); } o.slots[oldest] = .{ .serial = pane.serial, .cols = pane.cols, .is_diff = is_diff, .text = text, .rows = rows, .used = o.clock }; return if (is_diff) rows else null; } }; /// A command pane whose output is a diff (`git diff`, `diff -u`): its /// rows coloured as a .diff file's are, over what the program printed. /// The rows are the terminal's own, so a line it wrapped goes on in the /// row below (syntax.highlightDiffRows). pub fn recolorDiffOutput(p: *Pardes, s: *Surface, pane: *Pane, r: pardes.Rect, tx: u16, tw: u16, body_h: u16, body: []const u8) void { if (pane.command == null or !p.settings.colors) return; const tz = tracy.zone(@src(), "diffRecolor"); defer tz.end(); const rows = p.diff_output.lines(p, pane) orelse return; // The copy's rows are one text, joined as a file's lines are. const flat_start = @intFromPtr(rows[0].ptr); const last = rows[rows.len - 1]; const flat = rows[0].ptr[0 .. @intFromPtr(last.ptr) + last.len - flat_start]; const raw = pane.body.mode == .tty; const View = struct { row: usize, at: usize }; const arena = p.scratch.allocator(); const views = arena.alloc(?View, body_h) catch return; var lo: usize = std.math.maxInt(usize); var hi: usize = 0; var shown = std.mem.splitScalar(u8, body, '\n'); for (views, 0..) |*view, vi| { view.* = null; const line = shown.next() orelse continue; const vr: i32 = @intCast(vi); const w = pane.wrapAt(vr); const row_i: i32 = if (raw) terminal.gridOffset(pane) + vr else w.line; if (row_i < 0 or row_i >= @as(i64, @intCast(rows.len))) continue; const row: usize = @intCast(row_i); const from: usize = if (raw) 0 else @intCast(@max(0, w.at)); if (from > rows[row].len or !std.mem.startsWith(u8, rows[row][from..], line)) continue; view.* = .{ .row = row, .at = from }; const start = @intFromPtr(rows[row].ptr) - flat_start; lo = @min(lo, start); hi = @max(hi, start + rows[row].len); } if (lo > hi) return; const styles = syntax.highlightDiffRows(arena, flat, lo, hi, true) catch return; const tints = DiffTints.of(p); const ink = p.theme().fg orelse p.theme().tag_fg; const body_y = p.bodyTop(pane, r); shown = std.mem.splitScalar(u8, body, '\n'); for (views, 0..) |maybe, vr| { const line = shown.next() orelse break; const view = maybe orelse continue; const base = @intFromPtr(rows[view.row].ptr) - flat_start - lo; const tint = if (base < styles.len) tints.forStyle(styles[base]) else null; if (tint) |t| s.tint(tx, body_y + @as(u16, @intCast(vr)), tw, t.bg, null); var c: usize = 0; var screen_c: usize = 0; while (c < line.len and screen_c < tw) { const grapheme_end = modal.nextGrapheme(line, c); if (grapheme_end <= c) break; const cells = graphemeDisplayWidth(line[c..grapheme_end]); const style = styles[base + view.at + c]; const prefix = view.at + c == 0 and (line[0] == '+' or line[0] == '-'); // On an added or removed line, what the program coloured red or // green is the tint's to say now: its code takes the page's ink. const paint: ?SynStyle = if (tint != null and prefix) .{ .fg = tint.?.fg, .bold = true } else if (synStyle(p, @fromBackingInt(@intCast(style & syntax.syn_bits)))) |ss| ss else if (tint != null) .{ .fg = ink, .bold = false } else null; if (paint) |ss| { var fill: usize = 0; while (fill < cells and screen_c + fill < tw) : (fill += 1) { const cell = s.at(tx + @as(u16, @intCast(screen_c + fill)), body_y + @as(u16, @intCast(vr))); if (cell.default) continue; cell.style.fg = .{ .rgb = ss.fg }; cell.style.bold = ss.bold; } } screen_c += cells; c = grapheme_end; } } } pub fn drawWrapMarkers( p: *Pardes, s: *Surface, pane: *const Pane, r: pardes.Rect, tx: u16, tw: u16, body_h: u16, pane_bg: pardes.Color, ) void { if (tw <= gutterWidth(pane) + 1) return; const body_y = p.bodyTop(pane, r); const marker_fg = p.chromeTheme().lineno; var row: u16 = 0; while (row + 1 < pane.wrap_n and row + 1 < body_h) : (row += 1) { if (pane.wrap_line[row + 1] != pane.wrap_line[row]) continue; s.set(tx + tw - 1, body_y + row, config.wrap_marker, .{ .fg = .{ .rgb = marker_fg }, .bg = pane_bg, }); } } pub fn paintWordSelection( p: *Pardes, s: *Surface, pane: *Pane, r: pardes.Rect, row: i32, word_lo: i32, word_hi: i32, bg: [3]u8, ) void { const tx = r.x + config.GUTTER; const tw = r.w - config.GUTTER; const prefix_width = gutterWidth(pane); const body_y = p.bodyTop(pane, r); var vr: i32 = 0; while (vr + @as(i32, pane.tag_rows) < @as(i32, r.h)) : (vr += 1) { const here = pane.wrapAt(vr); if (here.line != row) continue; var hi = word_hi; const next = pane.wrapAt(vr + 1); if (next.line == row) hi = @min(hi, next.at); const lo = @max(word_lo, here.at); if (hi <= lo) continue; const c0 = @as(i32, prefix_width) + here.pad + displayOffset(pane, row, here.at, lo); const c1 = @as(i32, prefix_width) + here.pad + displayEndOffset(pane, row, here.at, hi - 1); const col = @max(@as(i32, prefix_width), c0); const end = @min(c1 + 1, @as(i32, tw)); if (col < end) s.tint(tx + @as(u16, @intCast(col)), body_y + @as(u16, @intCast(vr)), @intCast(end - col), bg, null); } } test "undo keeps its steps within a byte bound, the newest always" { const gpa = std.testing.allocator; const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 80, .rows = 24 }); defer p.deinit(); const pane = try p.setTestFile(""); const f = &pane.file.?; const step = limits.undo_bytes / 4 + 1; const text = try gpa.alloc(u8, step); defer gpa.free(text); for (0..8) |i| { @memset(text, 'a' + @as(u8, @intCast(i))); pushUndo(p, pane); setContent(p, f, try gpa.dupe(u8, text)); } pushUndo(p, pane); const history = f.history; try std.testing.expect(history.undo_len > 0 and history.undo_len < 8); try std.testing.expect(history.bytes <= limits.undo_bytes + step); var sum: usize = 0; for (history.undo[0..history.undo_len]) |snap| sum += snap.content.len; try std.testing.expectEqual(sum, history.bytes); undo(p, pane); try std.testing.expectEqualStrings(text[0..1], f.content[0..1]); }