diff options
| author | Gabriel Schneider <[email protected]> | 2026-11-17 00:35:08 -0300 |
|---|---|---|
| committer | Gabriel Schneider <[email protected]> | 2026-11-17 12:15:01 -0300 |
| commit | d7b3d57ed0ba649f01559356fbf2bf89561990ca (patch) | |
| tree | 37c95f8c04fd86961197a54adbb920675034d98a /src/locations.zig | |
| parent | 218d574b59abd7fb8dd6fe027b12927fc31c3506 (diff) | |
| download | pardes-d7b3d57ed0ba649f01559356fbf2bf89561990ca.tar.gz pardes-d7b3d57ed0ba649f01559356fbf2bf89561990ca.zip | |
rows: a pane's rows from outside, one definition and two sinks: File.setRows is the one writer of a pane's rows (locations.Row, the stored form as it was: digest, dump and blobs unchanged), refusing what its text cannot hold (more rows than lines, an offset or styles past a line's end) and keeping the painting of equal rows; Output.fillRows keeps what is the editor's (the pane, its refill identity, the steps) and hands its rows to it, as the query panes' three writers do; locations.formatRows and parseRows are its text, a line a row, fields a blank apart and the path last (kind m c p with d and u, line col end_line end_col source_column location_end code_start, styles as `-` or `N:start+len=role,...` a role a syntax class and grounds joined by dots); each pane directory over 9P has `rows`, read as that text (+Search's, +Callstack's addresses as data) and written whole lines at a time, at 0 replacing and later following (a line cut by a mount waits for its open's next write; tree.writeLines passes a line on at the offset it was begun at), `>` emptying them; tests: the rows of a +Search, a +Callstack and a +Diff read back from their text equal, byte for byte, and the file read, written whole and across writes, refused and emptied; README, reference and changelog say so
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
Diffstat (limited to 'src/locations.zig')
| -rw-r--r-- | src/locations.zig | 176 |
1 files changed, 176 insertions, 0 deletions
diff --git a/src/locations.zig b/src/locations.zig index fc39f92d..3dc0412d 100644 --- a/src/locations.zig +++ b/src/locations.zig @@ -103,6 +103,135 @@ pub fn equalRows(a: []const Row, b: []const Row) bool { return true; } +// ---- rows as text: a pane's `rows` file (ninep/pane.zig) ---- + +/// Rows as text, a line a row, its fields one blank apart and its path +/// last (a path may hold blanks): its kind (`m` a match n/N step to, `c` +/// context, `p` a preview of source; then `d` when it is a declaration and +/// `u` when its occurrence is not marked), its place (line, col, end_line, +/// end_col; 0 for none), source_column, location_end and code_start (byte +/// offsets in its line), its styles and its path. Styles are `-` for none, +/// else how many bytes they cover from code_start, a colon and the runs +/// that are not plain, `start+len=role`, comma-separated: a role is a +/// syntax class (keyword string number comment) and grounds (add del emph +/// line, syntax.ground_add's), joined by dots. `p 12 0 0 0 0 0 0 +/// 9:0+1=add.line,5+3=keyword.add src/a.zig`. +pub fn formatRows(rows: []const Row, w: *std.Io.Writer) std.Io.Writer.Error!void { + for (rows) |r| { + try w.writeByte(switch (r.kind) { + .match => 'm', + .context => 'c', + .preview => 'p', + }); + if (r.declaration) try w.writeByte('d'); + if (!r.mark_occurrence) try w.writeByte('u'); + try w.print(" {d} {d} {d} {d} {d} {d} {d} ", .{ r.at.line, r.at.col, r.at.end_line, r.at.end_col, r.source_column, r.location_end, r.code_start }); + if (r.colors.len == 0) try w.writeByte('-') else try w.print("{d}:", .{r.colors.len}); + var sep = false; + var at: usize = 0; + while (at < r.colors.len) { + const style = r.colors[at]; + var end = at + 1; + while (end < r.colors.len and r.colors[end] == style) end += 1; + defer at = end; + if (style == 0) continue; + if (sep) try w.writeByte(','); + sep = true; + try w.print("{d}+{d}=", .{ at, end - at }); + var dot = false; + const syn = style & syntax.syn_bits; + if (syn != 0) { + if (std.enums.fromInt(syntax.Syn, syn)) |known| try w.writeAll(@tagName(known)) else try w.print("{d}", .{syn}); + dot = true; + } + for (grounds) |g| if (style & g[0] != 0) { + if (dot) try w.writeByte('.'); + try w.writeAll(g[1]); + dot = true; + }; + } + try w.print(" {s}\n", .{r.path}); + } +} + +const grounds = [_]struct { u8, []const u8 }{ .{ syntax.ground_add, "add" }, .{ syntax.ground_del, "del" }, .{ syntax.ground_emph, "emph" }, .{ syntax.ground_line, "line" } }; + +/// formatRows' text read back, the rows and all they own `arena`'s. +/// BadRows for a line that is not one; a last newline ends the last row. +pub fn parseRows(arena: std.mem.Allocator, text: []const u8) error{ OutOfMemory, BadRows }![]Row { + const body = if (std.mem.endsWith(u8, text, "\n")) text[0 .. text.len - 1] else text; + if (body.len == 0) return &.{}; + var rows: std.ArrayList(Row) = .empty; + var lines = std.mem.splitScalar(u8, body, '\n'); + while (lines.next()) |line| { + var fields: [9][]const u8 = undefined; + var at: usize = 0; + for (&fields) |*field| { + const blank = std.mem.indexOfScalarPos(u8, line, at, ' ') orelse return error.BadRows; + field.* = line[at..blank]; + at = blank + 1; + } + const kind = fields[0]; + if (kind.len == 0) return error.BadRows; + var row: Row = .{ + .kind = switch (kind[0]) { + 'm' => .match, + 'c' => .context, + 'p' => .preview, + else => return error.BadRows, + }, + .path = try arena.dupe(u8, line[at..]), + .at = .{}, + .location_end = 0, + .code_start = 0, + }; + for (kind[1..]) |flag| switch (flag) { + 'd' => row.declaration = true, + 'u' => row.mark_occurrence = false, + else => return error.BadRows, + }; + var numbers: [7]usize = undefined; + for (&numbers, fields[1..8]) |*n, field| n.* = std.fmt.parseInt(usize, field, 10) catch return error.BadRows; + row.at = .{ .line = numbers[0], .col = numbers[1], .end_line = numbers[2], .end_col = numbers[3] }; + row.source_column = numbers[4]; + row.location_end = numbers[5]; + row.code_start = numbers[6]; + const styles = fields[8]; + if (!std.mem.eql(u8, styles, "-")) { + const colon = std.mem.indexOfScalar(u8, styles, ':') orelse return error.BadRows; + const len = std.fmt.parseInt(usize, styles[0..colon], 10) catch return error.BadRows; + // A line is never longer than a file: bounded before it is made. + if (len > @import("memory.zig").limits.max_file_bytes) return error.BadRows; + row.colors = try arena.alloc(u8, len); + @memset(row.colors, 0); + var runs = std.mem.splitScalar(u8, styles[colon + 1 ..], ','); + while (runs.next()) |run| { + if (run.len == 0) continue; + const plus = std.mem.indexOfScalar(u8, run, '+') orelse return error.BadRows; + const eq = std.mem.indexOfScalarPos(u8, run, plus, '=') orelse return error.BadRows; + const start = std.fmt.parseInt(usize, run[0..plus], 10) catch return error.BadRows; + const n = std.fmt.parseInt(usize, run[plus + 1 .. eq], 10) catch return error.BadRows; + if (start > len or n > len - start) return error.BadRows; + var style: u8 = 0; + var names = std.mem.splitScalar(u8, run[eq + 1 ..], '.'); + names: while (names.next()) |name| { + for (grounds) |g| if (std.mem.eql(u8, name, g[1])) { + style |= g[0]; + continue :names; + }; + if (style & syntax.syn_bits != 0) return error.BadRows; + const syn: u8 = if (std.meta.stringToEnum(syntax.Syn, name)) |known| @backingInt(known) else std.fmt.parseInt(u4, name, 10) catch return error.BadRows; + if (syn == 0) return error.BadRows; + style |= syn; + } + @memset(row.colors[start..][0..n], style); + } + } + try rows.append(arena, row); + } + return rows.items; +} + /// Compare native producer rows with an already formatted, context-free view. /// Identical refreshes retain allocations, syntax and selection state. pub fn sameInput(input: []const u8, rendered: []const u8, rows: []const Row, layout: Config.Layout) bool { @@ -984,3 +1113,50 @@ test "locations cache transfers oversized completed analysis without reparsing" try std.testing.expectEqual(@as(usize, 0), cache.len); try std.testing.expectEqual(@as(usize, 0), cache.bytes); } + +test "rows read back from their text are the rows: +Search's, +Callstack's and +Diff's" { + const testing = std.testing; + const p = try pardes.Pardes.init(testing.allocator, .{ .tty_only = true }); + defer p.deinit(); + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + try tmp.dir.writeFile(testing.io, .{ .sub_path = "a.zig", .data = "const S = struct {\n fn f() void {\n a(\"x y\");\n b();\n }\n};\n" }); + var buf: [std.Io.Dir.max_path_bytes]u8 = undefined; + const dir = buf[0..try tmp.dir.realPath(testing.io, &buf)]; + const patch = try std.Io.Dir.path.join(testing.allocator, &.{ dir, "c.patch" }); + defer testing.allocator.free(patch); + const search = try format(p, dir, "a.zig:3:9 a(\"x y\");\na.zig:4:9 b();\n", null, true); + defer p.gpa.free(search.content); + defer freeRows(p.gpa, search.rows); + const callstack = try formatCallstack(p, dir, "a.zig:2:8 f\nāā a.zig:3:9 a\n"); + defer p.gpa.free(callstack.content); + defer freeRows(p.gpa, callstack.rows); + const hid = try pardes.panes.Output.openDiff(p, 0, patch, "--- a.zig\n+++ a.zig\n@@ -2,3 +2,4 @@\n fn f() void {\n- a(\"x\");\n+ a(\"x y\");\n+ b();\n }\n"); + const stacked = p.panes[hid].?.file.?.location_rows; + // A +Diff's rows carry styles with grounds: the codec is tried on them. + var grounded = false; + for (stacked) |row| for (row.colors) |c| { + grounded = grounded or c & syntax.ground_add != 0; + }; + try testing.expect(grounded and search.rows.len > 0 and callstack.rows.len > 0); + var arena_state: std.heap.ArenaAllocator = .init(testing.allocator); + defer arena_state.deinit(); + const arena = arena_state.allocator(); + for ([_][]const Row{ search.rows, callstack.rows, stacked }) |rows| { + var text: std.Io.Writer.Allocating = .init(arena); + try formatRows(rows, &text.writer); + const back = try parseRows(arena, text.written()); + try testing.expect(equalRows(rows, back)); + var again: std.Io.Writer.Allocating = .init(arena); + try formatRows(back, &again.writer); + try testing.expectEqualStrings(text.written(), again.written()); + } + try testing.expectError(error.BadRows, parseRows(arena, "x 1 0 0 0 0 0 0 - a\n")); + try testing.expectError(error.BadRows, parseRows(arena, "m 1 0 0 0 0 0 0 2:0+3=keyword a\n")); + try testing.expectError(error.BadRows, parseRows(arena, "m 1 0 0 0 0 0 0 2:0+1=keyword.string a\n")); + try testing.expectError(error.BadRows, parseRows(arena, "m 1 0 0\n")); + const one = try parseRows(arena, "pd 12 3 0 0 0 0 0 4:0+1=add.line,1+2=keyword.add src/a b.zig\n"); + try testing.expectEqualStrings("src/a b.zig", one[0].path); + try testing.expect(one[0].declaration and one[0].kind == .preview and one[0].at.line == 12 and one[0].at.col == 3); + try testing.expectEqualSlices(u8, &.{ syntax.ground_add | syntax.ground_line, @backingInt(syntax.Syn.keyword) | syntax.ground_add, @backingInt(syntax.Syn.keyword) | syntax.ground_add, 0 }, one[0].colors); +} |
