summaryrefslogtreecommitdiff
path: root/src/modal.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-10-30 17:35:06 -0300
committerGabriel Schneider <[email protected]>2026-10-30 17:35:06 -0300
commit6d8da8721141284cf33bb901168b26135893eb86 (patch)
tree791d63401d4e85fbca1d597a8ce0326e70efd545 /src/modal.zig
parentefd43a3a2cf03bb741366331158b368abf9ac583 (diff)
parentbf6810a8f9d6cc82050e7d9c0cfb06358301b574 (diff)
downloadpardes-6d8da8721141284cf33bb901168b26135893eb86.tar.gz
pardes-6d8da8721141284cf33bb901168b26135893eb86.zip
Merge latest upstream into the macOS branch for Zig 0.17
Retain the macOS branch history and local Acme selection color while adopting upstream's current core and platform changes. Pin Zig and ZLS to 0.17.0, and fetch the existing zstbi compatibility commit through upstream after its original fork was removed.
Diffstat (limited to 'src/modal.zig')
-rw-r--r--src/modal.zig474
1 files changed, 360 insertions, 114 deletions
diff --git a/src/modal.zig b/src/modal.zig
index 3827d11f..7e10a877 100644
--- a/src/modal.zig
+++ b/src/modal.zig
@@ -15,6 +15,8 @@ pub const Normal = struct {
prefix_replace,
prefix_next,
prefix_prev,
+ prefix_register,
+ prefix_view_sticky,
goto_file_start,
goto_last_line,
@@ -27,15 +29,19 @@ pub const Normal = struct {
goto_view_top,
goto_view_center,
goto_view_bottom,
+ goto_last_modification,
+ goto_word,
goto_definition,
goto_declaration,
goto_type_definition,
goto_implementation,
goto_references,
+ goto_callstack,
view_top,
view_center,
view_bottom,
+ view_middle,
view_scroll_down,
view_scroll_up,
@@ -49,6 +55,13 @@ pub const Normal = struct {
add_newline,
goto_diagnostic,
goto_diagnostic_end,
+ goto_function,
+ goto_class,
+ goto_parameter,
+ goto_comment,
+ goto_test,
+ goto_entry,
+ goto_xml_element,
move_left,
move_right,
@@ -96,6 +109,17 @@ pub const Normal = struct {
trim_sels,
select_regex,
split_regex,
+ keep_regex,
+ remove_regex,
+ ensure_forward,
+ expand_node,
+ shrink_node,
+ next_sibling,
+ prev_sibling,
+ all_siblings,
+ all_children,
+ parent_node_end,
+ parent_node_start,
delete,
delete_noyank,
@@ -108,6 +132,10 @@ pub const Normal = struct {
to_lowercase,
to_uppercase,
join_lines,
+ join_select_space,
+ rotate_contents_fwd,
+ rotate_contents_back,
+ align_selections,
indent,
unindent,
format,
@@ -123,13 +151,19 @@ pub const Normal = struct {
pipe_selection_to,
insert_output,
append_output,
+ keep_pipe,
+ macro_record,
+ macro_replay,
+ repeat_insert,
search,
search_next,
search_prev,
+ search_selection,
+ search_selection_word,
};
pub const Input = struct {
- roles: std.EnumSet(Role) = .initEmpty(),
+ roles: std.EnumSet(Role) = .empty,
cp: u21,
ctrl: bool = false,
alt: bool = false,
@@ -156,6 +190,7 @@ pub const Normal = struct {
replace,
next,
prev,
+ register,
};
pub const MatchSub = enum(u8) {
@@ -172,9 +207,14 @@ pub const Normal = struct {
prefix: Prefix = .none,
match_sub: MatchSub = .none,
held_char: u21 = 0,
+ /// `"<reg>`: the register the next command names, 0 for none
+ register: u21 = 0,
+ /// `Z`: the view keys stay armed until Esc (helix's sticky view)
+ sticky: bool = false,
+ /// Drop what is pending; sticky view mode stays armed through it.
pub fn clear(state: *State) void {
- state.* = .{};
+ state.* = if (state.sticky) .{ .sticky = true, .prefix = .view } else .{};
}
};
@@ -188,13 +228,22 @@ pub const Normal = struct {
insert,
/// `A-!` — no stdin, and the output is appended AFTER each selection.
append,
+ /// `$` — stdin is the selection; the output is discarded, and only the
+ /// selections the command exits 0 on are kept.
+ keep,
/// Do the selections become stdin? helix's `pipe` flag.
pub fn pipes(b: PipeBehavior) bool {
- return b == .replace or b == .ignore;
+ return b == .replace or b == .ignore or b == .keep;
}
};
+ /// helix's tree-sitter selection keys: where a range goes in the tree
+ /// helix's tree-sitter textobjects, by what their queries call them
+ pub const Object = enum { function, class, parameter, comment, @"test", entry, xml_element };
+ pub const NodeWalk = enum { expand, shrink, next_sibling, prev_sibling, all_siblings, all_children, parent_end, parent_start };
+ /// what the s/S/K/Alt-K prompt does with its pattern's matches
+ pub const RegexMode = enum { select, split, keep, remove };
pub const Scope = enum { once, per_selection };
pub const Direction = enum { backward, forward };
pub const Motion = enum {
@@ -221,8 +270,9 @@ pub const Normal = struct {
view_top,
view_center,
view_bottom,
+ last_modification,
};
- pub const View = enum { top, center, bottom, scroll_down, scroll_up };
+ pub const View = enum { top, center, bottom, middle, scroll_down, scroll_up };
pub const Find = enum { forward, backward, till_forward, till_backward };
pub const Line = enum { start, end, first_nonws };
pub const Page = enum { half_down, half_up, down, up };
@@ -247,6 +297,7 @@ pub const Normal = struct {
merge,
merge_consecutive,
trim,
+ ensure_forward,
};
pub const Edit = enum {
delete,
@@ -260,13 +311,17 @@ pub const Normal = struct {
lowercase,
uppercase,
join_lines,
+ join_select_space,
+ rotate_contents_forward,
+ rotate_contents_backward,
+ align_selections,
indent,
unindent,
comment_toggle,
undo,
redo,
};
- pub const Lsp = enum { definition, declaration, type_definition, implementation, references, format };
+ pub const Lsp = enum { definition, declaration, type_definition, implementation, references, callstack, format };
pub const Counted = struct {
count: u32,
@@ -295,7 +350,7 @@ pub const Normal = struct {
insert: struct { kind: Insert, count: u32 },
select: struct { kind: Select, count: u32 },
multi: struct { kind: Multi, count: u32 },
- select_regex: bool, // false = select, true = split
+ select_regex: RegexMode,
edit: struct { kind: Edit, count: u32 },
lsp: Lsp,
adjust_number: i64,
@@ -303,7 +358,14 @@ pub const Normal = struct {
command_line,
pipe_selection: PipeBehavior,
search,
- search_step: Direction,
+ search_step: struct { direction: Direction, count: u32 },
+ search_selection: bool,
+ goto_word,
+ macro_record,
+ macro_replay: u32,
+ node: NodeWalk,
+ object_jump: struct { object: Object, direction: Direction, count: u32 },
+ repeat_insert: u32,
pub fn scope(value: Action) Scope {
return switch (value) {
@@ -315,9 +377,23 @@ pub const Normal = struct {
.pipe_selection,
.search,
.search_step,
+ .search_selection,
+ .macro_record,
+ .macro_replay,
+ .node,
+ .goto_word,
+ .repeat_insert,
=> .once,
.edit => |edit| switch (edit.kind) {
- .comment_toggle, .undo, .redo => .once,
+ .join_lines,
+ .join_select_space,
+ .rotate_contents_forward,
+ .rotate_contents_backward,
+ .align_selections,
+ .comment_toggle,
+ .undo,
+ .redo,
+ => .once,
else => .per_selection,
},
else => .per_selection,
@@ -354,7 +430,10 @@ pub const Normal = struct {
pub fn parse(state: *State, key: Input) Result {
if (key.has(.escape)) {
- state.clear();
+ // Esc out of sticky view mode leaves that mode and nothing else
+ const sticky = state.sticky;
+ state.* = .{};
+ if (sticky) return .ignored;
return resultAction(.escape);
}
@@ -375,27 +454,18 @@ pub const Normal = struct {
switch (state.prefix) {
.goto => {
state.prefix = .none;
- if (key.has(.goto_file_start)) return resultAction(.{ .goto = .{ .target = .file_start, .count = count, .explicit_count = counted.explicit } });
- if (key.has(.goto_last_line)) return resultAction(.{ .goto = .{ .target = .last_line, .count = count, .explicit_count = counted.explicit } });
- if (key.has(.goto_line_start)) return resultAction(.{ .goto = .{ .target = .line_start, .count = count, .explicit_count = counted.explicit } });
- if (key.has(.goto_line_end)) return resultAction(.{ .goto = .{ .target = .line_end, .count = count, .explicit_count = counted.explicit } });
- if (key.has(.goto_first_nonws)) return resultAction(.{ .goto = .{ .target = .first_nonws, .count = count, .explicit_count = counted.explicit } });
- if (key.has(.goto_line_down)) return resultAction(.{ .goto = .{ .target = .line_down, .count = count, .explicit_count = counted.explicit } });
- if (key.has(.goto_line_up)) return resultAction(.{ .goto = .{ .target = .line_up, .count = count, .explicit_count = counted.explicit } });
- if (key.has(.goto_column)) return resultAction(.{ .goto = .{ .target = .column, .count = count, .explicit_count = counted.explicit } });
- if (key.has(.goto_view_top)) return resultAction(.{ .goto = .{ .target = .view_top, .count = count, .explicit_count = counted.explicit } });
- if (key.has(.goto_view_center)) return resultAction(.{ .goto = .{ .target = .view_center, .count = count, .explicit_count = counted.explicit } });
- if (key.has(.goto_view_bottom)) return resultAction(.{ .goto = .{ .target = .view_bottom, .count = count, .explicit_count = counted.explicit } });
- if (key.has(.goto_definition)) return resultAction(.{ .lsp = .definition });
- if (key.has(.goto_declaration)) return resultAction(.{ .lsp = .declaration });
- if (key.has(.goto_type_definition)) return resultAction(.{ .lsp = .type_definition });
- if (key.has(.goto_implementation)) return resultAction(.{ .lsp = .implementation });
- if (key.has(.goto_references)) return resultAction(.{ .lsp = .references });
+ // each target's role is its name after `goto_`
+ inline for (comptime std.enums.values(Goto)) |target|
+ if (key.has(@field(Role, "goto_" ++ @tagName(target)))) return resultAction(.{ .goto = .{ .target = target, .count = count, .explicit_count = counted.explicit } });
+ if (key.has(.goto_word)) return resultAction(.goto_word);
+ inline for (.{ .definition, .declaration, .type_definition, .implementation, .references, .callstack }) |lsp|
+ if (key.has(@field(Role, "goto_" ++ @tagName(lsp)))) return resultAction(.{ .lsp = lsp });
return .ignored;
},
.view => {
- state.prefix = .none;
+ if (!state.sticky) state.prefix = .none;
if (key.has(.view_top)) return resultAction(.{ .view = .top });
+ if (key.has(.view_middle)) return resultAction(.{ .view = .middle });
if (key.has(.view_center)) return resultAction(.{ .view = .center });
if (key.has(.view_bottom)) return resultAction(.{ .view = .bottom });
if (key.has(.view_scroll_down)) return resultAction(.{ .view = .scroll_down });
@@ -473,14 +543,28 @@ pub const Normal = struct {
if (key.has(.add_newline)) return resultAction(.{ .add_newline = .{ .direction = direction, .count = count } });
if (key.has(.goto_diagnostic)) return resultAction(.{ .diagnostic = .{ .direction = direction, .endpoint = false } });
if (key.has(.goto_diagnostic_end)) return resultAction(.{ .diagnostic = .{ .direction = direction, .endpoint = true } });
+ inline for (.{ .{ .goto_function, .function }, .{ .goto_class, .class }, .{ .goto_parameter, .parameter }, .{ .goto_comment, .comment }, .{ .goto_test, .@"test" }, .{ .goto_entry, .entry }, .{ .goto_xml_element, .xml_element } }) |pair|
+ if (key.has(pair[0])) return resultAction(.{ .object_jump = .{ .object = pair[1], .direction = direction, .count = count } });
return .ignored;
},
+ .register => {
+ state.prefix = .none;
+ const char = key.literal() orelse return .ignored;
+ state.register = char;
+ // the count typed before `"` is still the command's
+ state.count = if (counted.explicit) count else 0;
+ return .pending;
+ },
.none => {},
}
// Prefix setters retain the count for their continuation.
if (key.has(.prefix_goto)) return armPrefix(state, .goto, if (counted.explicit) count else 0);
if (key.has(.prefix_view)) return armPrefix(state, .view, if (counted.explicit) count else 0);
+ if (key.has(.prefix_view_sticky)) {
+ state.sticky = true;
+ return armPrefix(state, .view, 0);
+ }
if (key.has(.prefix_find_fwd)) return armPrefix(state, .find_fwd, if (counted.explicit) count else 0);
if (key.has(.prefix_find_back)) return armPrefix(state, .find_back, if (counted.explicit) count else 0);
if (key.has(.prefix_till_fwd)) return armPrefix(state, .till_fwd, if (counted.explicit) count else 0);
@@ -489,6 +573,7 @@ pub const Normal = struct {
if (key.has(.prefix_next)) return armPrefix(state, .next, if (counted.explicit) count else 0);
if (key.has(.prefix_prev)) return armPrefix(state, .prev, if (counted.explicit) count else 0);
if (key.has(.prefix_match)) return armPrefix(state, .match, 0);
+ if (key.has(.prefix_register)) return armPrefix(state, .register, if (counted.explicit) count else 0);
if (key.has(.move_left)) return resultAction(.{ .move = .{ .motion = .left, .count = count } });
if (key.has(.move_right)) return resultAction(.{ .move = .{ .motion = .right, .count = count } });
@@ -510,20 +595,11 @@ pub const Normal = struct {
if (key.has(.page_down)) return resultAction(.{ .page = .{ .kind = .down, .count = count } });
if (key.has(.page_up)) return resultAction(.{ .page = .{ .kind = .up, .count = count } });
- if (key.has(.insert)) return resultAction(.{ .insert = .{ .kind = .at, .count = count } });
- if (key.has(.append)) return resultAction(.{ .insert = .{ .kind = .append, .count = count } });
- if (key.has(.insert_line_start)) return resultAction(.{ .insert = .{ .kind = .line_start, .count = count } });
- if (key.has(.insert_line_end)) return resultAction(.{ .insert = .{ .kind = .line_end, .count = count } });
- if (key.has(.open_below)) return resultAction(.{ .insert = .{ .kind = .open_below, .count = count } });
- if (key.has(.open_above)) return resultAction(.{ .insert = .{ .kind = .open_above, .count = count } });
+ inline for (.{ .{ .insert, .at }, .{ .append, .append }, .{ .insert_line_start, .line_start }, .{ .insert_line_end, .line_end }, .{ .open_below, .open_below }, .{ .open_above, .open_above } }) |pair|
+ if (key.has(pair[0])) return resultAction(.{ .insert = .{ .kind = pair[1], .count = count } });
- if (key.has(.select_mode)) return resultAction(.{ .select = .{ .kind = .mode, .count = count } });
- if (key.has(.select_line)) return resultAction(.{ .select = .{ .kind = .line, .count = count } });
- if (key.has(.select_line_bounds)) return resultAction(.{ .select = .{ .kind = .line_bounds, .count = count } });
- if (key.has(.shrink_to_line_bounds)) return resultAction(.{ .select = .{ .kind = .shrink_to_line_bounds, .count = count } });
- if (key.has(.collapse_selection)) return resultAction(.{ .select = .{ .kind = .collapse, .count = count } });
- if (key.has(.flip_selection)) return resultAction(.{ .select = .{ .kind = .flip, .count = count } });
- if (key.has(.select_all)) return resultAction(.{ .select = .{ .kind = .all, .count = count } });
+ inline for (.{ .{ .select_mode, .mode }, .{ .select_line, .line }, .{ .select_line_bounds, .line_bounds }, .{ .shrink_to_line_bounds, .shrink_to_line_bounds }, .{ .collapse_selection, .collapse }, .{ .flip_selection, .flip }, .{ .select_all, .all } }) |pair|
+ if (key.has(pair[0])) return resultAction(.{ .select = .{ .kind = pair[1], .count = count } });
if (key.has(.copy_sel_below)) return resultAction(.{ .multi = .{ .kind = .copy_below, .count = count } });
if (key.has(.copy_sel_above)) return resultAction(.{ .multi = .{ .kind = .copy_above, .count = count } });
@@ -535,8 +611,19 @@ pub const Normal = struct {
if (key.has(.merge_sels)) return resultAction(.{ .multi = .{ .kind = .merge, .count = count } });
if (key.has(.merge_consecutive_sels)) return resultAction(.{ .multi = .{ .kind = .merge_consecutive, .count = count } });
if (key.has(.trim_sels)) return resultAction(.{ .multi = .{ .kind = .trim, .count = count } });
- if (key.has(.select_regex)) return resultAction(.{ .select_regex = false });
- if (key.has(.split_regex)) return resultAction(.{ .select_regex = true });
+ if (key.has(.select_regex)) return resultAction(.{ .select_regex = .select });
+ if (key.has(.split_regex)) return resultAction(.{ .select_regex = .split });
+ if (key.has(.keep_regex)) return resultAction(.{ .select_regex = .keep });
+ if (key.has(.remove_regex)) return resultAction(.{ .select_regex = .remove });
+ if (key.has(.ensure_forward)) return resultAction(.{ .multi = .{ .kind = .ensure_forward, .count = count } });
+ if (key.has(.expand_node)) return resultAction(.{ .node = .expand });
+ if (key.has(.shrink_node)) return resultAction(.{ .node = .shrink });
+ if (key.has(.next_sibling)) return resultAction(.{ .node = .next_sibling });
+ if (key.has(.prev_sibling)) return resultAction(.{ .node = .prev_sibling });
+ if (key.has(.all_siblings)) return resultAction(.{ .node = .all_siblings });
+ if (key.has(.all_children)) return resultAction(.{ .node = .all_children });
+ if (key.has(.parent_node_end)) return resultAction(.{ .node = .parent_end });
+ if (key.has(.parent_node_start)) return resultAction(.{ .node = .parent_start });
if (key.has(.delete)) return resultAction(.{ .edit = .{ .kind = .delete, .count = count } });
if (key.has(.delete_noyank)) return resultAction(.{ .edit = .{ .kind = .delete_noyank, .count = count } });
@@ -549,6 +636,10 @@ pub const Normal = struct {
if (key.has(.to_lowercase)) return resultAction(.{ .edit = .{ .kind = .lowercase, .count = count } });
if (key.has(.to_uppercase)) return resultAction(.{ .edit = .{ .kind = .uppercase, .count = count } });
if (key.has(.join_lines)) return resultAction(.{ .edit = .{ .kind = .join_lines, .count = count } });
+ if (key.has(.join_select_space)) return resultAction(.{ .edit = .{ .kind = .join_select_space, .count = count } });
+ if (key.has(.rotate_contents_fwd)) return resultAction(.{ .edit = .{ .kind = .rotate_contents_forward, .count = count } });
+ if (key.has(.rotate_contents_back)) return resultAction(.{ .edit = .{ .kind = .rotate_contents_backward, .count = count } });
+ if (key.has(.align_selections)) return resultAction(.{ .edit = .{ .kind = .align_selections, .count = count } });
if (key.has(.indent)) return resultAction(.{ .edit = .{ .kind = .indent, .count = count } });
if (key.has(.unindent)) return resultAction(.{ .edit = .{ .kind = .unindent, .count = count } });
if (key.has(.format)) return resultAction(.{ .lsp = .format });
@@ -564,9 +655,15 @@ pub const Normal = struct {
if (key.has(.pipe_selection_to)) return resultAction(.{ .pipe_selection = .ignore });
if (key.has(.insert_output)) return resultAction(.{ .pipe_selection = .insert });
if (key.has(.append_output)) return resultAction(.{ .pipe_selection = .append });
+ if (key.has(.keep_pipe)) return resultAction(.{ .pipe_selection = .keep });
+ if (key.has(.macro_record)) return resultAction(.macro_record);
+ if (key.has(.macro_replay)) return resultAction(.{ .macro_replay = count });
+ if (key.has(.repeat_insert)) return resultAction(.{ .repeat_insert = count });
if (key.has(.search)) return resultAction(.search);
- if (key.has(.search_next)) return resultAction(.{ .search_step = .forward });
- if (key.has(.search_prev)) return resultAction(.{ .search_step = .backward });
+ if (key.has(.search_selection)) return resultAction(.{ .search_selection = false });
+ if (key.has(.search_selection_word)) return resultAction(.{ .search_selection = true });
+ if (key.has(.search_next)) return resultAction(.{ .search_step = .{ .direction = .forward, .count = count } });
+ if (key.has(.search_prev)) return resultAction(.{ .search_step = .{ .direction = .backward, .count = count } });
return .unbound;
}
@@ -669,7 +766,7 @@ fn codepointAt(text: []const u8, off: usize) u21 {
return std.unicode.utf8Decode(text[off .. off + n]) catch 0xFFFD;
}
-fn isUnicodeWhitespace(cp: u21) bool {
+pub fn isUnicodeWhitespace(cp: u21) bool {
if (cp == ' ' or (cp >= '\t' and cp <= '\r') or cp == 0x85) return true;
return switch (uucode.get(.general_category, cp)) {
.separator_space, .separator_line, .separator_paragraph => true,
@@ -738,13 +835,6 @@ pub fn firstNonWs(line: []const u8) usize {
return i;
}
-pub fn firstNonWsOf(lines: []const []const u8, c: Cursor) Cursor {
- // the row can sit past the content (mouse click below a short pane's
- // last line) — out of range reads as an empty line, like lineLenOf
- if (c.row >= lines.len) return .{ .row = c.row, .col = 0 };
- return .{ .row = c.row, .col = firstNonWs(lines[c.row]) };
-}
-
pub fn charLeft(lines: []const []const u8, c: Cursor) Cursor {
if (c.row >= lines.len) return .{ .row = c.row, .col = 0 };
return .{ .row = c.row, .col = prevGrapheme(lines[c.row], @min(c.col, lines[c.row].len)) };
@@ -870,13 +960,77 @@ pub fn lineCount(content: []const u8) usize {
// byte offset of the start of line `row` (0-based). row may == lineCount()
// (== content.len, the end).
pub fn lineStartOffset(content: []const u8, row: usize) usize {
+ // Newlines counted 32 bytes at a time, the last block byte by byte: one
+ // indexOfScalarPos per line was a call per line, 7000 of them to find
+ // line 7000 of a source, for every cursor move, selection and language
+ // request there.
+ const block = 32;
+ const Block = @Vector(block, u8);
var off: usize = 0;
- var r: usize = 0;
- while (r < row) : (r += 1) {
- const nl = std.mem.indexOfScalarPos(u8, content, off, '\n') orelse return content.len;
- off = nl + 1;
+ var left = row;
+ if (left == 0) return 0;
+ while (off + block <= content.len) : (off += block) {
+ const chunk: Block = content[off..][0..block].*;
+ const found: usize = @popCount(@as(u32, @bitCast(chunk == @as(Block, @splat('\n')))));
+ if (found >= left) break;
+ left -= found;
+ }
+ while (off < content.len) : (off += 1) if (content[off] == '\n') {
+ left -= 1;
+ if (left == 0) return off + 1;
+ };
+ return content.len;
+}
+
+test "lineStartOffset by blocks and offsetAt agree with a line at a time" {
+ var prng: std.Random.DefaultPrng = .init(0x9e3779b9);
+ const random = prng.random();
+ var buf: [300]u8 = undefined;
+ for (0..2000) |_| {
+ const len = random.uintLessThan(usize, buf.len);
+ for (buf[0..len]) |*b| b.* = if (random.uintLessThan(u8, 4) == 0) '\n' else 'a';
+ const text = buf[0..len];
+ for (0..len + 3) |row| {
+ var off: usize = 0;
+ var r: usize = 0;
+ const want = while (r < row) : (r += 1) {
+ off = (std.mem.indexOfScalarPos(u8, text, off, '\n') orelse break text.len) + 1;
+ } else off;
+ try std.testing.expectEqual(want, lineStartOffset(text, row));
+ const cursor: Cursor = .{ .row = row, .col = random.uintLessThan(usize, 6) };
+ const clamped = lineStartOffset(text, @min(row, cursorLineCount(text) - 1));
+ const end = std.mem.indexOfScalarPos(u8, text, clamped, '\n') orelse text.len;
+ try std.testing.expectEqual(clamped + graphemeStart(text[clamped..end], @min(cursor.col, end - clamped)), offsetAt(text, cursor));
+ // lineSpan, as it was: a line at a time, null past the last.
+ const span: ?LineSpan = span: {
+ if (text.len == 0) break :span null;
+ var start: usize = 0;
+ for (0..row) |_| start = (std.mem.indexOfScalarPos(u8, text, start, '\n') orelse break :span null) + 1;
+ if (start == text.len and !(row == 0 or text[text.len - 1] == '\n')) break :span null;
+ break :span .{ .start = start, .end = std.mem.indexOfScalarPos(u8, text, start, '\n') orelse text.len };
+ };
+ try std.testing.expectEqual(span, lineSpan(text, row));
+ // rangeBytes, as it was: each line looked for from the top, twice.
+ const other: Cursor = .{ .row = random.uintLessThan(usize, len + 3), .col = random.uintLessThan(usize, 6) };
+ var lo = cursor;
+ var hi = other;
+ if (hi.row < lo.row or (hi.row == lo.row and hi.col < lo.col)) std.mem.swap(Cursor, &lo, &hi);
+ const lo_line = lineSlice(text, lo.row);
+ const hi_line = lineSlice(text, hi.row);
+ const s0 = lineStartOffset(text, lo.row) + graphemeStart(lo_line, @min(lo.col, lo_line.len));
+ var e0 = lineStartOffset(text, hi.row) + graphemeStart(hi_line, @min(hi.col, hi_line.len));
+ if (e0 < text.len) e0 = nextGrapheme(text, e0);
+ const got = rangeBytes(text, cursor, other);
+ try std.testing.expectEqual(s0, got.s);
+ try std.testing.expectEqual(@max(s0, e0), got.e);
+ }
}
- return off;
+}
+
+/// The line that starts at `start` (lineSlice's, once its start is known).
+fn lineFrom(content: []const u8, start: usize) []const u8 {
+ if (start >= content.len) return "";
+ return content[start .. std.mem.indexOfScalarPos(u8, content, start, '\n') orelse content.len];
}
// the text of line `row` (no terminator), a slice into `content`.
@@ -892,23 +1046,29 @@ pub fn lineSlice(content: []const u8, row: usize) []const u8 {
/// A bounded scan of one line; null if the row does not exist.
pub const LineSpan = struct { start: usize, end: usize };
+/// Just past the `row`-th newline; null if the text has fewer.
+pub fn lineStartExact(content: []const u8, row: usize) ?usize {
+ const at = lineStartOffset(content, row);
+ // At the end: either the row-th newline was the last byte, or there were fewer.
+ if (at == content.len and std.mem.count(u8, content, "\n") < row) return null;
+ return at;
+}
+
pub fn lineSpan(content: []const u8, row: usize) ?LineSpan {
// Match lineCount: empty content has no lines; a trailing newline adds one.
if (content.len == 0) return null;
- var start: usize = 0;
- var r: usize = 0;
- while (r < row) : (r += 1) {
- const nl = std.mem.indexOfScalarPos(u8, content, start, '\n') orelse return null;
- start = nl + 1;
- }
- if (start > content.len) return null;
+ const start = lineStartExact(content, row) orelse return null;
if (start == content.len and !(row == 0 or content.len == 0 or content[content.len - 1] == '\n')) return null;
const end = std.mem.indexOfScalarPos(u8, content, start, '\n') orelse content.len;
return .{ .start = start, .end = end };
}
-fn spliceAlloc(alloc: std.mem.Allocator, content: []const u8, start: usize, end: usize, replacement: []const u8) ![]u8 {
- const out = try alloc.alloc(u8, content.len - (end - start) + replacement.len);
+pub fn spliceAlloc(alloc: std.mem.Allocator, content: []const u8, start: usize, end: usize, replacement: []const u8) ![]u8 {
+ // Raw: every byte is written below, where `alloc` fills a safe build's
+ // new memory first, a whole file's worth per keystroke.
+ const len = content.len - (end - start) + replacement.len;
+ if (len == 0) return alloc.alloc(u8, 0);
+ const out = (alloc.rawAlloc(len, .of(u8), @returnAddress()) orelse return error.OutOfMemory)[0..len];
@memcpy(out[0..start], content[0..start]);
@memcpy(out[start..][0..replacement.len], replacement);
@memcpy(out[start + replacement.len ..], content[end..]);
@@ -917,13 +1077,18 @@ fn spliceAlloc(alloc: std.mem.Allocator, content: []const u8, start: usize, end:
/// insert `text` at (row, col). col is clamped to the line length.
pub fn insertAt(alloc: std.mem.Allocator, content: []const u8, c: Cursor, text: []const u8) ![]u8 {
+ const off = insertOffset(content, c);
+ return spliceAlloc(alloc, content, off, off, text);
+}
+
+/// Where insertAt puts its text: col clamped to the line, no further.
+pub fn insertOffset(content: []const u8, c: Cursor) usize {
// Only an out-of-range row requires counting the whole document.
const span = lineSpan(content, c.row) orelse blk: {
const last = lineCount(content) -| 1;
break :blk lineSpan(content, last) orelse LineSpan{ .start = content.len, .end = content.len };
};
- const off = span.start + @min(c.col, span.end - span.start);
- return spliceAlloc(alloc, content, off, off, text);
+ return span.start + @min(c.col, span.end - span.start);
}
// delete the character at (row, col). no-op if col is past the line end.
@@ -986,12 +1151,15 @@ fn rangeBytes(content: []const u8, a: Cursor, b: Cursor) struct { s: usize, e: u
lo = b;
hi = a;
}
- const lo_line = lineSlice(content, lo.row);
- const hi_line = lineSlice(content, hi.row);
+ // Each line found once, the second from the first.
+ const lo_start = lineStartOffset(content, lo.row);
+ const hi_start = if (hi.row == lo.row) lo_start else lo_start + lineStartOffset(content[lo_start..], hi.row - lo.row);
+ const lo_line = lineFrom(content, lo_start);
+ const hi_line = lineFrom(content, hi_start);
const lo_col = graphemeStart(lo_line, @min(lo.col, lo_line.len));
const hi_col = graphemeStart(hi_line, @min(hi.col, hi_line.len));
- const s = lineStartOffset(content, lo.row) + lo_col;
- var e = lineStartOffset(content, hi.row) + hi_col;
+ const s = lo_start + lo_col;
+ var e = hi_start + hi_col;
if (e < content.len) e = nextGrapheme(content, e); // include the grapheme under the head
return .{ .s = s, .e = @max(s, e) };
}
@@ -1019,12 +1187,12 @@ pub fn clearLine(alloc: std.mem.Allocator, content: []const u8, row: usize) ![]u
// paste `text` as a new line BELOW `row`. Multiline `text` becomes several lines.
pub fn pasteLineBelow(alloc: std.mem.Allocator, content: []const u8, row: usize, text: []const u8) ![]u8 {
- const n = lineCount(content);
- const off = if (row + 1 < n) lineStartOffset(content, row + 1) else content.len;
+ // The next line's start, or the end: no whole-text line count to know which.
+ const off = lineStartExact(content, row + 1) orelse content.len;
const suffix_newline = off < content.len or (content.len > 0 and content[content.len - 1] == '\n');
const prefix_newline = !suffix_newline and off > 0;
const extra: usize = @intFromBool(suffix_newline or prefix_newline);
- const out = try alloc.alloc(u8, content.len + text.len + extra);
+ const out = try @import("memory.zig").unfilled(alloc, content.len + text.len + extra);
var write: usize = 0;
@memcpy(out[write..][0..off], content[0..off]);
write += off;
@@ -1211,6 +1379,58 @@ pub fn lineEndOffset(text: []const u8, line: usize) usize {
}
/// gap offset -> (row, col) cell
+/// The start of the UTF-8 rune `off` falls in. Addresses (the 9P `addr`,
+/// `dot`, `#n`, `line:col`, a search's match) count runes, as sam's and
+/// acme's do, not grapheme clusters: a lone combining mark or a `\r` is a
+/// place of its own, whatever a terminal draws in one cell.
+pub fn runeStart(text: []const u8, off: usize) usize {
+ const o = @min(off, text.len);
+ if (o == text.len or text[o] & 0xC0 != 0x80) return o;
+ var s = o;
+ var steps: u8 = 0;
+ while (s > 0 and text[s] & 0xC0 == 0x80 and steps < 3) : (steps += 1) s -= 1;
+ // Only a lead byte whose sequence reaches `o`, its bytes all
+ // continuations, makes `o` the inside of a rune; a stray continuation
+ // byte (invalid UTF-8) is a place of its own.
+ const n = std.unicode.utf8ByteSequenceLength(text[s]) catch return o;
+ if (s + n <= o or s + n > text.len) return o;
+ for (text[s + 1 .. s + n]) |c| if (c & 0xC0 != 0x80) return o;
+ return s;
+}
+
+/// `off`, or the end of the rune it falls inside.
+pub fn runeEnd(text: []const u8, off: usize) usize {
+ const o = @min(off, text.len);
+ const s = runeStart(text, o);
+ if (s == o) return o;
+ return s + (std.unicode.utf8ByteSequenceLength(text[s]) catch 1);
+}
+
+/// The rune boundary after the one at `off`.
+pub fn nextRune(text: []const u8, off: usize) usize {
+ return if (off >= text.len) text.len else runeEnd(text, off + 1);
+}
+
+/// The rune boundary before `off`.
+pub fn prevRune(text: []const u8, off: usize) usize {
+ return if (off == 0) 0 else runeStart(text, @min(off, text.len) - 1);
+}
+
+/// `positionAt` snapped to a rune rather than a grapheme cluster.
+pub fn runePositionAt(text: []const u8, off: usize) Cursor {
+ const bounded = runeStart(text, off);
+ const s = if (std.mem.lastIndexOfScalar(u8, text[0..bounded], '\n')) |nl| nl + 1 else 0;
+ return .{ .row = lineAtOffset(text, bounded), .col = bounded - s };
+}
+
+/// `offsetAt` snapped to a rune rather than a grapheme cluster.
+pub fn runeOffsetAt(text: []const u8, c: Cursor) usize {
+ const row = @min(c.row, cursorLineCount(text) - 1);
+ const s = lineStartOffset(text, row);
+ const e = std.mem.indexOfScalarPos(u8, text, s, '\n') orelse text.len;
+ return s + runeStart(text[s..e], @min(c.col, e - s));
+}
+
pub fn positionAt(text: []const u8, off: usize) Cursor {
const bounded = @min(off, text.len);
// Find the line start backward without a second scan of the document prefix.
@@ -1222,8 +1442,10 @@ pub fn positionAt(text: []const u8, off: usize) Cursor {
/// (row, col) -> clamped gap offset; col == line length lands ON the '\n'
pub fn offsetAt(text: []const u8, c: Cursor) usize {
- const row = @min(c.row, cursorLineCount(text) - 1);
- const s = lineStartOffset(text, row);
+ // A row past the last is the last: found back from the end, where
+ // counting every line of the text to clamp it cost a pass over all of it.
+ var s = lineStartOffset(text, c.row);
+ if (s == text.len) s = if (std.mem.lastIndexOfScalar(u8, text, '\n')) |nl| nl + 1 else 0;
// lineEndOffset(text, row) inlined: it starts by walking to `row` again,
// and we are already standing there
const e = std.mem.indexOfScalarPos(u8, text, s, '\n') orelse text.len;
@@ -1257,6 +1479,17 @@ fn wordClassAt(text: []const u8, off: usize) WordClass {
};
}
+pub fn searchWordAt(text: []const u8, off: usize) bool {
+ return off < text.len and wordClassAt(text, off) == .word;
+}
+
+pub fn searchWordBefore(text: []const u8, off: usize) bool {
+ if (off == 0) return false;
+ var previous = off - 1;
+ while (previous > 0 and text[previous] & 0xc0 == 0x80) previous -= 1;
+ return searchWordAt(text, previous);
+}
+
fn isWordWhitespace(c: WordClass) bool { // Rust char::is_whitespace (includes line endings)
return c == .ws or c == .eol;
}
@@ -1287,6 +1520,53 @@ fn wmIsPrev(t: WordTarget) bool {
}
/// w/b/e/W/B/E: helix word_move — each step selects the traversed span.
+/// helix jump_to_word's candidates: the words of two or more word
+/// characters between `start` and `end`, nearest the cursor first, taking one
+/// forward and one back in turn, each over its word pointing the way it was
+/// found, as many as `out` holds.
+pub fn jumpWords(text: []const u8, cursor: usize, start: usize, end: usize, out: []Selection) usize {
+ var fwd: Selection = .{ .anchor = cursor, .head = cursor };
+ var rev = fwd;
+ if (cursor < text.len and !isWordWhitespace(wordClassAt(text, cursor))) {
+ const word_end = moveWord(text, fwd, 1, .next_word_end);
+ if (word_end.anchor == cursor) fwd = word_end; // a word of one grapheme
+ const word_start = moveWord(text, rev, 1, .prev_word_start);
+ if (word_start.anchor == nextGrapheme(text, cursor)) rev = word_start;
+ }
+ var n: usize = 0;
+ while (n < out.len) {
+ var changed = false;
+ while (fwd.head < end) {
+ fwd = moveWord(text, fwd, 1, .next_word_end);
+ // the two graphemes before the head are word characters
+ const one = prevGrapheme(text, fwd.head);
+ if (fwd.head == 0 or one == 0 or wordClassAt(text, one) != .word or wordClassAt(text, prevGrapheme(text, one)) != .word) continue;
+ changed = true;
+ var from = fwd.anchor;
+ while (from < fwd.head and wordClassAt(text, from) != .word) from = nextGrapheme(text, from);
+ fwd.anchor = from;
+ out[n] = fwd;
+ n += 1;
+ break;
+ }
+ if (n == out.len) break;
+ while (rev.head > start) {
+ rev = moveWord(text, rev, 1, .prev_word_start);
+ // the two graphemes from the head are word characters
+ if (wordClassAt(text, rev.head) != .word or wordClassAt(text, nextGrapheme(text, rev.head)) != .word) continue;
+ changed = true;
+ var to = rev.anchor;
+ while (to > rev.head and wordClassAt(text, prevGrapheme(text, to)) != .word) to = prevGrapheme(text, to);
+ rev.anchor = to;
+ out[n] = rev;
+ n += 1;
+ break;
+ }
+ if (!changed) break;
+ }
+ return n;
+}
+
pub fn moveWord(text: []const u8, r0: Selection, count: usize, target: WordTarget) Selection {
const is_prev = wmIsPrev(target);
if ((is_prev and r0.head == 0) or (!is_prev and r0.head == text.len)) return r0;
@@ -1408,18 +1688,6 @@ pub fn moveParagraph(text: []const u8, r: Selection, count: usize, fwd: bool, ex
return .{ .anchor = anchor, .head = head };
}
-/// j/k target: helix move_vertically — goal_col clamps to the line's content
-/// length, i.e. the cursor may land ON the '\n' of a shorter line.
-pub fn verticalTarget(text: []const u8, pos: usize, down: bool, count: usize, goal_col: usize) usize {
- const nlines = cursorLineCount(text);
- const line = lineAtOffset(text, pos);
- const nline = if (down) @min(line + @max(1, count), nlines - 1) else line -| @max(1, count);
- const s = lineStartOffset(text, nline);
- // lineEndOffset(text, nline) without its second walk to nline (see offsetAt)
- const e = std.mem.indexOfScalarPos(u8, text, s, '\n') orelse text.len;
- return s + graphemeStart(text[s..e], @min(goal_col, e - s));
-}
-
/// f/F/t/T target cell. helix find_char: the exclusive (till) search starts
/// one further out so repeats make progress; not-found = null (no move).
pub fn findTarget(text: []const u8, cursor: usize, ch: u21, fwd: bool, till: bool, count: usize) ?usize {
@@ -1554,21 +1822,10 @@ test "selection textobjects distinguish words and paragraph boundaries" {
try std.testing.expectEqual(@as(usize, 7), r.head);
}
-/// leading-whitespace visual width (tab -> next multiple of INDENT_W)
-pub fn indentWidth(line: []const u8) usize {
- var w: usize = 0;
- for (line) |ch| {
- if (ch == ' ') w += 1 else if (ch == '\t') w = (w / INDENT_W + 1) * INDENT_W else break;
- }
- return w;
-}
-
-/// full indent LEVELS of a line as spaces (helix indent_level_for_line:
-/// partial levels round down) — what o/O/insert-newline copy.
+/// A line's indent as it is, tabs and spaces both, as acme's autoindent
+/// copies it: what o/O/insert-newline give the new line.
pub fn indentText(line: []const u8) []const u8 {
- const level = indentWidth(line) / INDENT_W;
- const max = " "; // 8 levels is plenty (ponytail)
- return max[0..@min(level * INDENT_W, max.len)];
+ return line[0 .. std.mem.indexOfNone(u8, line, " \t") orelse line.len];
}
/// Copy full indent levels and add one after (, [, {, or ), without parsing.
@@ -1678,14 +1935,6 @@ test "paragraph selections cross blank lines" {
try std.testing.expectEqual(@as(usize, 7), r.head);
}
-test "vertical target clamps the goal column onto the newline cell" {
- const t = "abcdef\nab\nabcdef\n";
- // from (0,5) down: line "ab" clamps to its '\n' at offset 9
- try std.testing.expectEqual(@as(usize, 9), verticalTarget(t, 5, true, 1, 5));
- // two down with the same goal restores col 5
- try std.testing.expectEqual(@as(usize, 15), verticalTarget(t, 9, true, 1, 5));
-}
-
test "find targets count matches and skip adjacent till targets" {
const t = "abcabc\n";
try std.testing.expectEqual(@as(usize, 2), findTarget(t, 0, 'c', true, false, 1).?);
@@ -1850,14 +2099,11 @@ test "codepoint classes distinguish words punctuation and whitespace" {
try std.testing.expectEqual(Kind.ws, kindOfCodepoint('\n'));
}
-test "insert cursor steps characters and skips indentation" {
+test "insert cursor steps characters" {
const lines = [_][]const u8{ "alpha beta", " two words", "x" };
const c = Cursor{ .row = 0, .col = 5 };
try std.testing.expectEqual(Cursor{ .row = 0, .col = 4 }, charLeft(&.{"hello"}, c));
try std.testing.expectEqual(Cursor{ .row = 0, .col = 6 }, charRight(&lines, c));
- try std.testing.expectEqual(Cursor{ .row = 1, .col = 2 }, firstNonWsOf(&lines, Cursor{ .row = 1, .col = 0 }));
- // cursor row past the content (mouse click below a short pane): no panic
- try std.testing.expectEqual(Cursor{ .row = 24, .col = 0 }, firstNonWsOf(&lines, Cursor{ .row = 24, .col = 3 }));
}
test "lineSpan agrees with the whole-document scans it replaces" {