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 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;
}
void vis_prompt_show(Vis *vis, const char *title) {
Win *active = vis->win;
Win *prompt = window_new_file(vis, title[0] == ':' ? vis->command_file : vis->search_file,
UI_OPTION_ONELINE);
if (!prompt)
return;
if (vis->mode->visual)
window_selection_save(active);
Text *txt = prompt->file->text;
text_insert(txt, text_size(txt), title, strlen(title));
Cursor *cursor = view_cursors_primary_get(prompt->view);
view_cursors_scroll_to(cursor, text_size(txt));
prompt->parent = active;
prompt->parent_mode = vis->mode;
vis_window_mode_map(prompt, VIS_MODE_NORMAL, true, "<Enter>", &prompt_enter_binding);
vis_window_mode_map(prompt, VIS_MODE_INSERT, true, "<Enter>", &prompt_enter_binding);
vis_window_mode_map(prompt, VIS_MODE_VISUAL, true, "<Enter>", &prompt_enter_binding);
vis_window_mode_map(prompt, VIS_MODE_NORMAL, true, "<Escape>", &prompt_esc_binding);
vis_window_mode_map(prompt, VIS_MODE_INSERT, true, "<Up>", &prompt_up_binding);
vis_window_mode_map(prompt, VIS_MODE_INSERT, true, "<Backspace>", &prompt_backspace_binding);
vis_mode_switch(vis, VIS_MODE_INSERT);
}
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;
}
bool vis_operator(Vis *vis, enum VisOperator id, ...) {
va_list ap;
va_start(ap, id);
switch (id) {
case VIS_OP_CASE_LOWER:
case VIS_OP_CASE_UPPER:
case VIS_OP_CASE_SWAP:
vis->action.arg.i = id;
id = VIS_OP_CASE_SWAP;
break;
case VIS_OP_CURSOR_SOL:
case VIS_OP_CURSOR_EOL:
vis->action.arg.i = id;
id = VIS_OP_CURSOR_SOL;
break;
case VIS_OP_PUT_AFTER:
case VIS_OP_PUT_AFTER_END:
case VIS_OP_PUT_BEFORE:
case VIS_OP_PUT_BEFORE_END:
vis->action.arg.i = id;
id = VIS_OP_PUT_AFTER;
break;
case VIS_OP_FILTER:
vis->action.arg.s = va_arg(ap, char*);
/* fall through */
case VIS_OP_SHIFT_LEFT:
case VIS_OP_SHIFT_RIGHT:
vis_motion_type(vis, VIS_MOTIONTYPE_LINEWISE);
break;
default:
break;
}
if (id >= LENGTH(vis_operators))
goto err;
const Operator *op = &vis_operators[id];
if (vis->mode->visual) {
vis->action.op = op;
action_do(vis, &vis->action);
goto out;
}
/* switch to operator mode inorder to make operator options and
* text-object available */
vis_mode_switch(vis, VIS_MODE_OPERATOR_PENDING);
if (vis->action.op == op) {
/* hacky way to handle double operators i.e. things like
* dd, yy etc where the second char isn't a movement */
vis->action.type = LINEWISE;
vis_motion(vis, VIS_MOVE_LINE_NEXT);
} else {
vis->action.op = op;
}
/* put is not a real operator, does not need a range to operate on */
if (id == VIS_OP_PUT_AFTER)
vis_motion(vis, VIS_MOVE_NOP);
out:
va_end(ap);
return true;
err:
va_end(ap);
return false;
}
static const char *selection_restore(Vis *vis, const char *keys, const Arg *arg) {
for (Cursor *c = view_cursors(vis_view(vis)); c; c = view_cursors_next(c))
view_cursors_selection_restore(c);
vis_mode_switch(vis, VIS_MODE_VISUAL);
return keys;
}
