static const char *cursors_select_next(Vis *vis, const char *keys, const Arg *arg) {
Text *txt = vis_text(vis);
View *view = vis_view(vis);
Cursor *cursor = view_cursor(view);
Filerange sel = view_cursors_selection_get(cursor);
if (!text_range_valid(&sel))
return keys;
size_t len = text_range_size(&sel);
char *buf = malloc(len+1);
if (!buf)
return keys;
len = text_bytes_get(txt, sel.start, len, buf);
buf[len] = '\0';
Filerange word = text_object_word_find_next(txt, sel.end, buf);
free(buf);
if (text_range_valid(&word)) {
cursor = view_cursors_new(view);
if (!cursor)
return keys;
view_cursors_selection_set(cursor, &word);
view_cursors_to(cursor, text_char_prev(txt, word.end));
}
return keys;
}
static const char *cursors_select(Vis *vis, const char *keys, const Arg *arg) {
Text *txt = vis_text(vis);
View *view = vis_view(vis);
for (Cursor *cursor = view_cursors(view); cursor; cursor = view_cursors_next(cursor)) {
Filerange sel = view_cursors_selection_get(cursor);
Filerange word = text_object_word(txt, view_cursors_pos(cursor));
if (!text_range_valid(&sel) && text_range_valid(&word)) {
view_cursors_selection_set(cursor, &word);
view_cursors_to(cursor, text_char_prev(txt, word.end));
}
}
vis_mode_switch(vis, VIS_MODE_VISUAL);
return keys;
}
Filerange text_object_function(Text *txt, size_t pos) {
Filerange r = object_function(txt, pos);
if (!text_range_valid(&r))
return r;
r.end++;
return text_range_linewise(txt, &r);
}
enum SamError sam_cmd(Vis *vis, const char *s) {
enum SamError err = SAM_ERR_OK;
if (!s)
return err;
Command *cmd = sam_parse(vis, s, &err);
if (!cmd) {
if (err == SAM_ERR_OK)
err = SAM_ERR_MEMORY;
return err;
}
Filerange range = text_range_empty();
sam_execute(vis, vis->win, cmd, NULL, &range);
if (vis->win) {
bool completed = true;
for (Cursor *c = view_cursors(vis->win->view); c; c = view_cursors_next(c)) {
Filerange sel = view_cursors_selection_get(c);
if (text_range_valid(&sel)) {
completed = false;
break;
}
}
vis_mode_switch(vis, completed ? VIS_MODE_NORMAL : VIS_MODE_VISUAL);
}
command_free(cmd);
return err;
}
static void window_selection_changed(void *win, Filerange *sel) {
File *file = ((Win*)win)->file;
if (text_range_valid(sel)) {
file->marks[MARK_SELECTION_START] = text_mark_set(file->text, sel->start);
file->marks[MARK_SELECTION_END] = text_mark_set(file->text, sel->end);
}
}
Filerange text_object_function_inner(Text *txt, size_t pos) {
Filerange r = text_object_function(txt, pos);
if (!text_range_valid(&r))
return r;
size_t b = text_function_end_next(txt, pos);
size_t a = text_bracket_match(txt, b);
return text_range_new(a+1, b-1);
}
static const char *prompt_enter(Vis *vis, const char *keys, const Arg *arg) {
Win *prompt = vis->win;
View *view = prompt->view;
Text *txt = prompt->file->text;
Win *win = prompt->parent;
char *cmd = NULL;
Filerange range = view_selection_get(view);
if (!text_range_valid(&range))
range = text_object_line(txt, view_cursor_get(view));
if (text_range_valid(&range))
cmd = text_bytes_alloc0(txt, range.start, text_range_size(&range));
if (!win || !cmd) {
vis_info_show(vis, "Prompt window invalid\n");
prompt_restore(prompt);
prompt_hide(prompt);
free(cmd);
return keys;
}
size_t len = strlen(cmd);
if (len > 0 && cmd[len-1] == '\n')
cmd[len-1] = '\0';
bool lastline = (range.end == text_size(txt));
prompt_restore(prompt);
if (vis_prompt_cmd(vis, cmd)) {
prompt_hide(prompt);
if (!lastline) {
text_delete(txt, range.start, text_range_size(&range));
text_appendf(txt, "%s\n", cmd);
}
} else {
vis->win = prompt;
vis->mode = &vis_modes[VIS_MODE_INSERT];
}
free(cmd);
vis_draw(vis);
return keys;
}
size_t text_range_line_last(Text *txt, Filerange *r) {
if (!text_range_valid(r))
return EPOS;
size_t pos = text_line_begin(txt, r->end);
if (pos == r->end) {
/* range ends at a begin of a line, skip last line ending */
pos = text_line_prev(txt, pos);
pos = text_line_begin(txt, pos);
}
return r->start <= pos ? pos : r->start;
}
static bool cmd_select(Vis *vis, Win *win, Command *cmd, const char *argv[], Cursor *cur, Filerange *range) {
Filerange sel = text_range_empty();
if (!win)
return sam_execute(vis, NULL, cmd->cmd, NULL, &sel);
bool ret = true;
View *view = win->view;
Text *txt = win->file->text;
bool multiple_cursors = view_cursors_multiple(view);
Cursor *primary = view_cursors_primary_get(view);
for (Cursor *c = view_cursors(view), *next; c && ret; c = next) {
next = view_cursors_next(c);
size_t pos = view_cursors_pos(c);
if (vis->mode->visual) {
sel = view_cursors_selection_get(c);
} else if (cmd->cmd->address) {
/* convert a single line range to a goto line motion */
if (!multiple_cursors && cmd->cmd->cmddef->func == cmd_print) {
Address *addr = cmd->cmd->address;
switch (addr->type) {
case '+':
case '-':
addr = addr->right;
/* fall through */
case 'l':
if (addr && addr->type == 'l' && !addr->right)
addr->type = 'g';
break;
}
}
sel = text_range_new(pos, pos);
} else if (cmd->cmd->cmddef->flags & CMD_ADDRESS_POS) {
sel = text_range_new(pos, pos);
} else if (cmd->cmd->cmddef->flags & CMD_ADDRESS_LINE) {
sel = text_object_line(txt, pos);
} else if (cmd->cmd->cmddef->flags & CMD_ADDRESS_AFTER) {
size_t next_line = text_line_next(txt, pos);
sel = text_range_new(next_line, next_line);
} else if (multiple_cursors) {
sel = text_object_line(txt, pos);
} else {
sel = text_range_new(0, text_size(txt));
}
if (text_range_valid(&sel))
ret &= sam_execute(vis, win, cmd->cmd, c, &sel);
if (cmd->cmd->cmddef->flags & CMD_ONCE)
break;
}
if (vis->win && vis->win->view == view && primary != view_cursors_primary_get(view))
view_cursors_primary_set(view_cursors(view));
return ret;
}
Filerange view_selection_get(View *view) {
Filerange sel = view->sel;
if (sel.start > sel.end) {
size_t tmp = sel.start;
sel.start = sel.end;
sel.end = tmp;
}
if (!text_range_valid(&sel))
return text_range_empty();
sel.end = text_char_next(view->text, sel.end);
return sel;
}
static Filerange text_object_bracket(Text *txt, size_t pos, char type) {
char c, open, close;
int opened = 1, closed = 1;
Filerange r = text_range_empty();
switch (type) {
case '(': case ')': open = '('; close = ')'; break;
case '{': case '}': open = '{'; close = '}'; break;
case '[': case ']': open = '['; close = ']'; break;
case '<': case '>': open = '<'; close = '>'; break;
case '"': open = '"'; close = '"'; break;
case '`': open = '`'; close = '`'; break;
case '\'': open = '\''; close = '\''; break;
default: return r;
}
Iterator it = text_iterator_get(txt, pos);
if (open == close && text_iterator_byte_get(&it, &c) && (c == '"' || c == '`' || c == '\'')) {
size_t match = text_bracket_match(txt, pos);
r.start = MIN(pos, match) + 1;
r.end = MAX(pos, match);
return r;
}
while (text_iterator_byte_get(&it, &c)) {
if (c == open && --opened == 0) {
r.start = it.pos + 1;
break;
} else if (c == close && it.pos != pos) {
opened++;
}
text_iterator_byte_prev(&it, NULL);
}
it = text_iterator_get(txt, pos);
while (text_iterator_byte_get(&it, &c)) {
if (c == close && --closed == 0) {
r.end = it.pos;
break;
} else if (c == open && it.pos != pos) {
closed++;
}
text_iterator_byte_next(&it, NULL);
}
if (!text_range_valid(&r))
return text_range_empty();
return r;
}
Filerange text_object_number(Text *txt, size_t pos) {
char *buf, *err = NULL;
Filerange r = text_object_range(txt, pos, is_number);
if (!text_range_valid(&r))
return r;
if (!(buf = text_bytes_alloc0(txt, r.start, text_range_size(&r))))
return text_range_empty();
errno = 0;
strtoll(buf, &err, 0);
if (errno || err == buf)
r = text_range_empty();
else
r.end = r.start + (err - buf);
free(buf);
return r;
}
static bool cmd_print(Vis *vis, Win *win, Command *cmd, const char *argv[], Cursor *cur, Filerange *range) {
if (!win || !text_range_valid(range))
return false;
View *view = win->view;
Text *txt = win->file->text;
size_t pos = range->end;
if (range->start != range->end)
pos = text_char_prev(txt, pos);
if (cur)
view_cursors_to(cur, pos);
else
cur = view_cursors_new_force(view, pos);
if (cur) {
if (range->start != range->end)
view_cursors_selection_set(cur, range);
else
view_cursors_selection_clear(cur);
}
return cur != NULL;
}
static bool sam_execute(Vis *vis, Win *win, Command *cmd, Cursor *cur, Filerange *range) {
bool ret = true;
if (cmd->address && win)
*range = address_evaluate(cmd->address, win->file, range, 0);
switch (cmd->argv[0][0]) {
case '{':
{
if (!win) {
ret = false;
break;
}
Text *txt = win->file->text;
Mark start, end;
Filerange group = *range;
for (Command *c = cmd->cmd; c && ret; c = c->next) {
if (!text_range_valid(&group))
return false;
start = text_mark_set(txt, group.start);
end = text_mark_set(txt, group.end);
ret &= sam_execute(vis, win, c, NULL, &group);
size_t s = text_mark_get(txt, start);
/* hack to make delete work, only update if still valid */
if (s != EPOS)
group.start = s;
group.end = text_mark_get(txt, end);
}
break;
}
default:
ret = cmd->cmddef->func(vis, win, cmd, cmd->argv, cur, range);
break;
}
return ret;
}
Filerange text_range_union(const Filerange *r1, const Filerange *r2) {
if (!text_range_valid(r1))
return *r2;
if (!text_range_valid(r2))
return *r1;
return (Filerange) {
.start = MIN(r1->start, r2->start),
.end = MAX(r1->end, r2->end),
};
}
Filerange text_range_new(size_t a, size_t b) {
return (Filerange) {
.start = MIN(a, b),
.end = MAX(a, b),
};
}
bool text_range_equal(const Filerange *r1, const Filerange *r2) {
if (!text_range_valid(r1) && !text_range_valid(r2))
return true;
return r1->start == r2->start && r1->end == r2->end;
}
bool text_range_overlap(const Filerange *r1, const Filerange *r2) {
if (!text_range_valid(r1) || !text_range_valid(r2))
return false;
return r1->start <= r2->end && r2->start <= r1->end;
}
bool text_range_contains(const Filerange *r, size_t pos) {
return text_range_valid(r) && r->start <= pos && pos <= r->end;
}
int text_char_count(const char *data, size_t len) {
int count = 0;
mbstate_t ps = { 0 };
while (len > 0) {
wchar_t wc;
size_t wclen = mbrtowc(&wc, data, len, &ps);
if (wclen == (size_t)-1 && errno == EILSEQ) {
count++;
while (!ISUTF8(*data))
data++, len--;
} else if (wclen == (size_t)-2) {
break;
} else if (wclen == 0) {
count++;
data++;
len--;
} else {
int width = wcwidth(wc);
if (width != 0)
count++;
data += wclen;
len -= wclen;
}
}
return count;
}
int text_string_width(const char *data, size_t len) {
int width = 0;
mbstate_t ps = { 0 };
const char *s = data;
while (len > 0) {
char buf[MB_CUR_MAX];
wchar_t wc;
size_t wclen = mbrtowc(&wc, s, len, &ps);
if (wclen == (size_t)-1 && errno == EILSEQ) {
/* assume a replacement symbol will be displayed */
width++;
wclen = 1;
} else if (wclen == (size_t)-2) {
/* do nothing, advance to next character */
wclen = 1;
} else if (wclen == 0) {
/* assume NUL byte will be displayed as ^@ */
width += 2;
wclen = 1;
} else if (buf[0] == '\t') {
width++;
wclen = 1;
} else {
int w = wcwidth(wc);
if (w == -1)
w = 2; /* assume non-printable will be displayed as ^{char} */
width += w;
}
len -= wclen;
s += wclen;
}
return width;
}
size_t text_range_size(const Filerange *r) {
return text_range_valid(r) ? r->end - r->start : 0;
}
static bool cmd_extract(Vis *vis, Win *win, Command *cmd, const char *argv[], Cursor *cur, Filerange *range) {
if (!win)
return false;
bool ret = true;
Text *txt = win->file->text;
if (cmd->regex) {
size_t start = range->start, end = range->end, last_start = EPOS;
RegexMatch match[1];
while (start < end) {
bool found = text_search_range_forward(txt, start,
end - start, cmd->regex, 1, match,
start > range->start ? REG_NOTBOL : 0) == 0;
Filerange r = text_range_empty();
if (found) {
if (argv[0][0] == 'x')
r = text_range_new(match[0].start, match[0].end);
else
r = text_range_new(start, match[0].start);
if (match[0].start == match[0].end) {
if (last_start == match[0].start) {
start++;
continue;
}
/* in Plan 9's regexp library ^ matches the beginning
* of a line, however in POSIX with REG_NEWLINE ^
* matches the zero-length string immediately after a
* newline. Try filtering out the last such match at EOF.
*/
if (end == match[0].start && start > range->start)
break;
}
start = match[0].end;
} else {
if (argv[0][0] == 'y')
r = text_range_new(start, end);
start = end;
}
if (text_range_valid(&r)) {
Mark mark_start = text_mark_set(txt, start);
Mark mark_end = text_mark_set(txt, end);
ret &= sam_execute(vis, win, cmd->cmd, NULL, &r);
last_start = start = text_mark_get(txt, mark_start);
if (start == EPOS && last_start != r.end)
last_start = start = r.end;
end = text_mark_get(txt, mark_end);
if (start == EPOS || end == EPOS) {
ret = false;
break;
}
}
}
} else {
size_t start = range->start, end = range->end;
while (start < end) {
size_t next = text_line_next(txt, start);
if (next > end)
next = end;
Filerange r = text_range_new(start, next);
if (start == next || !text_range_valid(&r))
break;
start = next;
Mark mark_start = text_mark_set(txt, start);
Mark mark_end = text_mark_set(txt, end);
ret &= sam_execute(vis, win, cmd->cmd, NULL, &r);
start = text_mark_get(txt, mark_start);
if (start == EPOS)
start = r.end;
end = text_mark_get(txt, mark_end);
if (end == EPOS) {
ret = false;
break;
}
}
}
view_cursors_dispose(cur);
return ret;
}
Filerange text_object_function_inner(Text *txt, size_t pos) {
Filerange r = object_function(txt, pos);
if (!text_range_valid(&r))
return r;
return text_range_new(text_bracket_match(txt, r.end)+1, r.end);
}
size_t text_parenthese_end(Text *txt, size_t pos) {
Filerange r = text_object_paranthese(txt, pos+1);
return text_range_valid(&r) ? r.end : pos;
}
bool text_range_is_linewise(Text *txt, Filerange *r) {
return text_range_valid(r) &&
r->start == text_line_begin(txt, r->start) &&
r->end == text_line_begin(txt, r->end);
}
size_t text_range_line_first(Text *txt, Filerange *r) {
if (!text_range_valid(r))
return EPOS;
return r->start;
}
static void ui_window_draw(UiWin *w) {
UiCursesWin *win = (UiCursesWin*)w;
if (!ui_window_draw_sidebar(win))
return;
wbkgd(win->win, style_to_attr(&win->styles[UI_STYLE_DEFAULT]));
wmove(win->win, 0, 0);
int width = view_width_get(win->view);
CellStyle *prev_style = NULL;
size_t cursor_lineno = -1;
if (win->options & UI_OPTION_CURSOR_LINE && win->ui->selwin == win) {
Cursor *cursor = view_cursors(win->view);
Filerange selection = view_cursors_selection_get(cursor);
if (!view_cursors_next(cursor) && !text_range_valid(&selection))
cursor_lineno = view_cursor_getpos(win->view).line;
}
short selection_bg = win->styles[UI_STYLE_SELECTION].bg;
short cursor_line_bg = win->styles[UI_STYLE_CURSOR_LINE].bg;
bool multiple_cursors = view_cursors_multiple(win->view);
attr_t attr = A_NORMAL;
for (const Line *l = view_lines_get(win->view); l; l = l->next) {
bool cursor_line = l->lineno == cursor_lineno;
for (int x = 0; x < width; x++) {
enum UiStyles style_id = l->cells[x].style;
if (style_id == 0)
style_id = UI_STYLE_DEFAULT;
CellStyle *style = &win->styles[style_id];
if (l->cells[x].cursor && win->ui->selwin == win) {
if (multiple_cursors && l->cells[x].cursor_primary)
attr = style_to_attr(&win->styles[UI_STYLE_CURSOR_PRIMARY]);
else
attr = style_to_attr(&win->styles[UI_STYLE_CURSOR]);
prev_style = NULL;
} else if (l->cells[x].selected) {
if (style->fg == selection_bg)
attr |= A_REVERSE;
else
attr = style->attr | COLOR_PAIR(color_pair_get(style->fg, selection_bg));
prev_style = NULL;
} else if (cursor_line) {
attr = style->attr | COLOR_PAIR(color_pair_get(style->fg, cursor_line_bg));
prev_style = NULL;
} else if (style != prev_style) {
attr = style_to_attr(style);
prev_style = style;
}
wattrset(win->win, attr);
waddstr(win->win, l->cells[x].data);
}
/* try to fixup display issues, in theory we should always output a full line */
int x, y;
getyx(win->win, y, x);
(void)y;
wattrset(win->win, A_NORMAL);
for (; 0 < x && x < width; x++)
waddstr(win->win, " ");
}
wclrtobot(win->win);
if (win->winstatus)
ui_window_draw_status(w);
}
size_t text_block_start(Text *txt, size_t pos) {
Filerange r = text_object_curly_bracket(txt, pos-1);
return text_range_valid(&r) ? r.start-1 : pos;
}
size_t text_block_end(Text *txt, size_t pos) {
Filerange r = text_object_curly_bracket(txt, pos+1);
return text_range_valid(&r) ? r.end : pos;
}
size_t text_parenthese_start(Text *txt, size_t pos) {
Filerange r = text_object_paranthese(txt, pos-1);
return text_range_valid(&r) ? r.start-1 : pos;
}
void action_do(Vis *vis, Action *a) {
Win *win = vis->win;
Text *txt = win->file->text;
View *view = win->view;
if (a->op == &vis_operators[VIS_OP_FILTER] && !vis->mode->visual)
vis_mode_switch(vis, VIS_MODE_VISUAL_LINE);
int count = MAX(a->count, 1);
bool repeatable = a->op && !vis->macro_operator;
bool multiple_cursors = view_cursors_multiple(view);
bool linewise = !(a->type & CHARWISE) && (
a->type & LINEWISE || (a->movement && a->movement->type & LINEWISE) ||
vis->mode == &vis_modes[VIS_MODE_VISUAL_LINE]);
for (Cursor *cursor = view_cursors(view), *next; cursor; cursor = next) {
next = view_cursors_next(cursor);
size_t pos = view_cursors_pos(cursor);
Register *reg = multiple_cursors ? view_cursors_register(cursor) : a->reg;
if (!reg)
reg = &vis->registers[win->file->internal ? VIS_REG_PROMPT : VIS_REG_DEFAULT];
OperatorContext c = {
.count = count,
.pos = pos,
.newpos = EPOS,
.range = text_range_empty(),
.reg = reg,
.linewise = linewise,
.arg = &a->arg,
};
if (a->movement) {
size_t start = pos;
for (int i = 0; i < count; i++) {
size_t pos_prev = pos;
if (a->movement->txt)
pos = a->movement->txt(txt, pos);
else if (a->movement->cur)
pos = a->movement->cur(cursor);
else if (a->movement->file)
pos = a->movement->file(vis, vis->win->file, pos);
else if (a->movement->vis)
pos = a->movement->vis(vis, txt, pos);
else if (a->movement->view)
pos = a->movement->view(vis, view);
else if (a->movement->win)
pos = a->movement->win(vis, win, pos);
else if (a->movement->user)
pos = a->movement->user(vis, win, a->movement->data, pos);
if (pos == EPOS || a->movement->type & IDEMPOTENT || pos == pos_prev)
break;
}
if (pos == EPOS) {
c.range.start = start;
c.range.end = start;
pos = start;
} else {
c.range = text_range_new(start, pos);
c.newpos = pos;
}
if (!a->op) {
if (a->movement->type & CHARWISE)
view_cursors_scroll_to(cursor, pos);
else
view_cursors_to(cursor, pos);
if (vis->mode->visual)
c.range = view_cursors_selection_get(cursor);
if (a->movement->type & JUMP)
window_jumplist_add(win, pos);
else
window_jumplist_invalidate(win);
} else if (a->movement->type & INCLUSIVE ||
(linewise && a->movement->type & LINEWISE_INCLUSIVE)) {
c.range.end = text_char_next(txt, c.range.end);
}
} else if (a->textobj) {
if (vis->mode->visual)
c.range = view_cursors_selection_get(cursor);
else
c.range.start = c.range.end = pos;
for (int i = 0; i < count; i++) {
Filerange r = text_range_empty();
if (a->textobj->txt)
r = a->textobj->txt(txt, pos);
else if (a->textobj->vis)
r = a->textobj->vis(vis, txt, pos);
else if (a->textobj->user)
r = a->textobj->user(vis, win, a->textobj->data, pos);
if (!text_range_valid(&r))
break;
if (a->textobj->type & OUTER) {
r.start--;
r.end++;
}
if (a->textobj->type & SPLIT)
c.range = r;
else
c.range = text_range_union(&c.range, &r);
if (i < count - 1)
pos = c.range.end + 1;
}
} else if (vis->mode->visual) {
c.range = view_cursors_selection_get(cursor);
if (!text_range_valid(&c.range))
c.range.start = c.range.end = pos;
}
if (linewise && vis->mode != &vis_modes[VIS_MODE_VISUAL])
c.range = text_range_linewise(txt, &c.range);
if (vis->mode->visual) {
view_cursors_selection_set(cursor, &c.range);
if (vis->mode == &vis_modes[VIS_MODE_VISUAL] || a->textobj)
view_cursors_selection_sync(cursor);
}
if (a->op) {
size_t pos = a->op->func(vis, txt, &c);
if (pos == EPOS) {
view_cursors_dispose(cursor);
} else if (pos <= text_size(txt)) {
/* moving the cursor will affect the selection.
* because we want to be able to later restore
* the old selection we update it again before
* leaving visual mode.
*/
Filerange sel = view_cursors_selection_get(cursor);
view_cursors_to(cursor, pos);
if (vis->mode->visual) {
if (sel.start == EPOS && sel.end == EPOS)
sel = c.range;
else if (sel.start == EPOS)
sel = text_range_new(c.range.start, sel.end);
else if (sel.end == EPOS)
sel = text_range_new(c.range.start, sel.start);
if (vis->mode == &vis_modes[VIS_MODE_VISUAL_LINE])
sel = text_range_linewise(txt, &sel);
view_cursors_selection_set(cursor, &sel);
}
}
}
}
if (a->op) {
/* we do not support visual repeat, still do something resonable */
if (vis->mode->visual && !a->movement && !a->textobj)
a->movement = &vis_motions[VIS_MOVE_NOP];
/* operator implementations must not change the mode,
* they might get called multiple times (once for every cursor)
*/
if (a->op == &vis_operators[VIS_OP_INSERT] || a->op == &vis_operators[VIS_OP_CHANGE]) {
vis_mode_switch(vis, VIS_MODE_INSERT);
} else if (a->op == &vis_operators[VIS_OP_REPLACE]) {
vis_mode_switch(vis, VIS_MODE_REPLACE);
} else if (a->op == &vis_operators[VIS_OP_FILTER]) {
if (a->arg.s)
vis_cmd(vis, a->arg.s);
else
vis_prompt_show(vis, ":|");
} else if (vis->mode == &vis_modes[VIS_MODE_OPERATOR_PENDING]) {
mode_set(vis, vis->mode_prev);
} else if (vis->mode->visual) {
vis_mode_switch(vis, VIS_MODE_NORMAL);
}
text_snapshot(txt);
vis_draw(vis);
}
if (a != &vis->action_prev) {
if (repeatable) {
if (!a->macro)
a->macro = vis->macro_operator;
vis->action_prev = *a;
}
action_reset(a);
}
}
void action_reset(Action *a) {
memset(a, 0, sizeof(*a));
a->count = VIS_COUNT_UNKNOWN;
}
static Filerange address_evaluate(Address *addr, File *file, Filerange *range, int sign) {
Filerange ret = text_range_empty();
do {
switch (addr->type) {
case '#':
if (sign > 0)
ret.start = ret.end = range->end + addr->number;
else if (sign < 0)
ret.start = ret.end = range->start - addr->number;
else
ret = text_range_new(addr->number, addr->number);
break;
case 'l':
case 'g':
ret = address_line_evaluate(addr, file, range, sign);
break;
case '?':
sign = sign == 0 ? -1 : -sign;
/* fall through */
case '/':
if (sign >= 0)
ret = text_object_search_forward(file->text, range->end, addr->regex);
else
ret = text_object_search_backward(file->text, range->start, addr->regex);
break;
case '$':
{
size_t size = text_size(file->text);
ret = text_range_new(size, size);
break;
}
case '.':
ret = *range;
break;
case '+':
case '-':
sign = addr->type == '+' ? +1 : -1;
if (!addr->right || addr->right->type == '+' || addr->right->type == '-')
ret = address_line_evaluate(addr, file, range, sign);
break;
case ',':
case ';':
{
Filerange left, right;
if (addr->left)
left = address_evaluate(addr->left, file, range, 0);
else
left = text_range_new(0, 0);
if (addr->type == ';')
range = &left;
if (addr->right) {
right = address_evaluate(addr->right, file, range, 0);
} else {
size_t size = text_size(file->text);
right = text_range_new(size, size);
}
/* TODO: enforce strict ordering? */
return text_range_union(&left, &right);
}
case '%':
return text_range_new(0, text_size(file->text));
}
if (text_range_valid(&ret))
range = &ret;
} while ((addr = addr->right));
return ret;
}
