summaryrefslogtreecommitdiff
path: root/src/modal.zig
diff options
context:
space:
mode:
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" {