?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
vis: respect window local mappings for child modes
[vis.git] / vis.c
blob1138dd7a8cba869eb5801e348c239aeb1c1cdb76
1 /*
2 * Copyright (c) 2014-2015 Marc André Tanner <mat at brain-dump.org>
3 *
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15 */
16 #include <locale.h>
17 #include <stdlib.h>
18 #include <unistd.h>
19 #include <string.h>
20 #include <strings.h>
21 #include <signal.h>
22 #include <stdarg.h>
23 #include <stdio.h>
24 #include <errno.h>
25 #include <fcntl.h>
26 #include <limits.h>
27 #include <ctype.h>
28 #include <time.h>
29 #include <regex.h>
30 #include <sys/select.h>
31 #include <sys/types.h>
32 #include <sys/wait.h>
33 #include <sys/stat.h>
34 #include <sys/ioctl.h>
35 #include <sys/mman.h>
36 #include <pwd.h>
37 #include <termkey.h>
38
39 #include "vis.h"
40 #include "text-util.h"
41 #include "text-motions.h"
42 #include "text-objects.h"
43 #include "util.h"
44 #include "vis-core.h"
45
46 /* enable large file optimization for files larger than: */
47 #define LARGE_FILE (1 << 25)
48
49 static Macro *macro_get(Vis *vis, enum VisMacro m);
50 static void macro_replay(Vis *vis, const Macro *macro);
51
52 /** window / file handling */
53
54 static void file_free(Vis *vis, File *file) {
55 if (!file)
56 return;
57 if (file->refcount > 1) {
58 --file->refcount;
59 return;
60 }
61 if (vis->event && vis->event->file_close)
62 vis->event->file_close(vis, file);
63 text_free(file->text);
64 free((char*)file->name);
65
66 if (file->prev)
67 file->prev->next = file->next;
68 if (file->next)
69 file->next->prev = file->prev;
70 if (vis->files == file)
71 vis->files = file->next;
72 free(file);
73 }
74
75 static File *file_new_text(Vis *vis, Text *text) {
76 File *file = calloc(1, sizeof(*file));
77 if (!file)
78 return NULL;
79 file->text = text;
80 file->stat = text_stat(text);
81 if (vis->files)
82 vis->files->prev = file;
83 file->next = vis->files;
84 vis->files = file;
85 return file;
86 }
87
88 static File *file_new(Vis *vis, const char *filename) {
89 if (filename) {
90 /* try to detect whether the same file is already open in another window
91 * TODO: do this based on inodes */
92 for (File *file = vis->files; file; file = file->next) {
93 if (file->name && strcmp(file->name, filename) == 0) {
94 return file;
95 }
96 }
97 }
98
99 Text *text = text_load(filename);
100 if (!text && filename && errno == ENOENT)
101 text = text_load(NULL);
102 if (!text)
103 return NULL;
104
105 File *file = file_new_text(vis, text);
106 if (!file) {
107 text_free(text);
108 return NULL;
109 }
110
111 if (filename)
112 file->name = strdup(filename);
113 if (vis->event && vis->event->file_open)
114 vis->event->file_open(vis, file);
115 return file;
116 }
117
118 static File *file_new_internal(Vis *vis, const char *filename) {
119 File *file = file_new(vis, filename);
120 if (file) {
121 file->refcount = 1;
122 file->internal = true;
123 }
124 return file;
125 }
126
127 void vis_window_name(Win *win, const char *filename) {
128 File *file = win->file;
129 if (filename != file->name) {
130 free((char*)file->name);
131 file->name = filename ? strdup(filename) : NULL;
132 }
133 }
134
135 static void windows_invalidate(Vis *vis, size_t start, size_t end) {
136 for (Win *win = vis->windows; win; win = win->next) {
137 if (vis->win != win && vis->win->file == win->file) {
138 Filerange view = view_viewport_get(win->view);
139 if ((view.start <= start && start <= view.end) ||
140 (view.start <= end && end <= view.end))
141 view_draw(win->view);
142 }
143 }
144 view_draw(vis->win->view);
145 }
146
147 void window_selection_save(Win *win) {
148 File *file = win->file;
149 Filerange sel = view_cursors_selection_get(view_cursors(win->view));
150 file->marks[VIS_MARK_SELECTION_START] = text_mark_set(file->text, sel.start);
151 file->marks[VIS_MARK_SELECTION_END] = text_mark_set(file->text, sel.end);
152 }
153
154 static void window_free(Win *win) {
155 if (!win)
156 return;
157 Vis *vis = win->vis;
158 for (Win *other = vis->windows; other; other = other->next) {
159 if (other->parent == win)
160 other->parent = NULL;
161 }
162 if (vis->ui)
163 vis->ui->window_free(win->ui);
164 view_free(win->view);
165 for (size_t i = 0; i < LENGTH(win->modes); i++)
166 map_free(win->modes[i].bindings);
167 ringbuf_free(win->jumplist);
168 free(win);
169 }
170
171 Win *window_new_file(Vis *vis, File *file) {
172 Win *win = calloc(1, sizeof(Win));
173 if (!win)
174 return NULL;
175 win->vis = vis;
176 win->file = file;
177 win->jumplist = ringbuf_alloc(31);
178 win->view = view_new(file->text, vis->lua);
179 win->ui = vis->ui->window_new(vis->ui, win->view, file, UI_OPTION_STATUSBAR);
180 if (!win->jumplist || !win->view || !win->ui) {
181 window_free(win);
182 return NULL;
183 }
184 file->refcount++;
185 view_tabwidth_set(win->view, vis->tabwidth);
186
187 if (text_size(file->text) > LARGE_FILE) {
188 enum UiOption opt = view_options_get(win->view);
189 opt |= UI_OPTION_LARGE_FILE;
190 opt &= ~UI_OPTION_LINE_NUMBERS_ABSOLUTE;
191 view_options_set(win->view, opt);
192 }
193
194 if (vis->windows)
195 vis->windows->prev = win;
196 win->next = vis->windows;
197 vis->windows = win;
198 vis->win = win;
199 vis->ui->window_focus(win->ui);
200 for (size_t i = 0; i < LENGTH(win->modes); i++)
201 win->modes[i].parent = &vis_modes[i];
202 if (vis->event && vis->event->win_open)
203 vis->event->win_open(vis, win);
204 return win;
205 }
206
207 bool vis_window_reload(Win *win) {
208 const char *name = win->file->name;
209 if (!name)
210 return false; /* can't reload unsaved file */
211 /* temporarily unset file name, otherwise file_new returns the same File */
212 win->file->name = NULL;
213 File *file = file_new(win->vis, name);
214 win->file->name = name;
215 if (!file)
216 return false;
217 file_free(win->vis, win->file);
218 file->refcount = 1;
219 win->file = file;
220 win->ui->reload(win->ui, file);
221 return true;
222 }
223
224 bool vis_window_split(Win *original) {
225 Win *win = window_new_file(original->vis, original->file);
226 if (!win)
227 return false;
228 for (size_t i = 0; i < LENGTH(win->modes); i++) {
229 if (original->modes[i].bindings)
230 win->modes[i].bindings = map_new();
231 if (win->modes[i].bindings)
232 map_copy(win->modes[i].bindings, original->modes[i].bindings);
233 }
234 win->file = original->file;
235 win->file->refcount++;
236 view_syntax_set(win->view, view_syntax_get(original->view));
237 view_options_set(win->view, view_options_get(original->view));
238 view_cursor_to(win->view, view_cursor_get(original->view));
239 vis_draw(win->vis);
240 return true;
241 }
242
243 void vis_window_next(Vis *vis) {
244 Win *sel = vis->win;
245 if (!sel)
246 return;
247 vis->win = vis->win->next;
248 if (!vis->win)
249 vis->win = vis->windows;
250 vis->ui->window_focus(vis->win->ui);
251 }
252
253 void vis_window_prev(Vis *vis) {
254 Win *sel = vis->win;
255 if (!sel)
256 return;
257 vis->win = vis->win->prev;
258 if (!vis->win)
259 for (vis->win = vis->windows; vis->win->next; vis->win = vis->win->next);
260 vis->ui->window_focus(vis->win->ui);
261 }
262
263 void vis_draw(Vis *vis) {
264 vis->ui->draw(vis->ui);
265 }
266
267 void vis_redraw(Vis *vis) {
268 vis->ui->redraw(vis->ui);
269 }
270
271 void vis_update(Vis *vis) {
272 for (Win *win = vis->windows; win; win = win->next)
273 view_update(win->view);
274 view_update(vis->win->view);
275 vis->ui->update(vis->ui);
276 }
277
278 void vis_suspend(Vis *vis) {
279 vis->ui->suspend(vis->ui);
280 }
281
282 bool vis_window_new(Vis *vis, const char *filename) {
283 File *file = file_new(vis, filename);
284 if (!file)
285 return false;
286 Win *win = window_new_file(vis, file);
287 if (!win) {
288 file_free(vis, file);
289 return false;
290 }
291
292 vis_window_name(win, filename);
293 vis_draw(vis);
294
295 return true;
296 }
297
298 bool vis_window_closable(Win *win) {
299 if (!text_modified(win->file->text))
300 return true;
301 return win->file->refcount > 1;
302 }
303
304 void vis_window_close(Win *win) {
305 Vis *vis = win->vis;
306 if (vis->event && vis->event->win_close)
307 vis->event->win_close(vis, win);
308 file_free(vis, win->file);
309 if (win->prev)
310 win->prev->next = win->next;
311 if (win->next)
312 win->next->prev = win->prev;
313 if (vis->windows == win)
314 vis->windows = win->next;
315 if (vis->win == win)
316 vis->win = win->next ? win->next : win->prev;
317 if (win == vis->message_window)
318 vis->message_window = NULL;
319 window_free(win);
320 if (vis->win)
321 vis->ui->window_focus(vis->win->ui);
322 vis_draw(vis);
323 }
324
325 Vis *vis_new(Ui *ui, VisEvent *event) {
326 if (!ui)
327 return NULL;
328 Vis *vis = calloc(1, sizeof(Vis));
329 if (!vis)
330 return NULL;
331 vis->ui = ui;
332 vis->ui->init(vis->ui, vis);
333 vis->tabwidth = 8;
334 vis->expandtab = false;
335 vis->registers[VIS_REG_BLACKHOLE].type = REGISTER_BLACKHOLE;
336 vis->registers[VIS_REG_CLIPBOARD].type = REGISTER_CLIPBOARD;
337 action_reset(&vis->action);
338 if (!(vis->search_pattern = text_regex_new()))
339 goto err;
340 if (!(vis->command_file = file_new_internal(vis, NULL)))
341 goto err;
342 if (!(vis->search_file = file_new_internal(vis, NULL)))
343 goto err;
344 vis->mode_prev = vis->mode = &vis_modes[VIS_MODE_NORMAL];
345 vis->event = event;
346 if (event && event->vis_start)
347 event->vis_start(vis);
348 vis->ui->start(vis->ui);
349 return vis;
350 err:
351 vis_free(vis);
352 return NULL;
353 }
354
355 void vis_free(Vis *vis) {
356 if (!vis)
357 return;
358 if (vis->event && vis->event->vis_quit)
359 vis->event->vis_quit(vis);
360 vis->event = NULL;
361 while (vis->windows)
362 vis_window_close(vis->windows);
363 file_free(vis, vis->command_file);
364 file_free(vis, vis->search_file);
365 text_regex_free(vis->search_pattern);
366 for (int i = 0; i < LENGTH(vis->registers); i++)
367 register_release(&vis->registers[i]);
368 for (int i = 0; i < LENGTH(vis->macros); i++)
369 macro_release(&vis->macros[i]);
370 vis->ui->free(vis->ui);
371 map_free(vis->cmds);
372 map_free(vis->options);
373 map_free(vis->actions);
374 buffer_release(&vis->input_queue);
375 for (int i = 0; i < VIS_MODE_INVALID; i++)
376 map_free(vis_modes[i].bindings);
377 free(vis);
378 }
379
380 void vis_insert(Vis *vis, size_t pos, const char *data, size_t len) {
381 text_insert(vis->win->file->text, pos, data, len);
382 windows_invalidate(vis, pos, pos + len);
383 }
384
385 void vis_insert_key(Vis *vis, const char *data, size_t len) {
386 for (Cursor *c = view_cursors(vis->win->view); c; c = view_cursors_next(c)) {
387 size_t pos = view_cursors_pos(c);
388 vis_insert(vis, pos, data, len);
389 view_cursors_scroll_to(c, pos + len);
390 }
391 }
392
393 void vis_replace(Vis *vis, size_t pos, const char *data, size_t len) {
394 Text *txt = vis->win->file->text;
395 Iterator it = text_iterator_get(txt, pos);
396 int chars = text_char_count(data, len);
397 for (char c; chars-- > 0 && text_iterator_byte_get(&it, &c) && c != '\r' && c != '\n'; )
398 text_iterator_char_next(&it, NULL);
399
400 text_delete(txt, pos, it.pos - pos);
401 vis_insert(vis, pos, data, len);
402 }
403
404 void vis_replace_key(Vis *vis, const char *data, size_t len) {
405 for (Cursor *c = view_cursors(vis->win->view); c; c = view_cursors_next(c)) {
406 size_t pos = view_cursors_pos(c);
407 vis_replace(vis, pos, data, len);
408 view_cursors_scroll_to(c, pos + len);
409 }
410 }
411
412 void vis_delete(Vis *vis, size_t pos, size_t len) {
413 text_delete(vis->win->file->text, pos, len);
414 windows_invalidate(vis, pos, pos + len);
415 }
416
417 bool vis_action_register(Vis *vis, const KeyAction *action) {
418 if (!vis->actions)
419 vis->actions = map_new();
420 if (!vis->actions)
421 return false;
422 return map_put(vis->actions, action->name, action);
423 }
424
425 static void window_jumplist_add(Win *win, size_t pos) {
426 Mark mark = text_mark_set(win->file->text, pos);
427 if (mark && win->jumplist)
428 ringbuf_add(win->jumplist, mark);
429 }
430
431 static void window_jumplist_invalidate(Win *win) {
432 if (win->jumplist)
433 ringbuf_invalidate(win->jumplist);
434 }
435
436 void action_do(Vis *vis, Action *a) {
437 Win *win = vis->win;
438 Text *txt = win->file->text;
439 View *view = win->view;
440
441 if (a->op == &vis_operators[VIS_OP_FILTER] && !vis->mode->visual)
442 vis_mode_switch(vis, VIS_MODE_VISUAL_LINE);
443
444 int count = MAX(a->count, 1);
445 bool repeatable = a->op && !vis->macro_operator;
446 bool multiple_cursors = view_cursors_count(view) > 1;
447 bool linewise = !(a->type & CHARWISE) && (
448 a->type & LINEWISE || (a->movement && a->movement->type & LINEWISE) ||
449 vis->mode == &vis_modes[VIS_MODE_VISUAL_LINE]);
450
451 for (Cursor *cursor = view_cursors(view), *next; cursor; cursor = next) {
452
453 next = view_cursors_next(cursor);
454 size_t pos = view_cursors_pos(cursor);
455 Register *reg = multiple_cursors ? view_cursors_register(cursor) : a->reg;
456 if (!reg)
457 reg = &vis->registers[win->file->internal ? VIS_REG_PROMPT : VIS_REG_DEFAULT];
458
459 OperatorContext c = {
460 .count = count,
461 .pos = pos,
462 .newpos = EPOS,
463 .range = text_range_empty(),
464 .reg = reg,
465 .linewise = linewise,
466 .arg = &a->arg,
467 };
468
469 if (a->movement) {
470 size_t start = pos;
471 for (int i = 0; i < count; i++) {
472 if (a->movement->txt)
473 pos = a->movement->txt(txt, pos);
474 else if (a->movement->cur)
475 pos = a->movement->cur(cursor);
476 else if (a->movement->file)
477 pos = a->movement->file(vis, vis->win->file, pos);
478 else if (a->movement->vis)
479 pos = a->movement->vis(vis, txt, pos);
480 else if (a->movement->view)
481 pos = a->movement->view(vis, view);
482 else if (a->movement->win)
483 pos = a->movement->win(vis, win, pos);
484 if (pos == EPOS || a->movement->type & IDEMPOTENT)
485 break;
486 }
487
488 if (pos == EPOS) {
489 c.range.start = start;
490 c.range.end = start;
491 pos = start;
492 } else {
493 c.range = text_range_new(start, pos);
494 c.newpos = pos;
495 }
496
497 if (!a->op) {
498 if (a->movement->type & CHARWISE)
499 view_cursors_scroll_to(cursor, pos);
500 else
501 view_cursors_to(cursor, pos);
502 if (vis->mode->visual)
503 c.range = view_cursors_selection_get(cursor);
504 if (a->movement->type & JUMP)
505 window_jumplist_add(win, pos);
506 else
507 window_jumplist_invalidate(win);
508 } else if (a->movement->type & INCLUSIVE) {
509 c.range.end = text_char_next(txt, c.range.end);
510 }
511 } else if (a->textobj) {
512 if (vis->mode->visual)
513 c.range = view_cursors_selection_get(cursor);
514 else
515 c.range.start = c.range.end = pos;
516 for (int i = 0; i < count; i++) {
517 Filerange r;
518 if (a->textobj->txt)
519 r = a->textobj->txt(txt, pos);
520 else
521 r = a->textobj->vis(vis, txt, pos);
522 if (!text_range_valid(&r))
523 break;
524 if (a->textobj->type & OUTER) {
525 r.start--;
526 r.end++;
527 }
528
529 if (a->textobj->type & SPLIT)
530 c.range = r;
531 else
532 c.range = text_range_union(&c.range, &r);
533
534 if (i < count - 1)
535 pos = c.range.end + 1;
536 }
537 } else if (vis->mode->visual) {
538 c.range = view_cursors_selection_get(cursor);
539 if (!text_range_valid(&c.range))
540 c.range.start = c.range.end = pos;
541 }
542
543 if (linewise && vis->mode != &vis_modes[VIS_MODE_VISUAL])
544 c.range = text_range_linewise(txt, &c.range);
545 if (vis->mode->visual) {
546 view_cursors_selection_set(cursor, &c.range);
547 if (vis->mode == &vis_modes[VIS_MODE_VISUAL] || a->textobj)
548 view_cursors_selection_sync(cursor);
549 }
550
551 if (a->op) {
552 size_t pos = a->op->func(vis, txt, &c);
553 if (pos == EPOS) {
554 view_cursors_dispose(cursor);
555 } else if (pos <= text_size(txt)) {
556 /* moving the cursor will affect the selection.
557 * because we want to be able to later restore
558 * the old selection we update it again before
559 * leaving visual mode.
560 */
561 Filerange sel = view_cursors_selection_get(cursor);
562 view_cursors_to(cursor, pos);
563 if (vis->mode->visual) {
564 if (sel.start == EPOS && sel.end == EPOS)
565 sel = c.range;
566 else if (sel.start == EPOS)
567 sel = text_range_new(c.range.start, sel.end);
568 else if (sel.end == EPOS)
569 sel = text_range_new(c.range.start, sel.start);
570 if (vis->mode == &vis_modes[VIS_MODE_VISUAL_LINE])
571 sel = text_range_linewise(txt, &sel);
572 view_cursors_selection_set(cursor, &sel);
573 }
574 }
575 }
576 }
577
578 if (a->op) {
579 /* we do not support visual repeat, still do something resonable */
580 if (vis->mode->visual && !a->movement && !a->textobj)
581 a->movement = &vis_motions[VIS_MOVE_NOP];
582
583 /* operator implementations must not change the mode,
584 * they might get called multiple times (once for every cursor)
585 */
586 if (a->op == &vis_operators[VIS_OP_INSERT] || a->op == &vis_operators[VIS_OP_CHANGE]) {
587 vis_mode_switch(vis, VIS_MODE_INSERT);
588 } else if (a->op == &vis_operators[VIS_OP_REPLACE]) {
589 vis_mode_switch(vis, VIS_MODE_REPLACE);
590 } else if (a->op == &vis_operators[VIS_OP_FILTER]) {
591 if (a->arg.s) {
592 vis_mode_switch(vis, VIS_MODE_NORMAL);
593 vis_cmd(vis, a->arg.s);
594 } else {
595 vis_prompt_show(vis, ":'<,'>!");
596 }
597 } else if (vis->mode == &vis_modes[VIS_MODE_OPERATOR_PENDING]) {
598 mode_set(vis, vis->mode_prev);
599 } else if (vis->mode->visual) {
600 vis_mode_switch(vis, VIS_MODE_NORMAL);
601 }
602 text_snapshot(txt);
603 vis_draw(vis);
604 }
605
606 if (a != &vis->action_prev) {
607 if (repeatable) {
608 if (!a->macro)
609 a->macro = vis->macro_operator;
610 vis->action_prev = *a;
611 }
612 action_reset(a);
613 }
614 }
615
616 void action_reset(Action *a) {
617 memset(a, 0, sizeof(*a));
618 a->count = VIS_COUNT_UNKNOWN;
619 }
620
621 void vis_cancel(Vis *vis) {
622 action_reset(&vis->action);
623 }
624
625 void vis_die(Vis *vis, const char *msg, ...) {
626 va_list ap;
627 va_start(ap, msg);
628 vis->ui->die(vis->ui, msg, ap);
629 va_end(ap);
630 }
631
632 const char *vis_keys_next(Vis *vis, const char *keys) {
633 TermKeyKey key;
634 TermKey *termkey = vis->ui->termkey_get(vis->ui);
635 const char *next = NULL;
636 if (!keys)
637 return NULL;
638 /* first try to parse a special key of the form <Key> */
639 if (*keys == '<' && (next = termkey_strpkey(termkey, keys+1, &key, TERMKEY_FORMAT_VIM)) && *next == '>')
640 return next+1;
641 if (*keys == '<') {
642 const char *start = keys + 1, *end = start;
643 while (*end && *end != '>')
644 end++;
645 if (end > start && end - start - 1 < 64 && *end == '>') {
646 char key[64];
647 memcpy(key, start, end - start);
648 key[end - start] = '\0';
649 if (map_get(vis->actions, key))
650 return end + 1;
651 }
652 }
653 while (!ISUTF8(*keys))
654 keys++;
655 return termkey_strpkey(termkey, keys, &key, TERMKEY_FORMAT_VIM);
656 }
657
658 static const char *vis_keys_raw(Vis *vis, Buffer *buf, const char *input) {
659 char *keys = buf->data, *start = keys, *cur = keys, *end;
660 bool prefix = false;
661 KeyBinding *binding = NULL;
662
663 while (cur && *cur) {
664
665 if (!(end = (char*)vis_keys_next(vis, cur)))
666 goto err; // XXX: can't parse key this should never happen
667
668 char tmp = *end;
669 *end = '\0';
670 prefix = false;
671 binding = NULL;
672
673 for (Mode *mode = vis->mode; mode && !binding && !prefix; mode = mode->parent) {
674 for (int global = 0; global < 2 && !binding && !prefix; global++) {
675 Mode *mode_local = global ? mode : &vis->win->modes[mode->id];
676 if (!mode_local->bindings)
677 continue;
678 binding = map_get(mode_local->bindings, start);
679 /* "<" is never treated as a prefix because it is used to denote
680 * special key symbols */
681 if (strcmp(cur, "<"))
682 prefix = !binding && map_contains(mode_local->bindings, start);
683 }
684 }
685
686 *end = tmp;
687 vis->keys = buf;
688
689 if (binding) { /* exact match */
690 if (binding->action) {
691 end = (char*)binding->action->func(vis, end, &binding->action->arg);
692 if (!end)
693 break;
694 start = cur = end;
695 } else if (binding->alias) {
696 buffer_put0(buf, end);
697 buffer_prepend0(buf, binding->alias);
698 start = cur = buf->data;
699 }
700 } else if (prefix) { /* incomplete key binding? */
701 cur = end;
702 } else { /* no keybinding */
703 KeyAction *action = NULL;
704 if (start[0] == '<' && end[-1] == '>') {
705 /* test for special editor key command */
706 char tmp = end[-1];
707 end[-1] = '\0';
708 action = map_get(vis->actions, start+1);
709 end[-1] = tmp;
710 if (action) {
711 end = (char*)action->func(vis, end, &action->arg);
712 if (!end)
713 break;
714 }
715 }
716 if (!action && vis->mode->input)
717 vis->mode->input(vis, start, end - start);
718 start = cur = end;
719 }
720 }
721
722 vis->keys = NULL;
723 buffer_put0(buf, start);
724 return input + (start - keys);
725 err:
726 vis->keys = NULL;
727 buffer_truncate(buf);
728 return input + strlen(input);
729 }
730
731 bool vis_keys_inject(Vis *vis, const char *pos, const char *input) {
732 Buffer *buf = vis->keys;
733 if (!buf)
734 return false;
735 if (pos < buf->data || pos > buf->data + buf->len)
736 return false;
737 size_t off = pos - buf->data;
738 buffer_insert0(buf, off, input);
739 if (vis->macro_operator)
740 macro_append(vis->macro_operator, input);
741 return true;
742 }
743
744 const char *vis_keys_push(Vis *vis, const char *input) {
745 if (!input)
746 return NULL;
747
748 if (vis->recording)
749 macro_append(vis->recording, input);
750 if (vis->macro_operator)
751 macro_append(vis->macro_operator, input);
752
753 if (!buffer_append0(&vis->input_queue, input)) {
754 buffer_truncate(&vis->input_queue);
755 return NULL;
756 }
757
758 return vis_keys_raw(vis, &vis->input_queue, input);
759 }
760
761 static const char *getkey(Vis *vis) {
762 const char *key = vis->ui->getkey(vis->ui);
763 if (!key)
764 return NULL;
765 vis_info_hide(vis);
766 return key;
767 }
768
769 bool vis_signal_handler(Vis *vis, int signum, const siginfo_t *siginfo, const void *context) {
770 switch (signum) {
771 case SIGBUS:
772 for (File *file = vis->files; file; file = file->next) {
773 if (text_sigbus(file->text, siginfo->si_addr))
774 file->truncated = true;
775 }
776 vis->sigbus = true;
777 if (vis->running)
778 siglongjmp(vis->sigbus_jmpbuf, 1);
779 return true;
780 case SIGINT:
781 vis->cancel_filter = true;
782 return true;
783 }
784 return false;
785 }
786
787 static void vis_args(Vis *vis, int argc, char *argv[]) {
788 char *cmd = NULL;
789 bool end_of_options = false;
790 for (int i = 1; i < argc; i++) {
791 if (argv[i][0] == '-' && !end_of_options) {
792 switch (argv[i][1]) {
793 case '-':
794 end_of_options = true;
795 break;
796 case 'v':
797 vis_die(vis, "vis %s, compiled " __DATE__ " " __TIME__ "\n", VERSION);
798 break;
799 case '\0':
800 break;
801 default:
802 vis_die(vis, "Unknown command option: %s\n", argv[i]);
803 break;
804 }
805 } else if (argv[i][0] == '+') {
806 cmd = argv[i] + (argv[i][1] == '/' || argv[i][1] == '?');
807 } else if (!vis_window_new(vis, argv[i])) {
808 vis_die(vis, "Can not load `%s': %s\n", argv[i], strerror(errno));
809 } else if (cmd) {
810 vis_prompt_cmd(vis, cmd);
811 cmd = NULL;
812 }
813 }
814
815 if (!vis->windows) {
816 if (!strcmp(argv[argc-1], "-")) {
817 if (!vis_window_new(vis, NULL))
818 vis_die(vis, "Can not create empty buffer\n");
819 ssize_t len = 0;
820 char buf[PIPE_BUF];
821 File *file = vis->win->file;
822 Text *txt = file->text;
823 file->is_stdin = true;
824 while ((len = read(STDIN_FILENO, buf, sizeof buf)) > 0)
825 text_insert(txt, text_size(txt), buf, len);
826 if (len == -1)
827 vis_die(vis, "Can not read from stdin\n");
828 text_snapshot(txt);
829 int fd = open("/dev/tty", O_RDONLY);
830 if (fd == -1)
831 vis_die(vis, "Can not reopen stdin\n");
832 dup2(fd, STDIN_FILENO);
833 close(fd);
834 } else if (!vis_window_new(vis, NULL)) {
835 vis_die(vis, "Can not create empty buffer\n");
836 }
837 if (cmd)
838 vis_prompt_cmd(vis, cmd);
839 }
840 }
841
842 int vis_run(Vis *vis, int argc, char *argv[]) {
843 vis_args(vis, argc, argv);
844
845 struct timespec idle = { .tv_nsec = 0 }, *timeout = NULL;
846
847 sigset_t emptyset;
848 sigemptyset(&emptyset);
849 vis_draw(vis);
850 vis->running = true;
851 vis->exit_status = EXIT_SUCCESS;
852
853 sigsetjmp(vis->sigbus_jmpbuf, 1);
854
855 while (vis->running) {
856 fd_set fds;
857 FD_ZERO(&fds);
858 FD_SET(STDIN_FILENO, &fds);
859
860 if (vis->sigbus) {
861 char *name = NULL;
862 for (Win *next, *win = vis->windows; win; win = next) {
863 next = win->next;
864 if (win->file->truncated) {
865 free(name);
866 name = strdup(win->file->name);
867 vis_window_close(win);
868 }
869 }
870 if (!vis->windows)
871 vis_die(vis, "WARNING: file `%s' truncated!\n", name ? name : "-");
872 else
873 vis_info_show(vis, "WARNING: file `%s' truncated!\n", name ? name : "-");
874 vis->sigbus = false;
875 free(name);
876 }
877
878 vis_update(vis);
879 idle.tv_sec = vis->mode->idle_timeout;
880 int r = pselect(1, &fds, NULL, NULL, timeout, &emptyset);
881 if (r == -1 && errno == EINTR)
882 continue;
883
884 if (r < 0) {
885 /* TODO save all pending changes to a ~suffixed file */
886 vis_die(vis, "Error in mainloop: %s\n", strerror(errno));
887 }
888
889 if (!FD_ISSET(STDIN_FILENO, &fds)) {
890 if (vis->mode->idle)
891 vis->mode->idle(vis);
892 timeout = NULL;
893 continue;
894 }
895
896 TermKey *termkey = vis->ui->termkey_get(vis->ui);
897 termkey_advisereadable(termkey);
898 const char *key;
899
900 while ((key = getkey(vis)))
901 vis_keys_push(vis, key);
902
903 if (vis->mode->idle)
904 timeout = &idle;
905 }
906 return vis->exit_status;
907 }
908
909 static Macro *macro_get(Vis *vis, enum VisMacro m) {
910 if (m == VIS_MACRO_LAST_RECORDED)
911 return vis->last_recording;
912 if (m < LENGTH(vis->macros))
913 return &vis->macros[m];
914 return NULL;
915 }
916
917 void macro_operator_record(Vis *vis) {
918 vis->macro_operator = macro_get(vis, VIS_MACRO_OPERATOR);
919 macro_reset(vis->macro_operator);
920 }
921
922 void macro_operator_stop(Vis *vis) {
923 vis->macro_operator = NULL;
924 }
925
926 bool vis_macro_record(Vis *vis, enum VisMacro id) {
927 Macro *macro = macro_get(vis, id);
928 if (vis->recording || !macro)
929 return false;
930 macro_reset(macro);
931 vis->recording = macro;
932 return true;
933 }
934
935 bool vis_macro_record_stop(Vis *vis) {
936 if (!vis->recording)
937 return false;
938 /* XXX: hack to remove last recorded key, otherwise upon replay
939 * we would start another recording */
940 if (vis->recording->len > 1) {
941 vis->recording->len--;
942 vis->recording->data[vis->recording->len-1] = '\0';
943 }
944 vis->last_recording = vis->recording;
945 vis->recording = NULL;
946 return true;
947 }
948
949 bool vis_macro_recording(Vis *vis) {
950 return vis->recording;
951 }
952
953 static void macro_replay(Vis *vis, const Macro *macro) {
954 Buffer buf;
955 buffer_init(&buf);
956 buffer_put(&buf, macro->data, macro->len);
957 vis_keys_raw(vis, &buf, macro->data);
958 buffer_release(&buf);
959 }
960
961 bool vis_macro_replay(Vis *vis, enum VisMacro id) {
962 Macro *macro = macro_get(vis, id);
963 if (!macro || macro == vis->recording)
964 return false;
965 macro_replay(vis, macro);
966 return true;
967 }
968
969 void vis_repeat(Vis *vis) {
970 int count = vis->action.count;
971 Macro *macro_operator = macro_get(vis, VIS_MACRO_OPERATOR);
972 Macro *macro_repeat = macro_get(vis, VIS_MACRO_REPEAT);
973 const Macro *macro = vis->action_prev.macro;
974 if (macro == macro_operator) {
975 buffer_put(macro_repeat, macro_operator->data, macro_operator->len);
976 macro = macro_repeat;
977 vis->action_prev.macro = macro;
978 }
979 if (count != VIS_COUNT_UNKNOWN)
980 vis->action_prev.count = count;
981 count = vis->action_prev.count;
982 /* for some operators count should be applied only to the macro not the motion */
983 if (vis->action_prev.op == &vis_operators[VIS_OP_INSERT] || vis->action_prev.op == &vis_operators[VIS_OP_REPLACE])
984 vis->action_prev.count = 1;
985 action_do(vis, &vis->action_prev);
986 vis->action_prev.count = count;
987 if (macro) {
988 Mode *mode = vis->mode;
989 Action action_prev = vis->action_prev;
990 count = action_prev.count;
991 if (count < 1 || action_prev.op == &vis_operators[VIS_OP_CHANGE] || action_prev.op == &vis_operators[VIS_OP_FILTER])
992 count = 1;
993 for (int i = 0; i < count; i++) {
994 mode_set(vis, mode);
995 macro_replay(vis, macro);
996 }
997 vis->action_prev = action_prev;
998 }
999 vis_cancel(vis);
1000 }
1001
1002 void vis_mark_set(Vis *vis, enum VisMark mark, size_t pos) {
1003 File *file = vis->win->file;
1004 if (mark < LENGTH(file->marks))
1005 file->marks[mark] = text_mark_set(file->text, pos);
1006 }
1007
1008 int vis_count_get(Vis *vis) {
1009 return vis->action.count;
1010 }
1011
1012 int vis_count_get_default(Vis *vis, int def) {
1013 if (vis->action.count == VIS_COUNT_UNKNOWN)
1014 return def;
1015 return vis->action.count;
1016 }
1017
1018 void vis_count_set(Vis *vis, int count) {
1019 vis->action.count = (count >= 0 ? count : VIS_COUNT_UNKNOWN);
1020 }
1021
1022 void vis_register_set(Vis *vis, enum VisRegister reg) {
1023 if (reg >= VIS_REG_A && reg <= VIS_REG_Z) {
1024 vis->action.reg = &vis->registers[reg - VIS_REG_A];
1025 vis->action.reg->append = true;
1026 } else if (reg < LENGTH(vis->registers)) {
1027 vis->action.reg = &vis->registers[reg];
1028 vis->action.reg->append = false;
1029 }
1030 }
1031
1032 const char *vis_register_get(Vis *vis, enum VisRegister reg, size_t *len) {
1033 if (reg >= VIS_REG_A && reg <= VIS_REG_Z)
1034 reg -= VIS_REG_A;
1035 if (reg < LENGTH(vis->registers))
1036 return register_get(vis, &vis->registers[reg], len);
1037 *len = 0;
1038 return NULL;
1039 }
1040
1041 void vis_exit(Vis *vis, int status) {
1042 vis->running = false;
1043 vis->exit_status = status;
1044 }
1045
1046 const char *vis_mode_status(Vis *vis) {
1047 return vis->mode->status;
1048 }
1049
1050 void vis_insert_tab(Vis *vis) {
1051 if (!vis->expandtab) {
1052 vis_insert_key(vis, "\t", 1);
1053 return;
1054 }
1055 char spaces[9];
1056 int tabwidth = MIN(vis->tabwidth, LENGTH(spaces) - 1);
1057 for (Cursor *c = view_cursors(vis->win->view); c; c = view_cursors_next(c)) {
1058 size_t pos = view_cursors_pos(c);
1059 /* FIXME: this does not take double width characters into account */
1060 int chars = text_line_char_get(vis->win->file->text, pos);
1061 int count = tabwidth - (chars % tabwidth);
1062 for (int i = 0; i < count; i++)
1063 spaces[i] = ' ';
1064 spaces[count] = '\0';
1065 vis_insert(vis, pos, spaces, count);
1066 view_cursors_scroll_to(c, pos + count);
1067 }
1068 }
1069
1070 static void copy_indent_from_previous_line(Win *win) {
1071 View *view = win->view;
1072 Text *text = win->file->text;
1073 size_t pos = view_cursor_get(view);
1074 size_t prev_line = text_line_prev(text, pos);
1075 if (pos == prev_line)
1076 return;
1077 size_t begin = text_line_begin(text, prev_line);
1078 size_t start = text_line_start(text, begin);
1079 size_t len = start-begin;
1080 char *buf = malloc(len);
1081 if (!buf)
1082 return;
1083 len = text_bytes_get(text, begin, len, buf);
1084 vis_insert_key(win->vis, buf, len);
1085 free(buf);
1086 }
1087
1088 void vis_insert_nl(Vis *vis) {
1089 const char *nl;
1090 switch (text_newline_type(vis->win->file->text)) {
1091 case TEXT_NEWLINE_CRNL:
1092 nl = "\r\n";
1093 break;
1094 default:
1095 nl = "\n";
1096 break;
1097 }
1098
1099 vis_insert_key(vis, nl, strlen(nl));
1100
1101 if (vis->autoindent)
1102 copy_indent_from_previous_line(vis->win);
1103 }
1104
1105 Text *vis_text(Vis *vis) {
1106 return vis->win->file->text;
1107 }
1108
1109 View *vis_view(Vis *vis) {
1110 return vis->win->view;
1111 }
1112
1113 Win *vis_window(Vis *vis) {
1114 return vis->win;
1115 }
1116
1117 Text *vis_file_text(File *file) {
1118 return file->text;
1119 }
1120
1121 const char *vis_file_name(File *file) {
1122 return file->name;
1123 }
1124
a vim like text editor