1: /* vi_mode.c -- A vi emulation mode for Bash.
2: Derived from code written by Jeff Sparkes (jsparkes@bnr.ca). */
3:
4: /* Copyright (C) 1987-2012 Free Software Foundation, Inc.
5:
6: This file is part of the GNU Readline Library (Readline), a library
7: for reading lines of text with interactive input and history editing.
8:
9: Readline is free software: you can redistribute it and/or modify
10: it under the terms of the GNU General Public License as published by
11: the Free Software Foundation, either version 3 of the License, or
12: (at your option) any later version.
13:
14: Readline is distributed in the hope that it will be useful,
15: but WITHOUT ANY WARRANTY; without even the implied warranty of
16: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17: GNU General Public License for more details.
18:
19: You should have received a copy of the GNU General Public License
20: along with Readline. If not, see <http://www.gnu.org/licenses/>.
21: */
22:
23: #define READLINE_LIBRARY
24:
25: /* **************************************************************** */
26: /* */
27: /* VI Emulation Mode */
28: /* */
29: /* **************************************************************** */
30: #include "rlconf.h"
31:
32: #if defined (VI_MODE)
33:
34: #if defined (HAVE_CONFIG_H)
35: # include <config.h>
36: #endif
37:
38: #include <sys/types.h>
39:
40: #if defined (HAVE_STDLIB_H)
41: # include <stdlib.h>
42: #else
43: # include "ansi_stdlib.h"
44: #endif /* HAVE_STDLIB_H */
45:
46: #if defined (HAVE_UNISTD_H)
47: # include <unistd.h>
48: #endif
49:
50: #include <stdio.h>
51:
52: /* Some standard library routines. */
53: #include "rldefs.h"
54: #include "rlmbutil.h"
55:
56: #include "readline.h"
57: #include "history.h"
58:
59: #include "rlprivate.h"
60: #include "xmalloc.h"
61:
62: #ifndef member
63: #define member(c, s) ((c) ? (char *)strchr ((s), (c)) != (char *)NULL : 0)
64: #endif
65:
66: int _rl_vi_last_command = 'i'; /* default `.' puts you in insert mode */
67:
68: _rl_vimotion_cxt *_rl_vimvcxt = 0;
69:
70: /* Non-zero means enter insertion mode. */
71: static int _rl_vi_doing_insert;
72:
73: /* Command keys which do movement for xxx_to commands. */
74: static const char * const vi_motion = " hl^$0ftFT;,%wbeWBE|`";
75:
76: /* Keymap used for vi replace characters. Created dynamically since
77: rarely used. */
78: static Keymap vi_replace_map;
79:
80: /* The number of characters inserted in the last replace operation. */
81: static int vi_replace_count;
82:
83: /* If non-zero, we have text inserted after a c[motion] command that put
84: us implicitly into insert mode. Some people want this text to be
85: attached to the command so that it is `redoable' with `.'. */
86: static int vi_continued_command;
87: static char *vi_insert_buffer;
88: static int vi_insert_buffer_size;
89:
90: static int _rl_vi_last_repeat = 1;
91: static int _rl_vi_last_arg_sign = 1;
92: static int _rl_vi_last_motion;
93: #if defined (HANDLE_MULTIBYTE)
94: static char _rl_vi_last_search_mbchar[MB_LEN_MAX];
95: static int _rl_vi_last_search_mblen;
96: #else
97: static int _rl_vi_last_search_char;
98: #endif
99: static int _rl_vi_last_replacement;
100:
101: static int _rl_vi_last_key_before_insert;
102:
103: static int vi_redoing;
104:
105: /* Text modification commands. These are the `redoable' commands. */
106: static const char * const vi_textmod = "_*\\AaIiCcDdPpYyRrSsXx~";
107:
108: /* Arrays for the saved marks. */
109: static int vi_mark_chars['z' - 'a' + 1];
110:
111: static void _rl_vi_replace_insert PARAMS((int));
112: static void _rl_vi_save_replace PARAMS((void));
113: static void _rl_vi_stuff_insert PARAMS((int));
114: static void _rl_vi_save_insert PARAMS((UNDO_LIST *));
115:
116: static void vi_save_insert_buffer PARAMS ((int, int));
117:
118: static void _rl_vi_backup PARAMS((void));
119:
120: static int _rl_vi_arg_dispatch PARAMS((int));
121: static int rl_digit_loop1 PARAMS((void));
122:
123: static int _rl_vi_set_mark PARAMS((void));
124: static int _rl_vi_goto_mark PARAMS((void));
125:
126: static void _rl_vi_append_forward PARAMS((int));
127:
128: static int _rl_vi_callback_getchar PARAMS((char *, int));
129:
130: #if defined (READLINE_CALLBACKS)
131: static int _rl_vi_callback_set_mark PARAMS((_rl_callback_generic_arg *));
132: static int _rl_vi_callback_goto_mark PARAMS((_rl_callback_generic_arg *));
133: static int _rl_vi_callback_change_char PARAMS((_rl_callback_generic_arg *));
134: static int _rl_vi_callback_char_search PARAMS((_rl_callback_generic_arg *));
135: #endif
136:
137: static int rl_domove_read_callback PARAMS((_rl_vimotion_cxt *));
138: static int rl_domove_motion_callback PARAMS((_rl_vimotion_cxt *));
139: static int rl_vi_domove_getchar PARAMS((_rl_vimotion_cxt *));
140:
141: static int vi_change_dispatch PARAMS((_rl_vimotion_cxt *));
142: static int vi_delete_dispatch PARAMS((_rl_vimotion_cxt *));
143: static int vi_yank_dispatch PARAMS((_rl_vimotion_cxt *));
144:
145: static int vidomove_dispatch PARAMS((_rl_vimotion_cxt *));
146:
147: void
148: _rl_vi_initialize_line ()
149: {
150: register int i, n;
151:
152: n = sizeof (vi_mark_chars) / sizeof (vi_mark_chars[0]);
153: for (i = 0; i < n; i++)
154: vi_mark_chars[i] = -1;
155:
156: RL_UNSETSTATE(RL_STATE_VICMDONCE);
157: }
158:
159: void
160: _rl_vi_reset_last ()
161: {
162: _rl_vi_last_command = 'i';
163: _rl_vi_last_repeat = 1;
164: _rl_vi_last_arg_sign = 1;
165: _rl_vi_last_motion = 0;
166: }
167:
168: void
169: _rl_vi_set_last (key, repeat, sign)
170: int key, repeat, sign;
171: {
172: _rl_vi_last_command = key;
173: _rl_vi_last_repeat = repeat;
174: _rl_vi_last_arg_sign = sign;
175: }
176:
177: /* A convenience function that calls _rl_vi_set_last to save the last command
178: information and enters insertion mode. */
179: void
180: rl_vi_start_inserting (key, repeat, sign)
181: int key, repeat, sign;
182: {
183: _rl_vi_set_last (key, repeat, sign);
184: rl_vi_insertion_mode (1, key);
185: }
186:
187: /* Is the command C a VI mode text modification command? */
188: int
189: _rl_vi_textmod_command (c)
190: int c;
191: {
192: return (member (c, vi_textmod));
193: }
194:
195: static void
196: _rl_vi_replace_insert (count)
197: int count;
198: {
199: int nchars;
200:
201: nchars = strlen (vi_insert_buffer);
202:
203: rl_begin_undo_group ();
204: while (count--)
205: /* nchars-1 to compensate for _rl_replace_text using `end+1' in call
206: to rl_delete_text */
207: _rl_replace_text (vi_insert_buffer, rl_point, rl_point+nchars-1);
208: rl_end_undo_group ();
209: }
210:
211: static void
212: _rl_vi_stuff_insert (count)
213: int count;
214: {
215: rl_begin_undo_group ();
216: while (count--)
217: rl_insert_text (vi_insert_buffer);
218: rl_end_undo_group ();
219: }
220:
221: /* Bound to `.'. Called from command mode, so we know that we have to
222: redo a text modification command. The default for _rl_vi_last_command
223: puts you back into insert mode. */
224: int
225: rl_vi_redo (count, c)
226: int count, c;
227: {
228: int r;
229:
230: if (rl_explicit_arg == 0)
231: {
232: rl_numeric_arg = _rl_vi_last_repeat;
233: rl_arg_sign = _rl_vi_last_arg_sign;
234: }
235:
236: r = 0;
237: vi_redoing = 1;
238: /* If we're redoing an insert with `i', stuff in the inserted text
239: and do not go into insertion mode. */
240: if (_rl_vi_last_command == 'i' && vi_insert_buffer && *vi_insert_buffer)
241: {
242: _rl_vi_stuff_insert (count);
243: /* And back up point over the last character inserted. */
244: if (rl_point > 0)
245: _rl_vi_backup ();
246: }
247: else if (_rl_vi_last_command == 'R' && vi_insert_buffer && *vi_insert_buffer)
248: {
249: _rl_vi_replace_insert (count);
250: /* And back up point over the last character inserted. */
251: if (rl_point > 0)
252: _rl_vi_backup ();
253: }
254: /* Ditto for redoing an insert with `I', but move to the beginning of the
255: line like the `I' command does. */
256: else if (_rl_vi_last_command == 'I' && vi_insert_buffer && *vi_insert_buffer)
257: {
258: rl_beg_of_line (1, 'I');
259: _rl_vi_stuff_insert (count);
260: if (rl_point > 0)
261: _rl_vi_backup ();
262: }
263: /* Ditto for redoing an insert with `a', but move forward a character first
264: like the `a' command does. */
265: else if (_rl_vi_last_command == 'a' && vi_insert_buffer && *vi_insert_buffer)
266: {
267: _rl_vi_append_forward ('a');
268: _rl_vi_stuff_insert (count);
269: if (rl_point > 0)
270: _rl_vi_backup ();
271: }
272: /* Ditto for redoing an insert with `A', but move to the end of the line
273: like the `A' command does. */
274: else if (_rl_vi_last_command == 'A' && vi_insert_buffer && *vi_insert_buffer)
275: {
276: rl_end_of_line (1, 'A');
277: _rl_vi_stuff_insert (count);
278: if (rl_point > 0)
279: _rl_vi_backup ();
280: }
281: else
282: r = _rl_dispatch (_rl_vi_last_command, _rl_keymap);
283: vi_redoing = 0;
284:
285: return (r);
286: }
287:
288: /* A placeholder for further expansion. */
289: int
290: rl_vi_undo (count, key)
291: int count, key;
292: {
293: return (rl_undo_command (count, key));
294: }
295:
296: /* Yank the nth arg from the previous line into this line at point. */
297: int
298: rl_vi_yank_arg (count, key)
299: int count, key;
300: {
301: /* Readline thinks that the first word on a line is the 0th, while vi
302: thinks the first word on a line is the 1st. Compensate. */
303: if (rl_explicit_arg)
304: rl_yank_nth_arg (count - 1, 0);
305: else
306: rl_yank_nth_arg ('$', 0);
307:
308: return (0);
309: }
310:
311: /* With an argument, move back that many history lines, else move to the
312: beginning of history. */
313: int
314: rl_vi_fetch_history (count, c)
315: int count, c;
316: {
317: int wanted;
318:
319: /* Giving an argument of n means we want the nth command in the history
320: file. The command number is interpreted the same way that the bash
321: `history' command does it -- that is, giving an argument count of 450
322: to this command would get the command listed as number 450 in the
323: output of `history'. */
324: if (rl_explicit_arg)
325: {
326: wanted = history_base + where_history () - count;
327: if (wanted <= 0)
328: rl_beginning_of_history (0, 0);
329: else
330: rl_get_previous_history (wanted, c);
331: }
332: else
333: rl_beginning_of_history (count, 0);
334: return (0);
335: }
336:
337: /* Search again for the last thing searched for. */
338: int
339: rl_vi_search_again (count, key)
340: int count, key;
341: {
342: switch (key)
343: {
344: case 'n':
345: rl_noninc_reverse_search_again (count, key);
346: break;
347:
348: case 'N':
349: rl_noninc_forward_search_again (count, key);
350: break;
351: }
352: return (0);
353: }
354:
355: /* Do a vi style search. */
356: int
357: rl_vi_search (count, key)
358: int count, key;
359: {
360: switch (key)
361: {
362: case '?':
363: _rl_free_saved_history_line ();
364: rl_noninc_forward_search (count, key);
365: break;
366:
367: case '/':
368: _rl_free_saved_history_line ();
369: rl_noninc_reverse_search (count, key);
370: break;
371:
372: default:
373: rl_ding ();
374: break;
375: }
376: return (0);
377: }
378:
379: /* Completion, from vi's point of view. */
380: int
381: rl_vi_complete (ignore, key)
382: int ignore, key;
383: {
384: if ((rl_point < rl_end) && (!whitespace (rl_line_buffer[rl_point])))
385: {
386: if (!whitespace (rl_line_buffer[rl_point + 1]))
387: rl_vi_end_word (1, 'E');
388: rl_point++;
389: }
390:
391: if (key == '*')
392: rl_complete_internal ('*'); /* Expansion and replacement. */
393: else if (key == '=')
394: rl_complete_internal ('?'); /* List possible completions. */
395: else if (key == '\\')
396: rl_complete_internal (TAB); /* Standard Readline completion. */
397: else
398: rl_complete (0, key);
399:
400: if (key == '*' || key == '\\')
401: rl_vi_start_inserting (key, 1, rl_arg_sign);
402:
403: return (0);
404: }
405:
406: /* Tilde expansion for vi mode. */
407: int
408: rl_vi_tilde_expand (ignore, key)
409: int ignore, key;
410: {
411: rl_tilde_expand (0, key);
412: rl_vi_start_inserting (key, 1, rl_arg_sign);
413: return (0);
414: }
415:
416: /* Previous word in vi mode. */
417: int
418: rl_vi_prev_word (count, key)
419: int count, key;
420: {
421: if (count < 0)
422: return (rl_vi_next_word (-count, key));
423:
424: if (rl_point == 0)
425: {
426: rl_ding ();
427: return (0);
428: }
429:
430: if (_rl_uppercase_p (key))
431: rl_vi_bWord (count, key);
432: else
433: rl_vi_bword (count, key);
434:
435: return (0);
436: }
437:
438: /* Next word in vi mode. */
439: int
440: rl_vi_next_word (count, key)
441: int count, key;
442: {
443: if (count < 0)
444: return (rl_vi_prev_word (-count, key));
445:
446: if (rl_point >= (rl_end - 1))
447: {
448: rl_ding ();
449: return (0);
450: }
451:
452: if (_rl_uppercase_p (key))
453: rl_vi_fWord (count, key);
454: else
455: rl_vi_fword (count, key);
456: return (0);
457: }
458:
459: /* Move to the end of the ?next? word. */
460: int
461: rl_vi_end_word (count, key)
462: int count, key;
463: {
464: if (count < 0)
465: {
466: rl_ding ();
467: return -1;
468: }
469:
470: if (_rl_uppercase_p (key))
471: rl_vi_eWord (count, key);
472: else
473: rl_vi_eword (count, key);
474: return (0);
475: }
476:
477: /* Move forward a word the way that 'W' does. */
478: int
479: rl_vi_fWord (count, ignore)
480: int count, ignore;
481: {
482: while (count-- && rl_point < (rl_end - 1))
483: {
484: /* Skip until whitespace. */
485: while (!whitespace (rl_line_buffer[rl_point]) && rl_point < rl_end)
486: rl_point++;
487:
488: /* Now skip whitespace. */
489: while (whitespace (rl_line_buffer[rl_point]) && rl_point < rl_end)
490: rl_point++;
491: }
492: return (0);
493: }
494:
495: int
496: rl_vi_bWord (count, ignore)
497: int count, ignore;
498: {
499: while (count-- && rl_point > 0)
500: {
501: /* If we are at the start of a word, move back to whitespace so
502: we will go back to the start of the previous word. */
503: if (!whitespace (rl_line_buffer[rl_point]) &&
504: whitespace (rl_line_buffer[rl_point - 1]))
505: rl_point--;
506:
507: while (rl_point > 0 && whitespace (rl_line_buffer[rl_point]))
508: rl_point--;
509:
510: if (rl_point > 0)
511: {
512: while (--rl_point >= 0 && !whitespace (rl_line_buffer[rl_point]));
513: rl_point++;
514: }
515: }
516: return (0);
517: }
518:
519: int
520: rl_vi_eWord (count, ignore)
521: int count, ignore;
522: {
523: while (count-- && rl_point < (rl_end - 1))
524: {
525: if (!whitespace (rl_line_buffer[rl_point]))
526: rl_point++;
527:
528: /* Move to the next non-whitespace character (to the start of the
529: next word). */
530: while (rl_point < rl_end && whitespace (rl_line_buffer[rl_point]))
531: rl_point++;
532:
533: if (rl_point && rl_point < rl_end)
534: {
535: /* Skip whitespace. */
536: while (rl_point < rl_end && whitespace (rl_line_buffer[rl_point]))
537: rl_point++;
538:
539: /* Skip until whitespace. */
540: while (rl_point < rl_end && !whitespace (rl_line_buffer[rl_point]))
541: rl_point++;
542:
543: /* Move back to the last character of the word. */
544: rl_point--;
545: }
546: }
547: return (0);
548: }
549:
550: int
551: rl_vi_fword (count, ignore)
552: int count, ignore;
553: {
554: while (count-- && rl_point < (rl_end - 1))
555: {
556: /* Move to white space (really non-identifer). */
557: if (_rl_isident (rl_line_buffer[rl_point]))
558: {
559: while (_rl_isident (rl_line_buffer[rl_point]) && rl_point < rl_end)
560: rl_point++;
561: }
562: else /* if (!whitespace (rl_line_buffer[rl_point])) */
563: {
564: while (!_rl_isident (rl_line_buffer[rl_point]) &&
565: !whitespace (rl_line_buffer[rl_point]) && rl_point < rl_end)
566: rl_point++;
567: }
568:
569: /* Move past whitespace. */
570: while (whitespace (rl_line_buffer[rl_point]) && rl_point < rl_end)
571: rl_point++;
572: }
573: return (0);
574: }
575:
576: int
577: rl_vi_bword (count, ignore)
578: int count, ignore;
579: {
580: while (count-- && rl_point > 0)
581: {
582: int last_is_ident;
583:
584: /* If we are at the start of a word, move back to whitespace
585: so we will go back to the start of the previous word. */
586: if (!whitespace (rl_line_buffer[rl_point]) &&
587: whitespace (rl_line_buffer[rl_point - 1]))
588: rl_point--;
589:
590: /* If this character and the previous character are `opposite', move
591: back so we don't get messed up by the rl_point++ down there in
592: the while loop. Without this code, words like `l;' screw up the
593: function. */
594: last_is_ident = _rl_isident (rl_line_buffer[rl_point - 1]);
595: if ((_rl_isident (rl_line_buffer[rl_point]) && !last_is_ident) ||
596: (!_rl_isident (rl_line_buffer[rl_point]) && last_is_ident))
597: rl_point--;
598:
599: while (rl_point > 0 && whitespace (rl_line_buffer[rl_point]))
600: rl_point--;
601:
602: if (rl_point > 0)
603: {
604: if (_rl_isident (rl_line_buffer[rl_point]))
605: while (--rl_point >= 0 && _rl_isident (rl_line_buffer[rl_point]));
606: else
607: while (--rl_point >= 0 && !_rl_isident (rl_line_buffer[rl_point]) &&
608: !whitespace (rl_line_buffer[rl_point]));
609: rl_point++;
610: }
611: }
612: return (0);
613: }
614:
615: int
616: rl_vi_eword (count, ignore)
617: int count, ignore;
618: {
619: while (count-- && rl_point < rl_end - 1)
620: {
621: if (!whitespace (rl_line_buffer[rl_point]))
622: rl_point++;
623:
624: while (rl_point < rl_end && whitespace (rl_line_buffer[rl_point]))
625: rl_point++;
626:
627: if (rl_point < rl_end)
628: {
629: if (_rl_isident (rl_line_buffer[rl_point]))
630: while (++rl_point < rl_end && _rl_isident (rl_line_buffer[rl_point]));
631: else
632: while (++rl_point < rl_end && !_rl_isident (rl_line_buffer[rl_point])
633: && !whitespace (rl_line_buffer[rl_point]));
634: }
635: rl_point--;
636: }
637: return (0);
638: }
639:
640: int
641: rl_vi_insert_beg (count, key)
642: int count, key;
643: {
644: rl_beg_of_line (1, key);
645: rl_vi_insert_mode (1, key);
646: return (0);
647: }
648:
649: static void
650: _rl_vi_append_forward (key)
651: int key;
652: {
653: int point;
654:
655: if (rl_point < rl_end)
656: {
657: if (MB_CUR_MAX == 1 || rl_byte_oriented)
658: rl_point++;
659: else
660: {
661: point = rl_point;
662: #if 0
663: rl_forward_char (1, key);
664: #else
665: rl_point = _rl_forward_char_internal (1);
666: #endif
667: if (point == rl_point)
668: rl_point = rl_end;
669: }
670: }
671: }
672:
673: int
674: rl_vi_append_mode (count, key)
675: int count, key;
676: {
677: _rl_vi_append_forward (key);
678: rl_vi_start_inserting (key, 1, rl_arg_sign);
679: return (0);
680: }
681:
682: int
683: rl_vi_append_eol (count, key)
684: int count, key;
685: {
686: rl_end_of_line (1, key);
687: rl_vi_append_mode (1, key);
688: return (0);
689: }
690:
691: /* What to do in the case of C-d. */
692: int
693: rl_vi_eof_maybe (count, c)
694: int count, c;
695: {
696: return (rl_newline (1, '\n'));
697: }
698:
699: /* Insertion mode stuff. */
700:
701: /* Switching from one mode to the other really just involves
702: switching keymaps. */
703: int
704: rl_vi_insertion_mode (count, key)
705: int count, key;
706: {
707: _rl_keymap = vi_insertion_keymap;
708: _rl_vi_last_key_before_insert = key;
709: if (_rl_show_mode_in_prompt)
710: _rl_reset_prompt ();
711: return (0);
712: }
713:
714: int
715: rl_vi_insert_mode (count, key)
716: int count, key;
717: {
718: rl_vi_start_inserting (key, 1, rl_arg_sign);
719: return (0);
720: }
721:
722: static void
723: vi_save_insert_buffer (start, len)
724: int start, len;
725: {
726: /* Same code as _rl_vi_save_insert below */
727: if (len >= vi_insert_buffer_size)
728: {
729: vi_insert_buffer_size += (len + 32) - (len % 32);
730: vi_insert_buffer = (char *)xrealloc (vi_insert_buffer, vi_insert_buffer_size);
731: }
732: strncpy (vi_insert_buffer, rl_line_buffer + start, len - 1);
733: vi_insert_buffer[len-1] = '\0';
734: }
735:
736: static void
737: _rl_vi_save_replace ()
738: {
739: int len, start, end;
740: UNDO_LIST *up;
741:
742: up = rl_undo_list;
743: if (up == 0 || up->what != UNDO_END || vi_replace_count <= 0)
744: {
745: if (vi_insert_buffer_size >= 1)
746: vi_insert_buffer[0] = '\0';
747: return;
748: }
749: /* Let's try it the quick and easy way for now. This should essentially
750: accommodate every UNDO_INSERT and save the inserted text to
751: vi_insert_buffer */
752: end = rl_point;
753: start = end - vi_replace_count + 1;
754: len = vi_replace_count + 1;
755:
756: vi_save_insert_buffer (start, len);
757: }
758:
759: static void
760: _rl_vi_save_insert (up)
761: UNDO_LIST *up;
762: {
763: int len, start, end;
764:
765: if (up == 0 || up->what != UNDO_INSERT)
766: {
767: if (vi_insert_buffer_size >= 1)
768: vi_insert_buffer[0] = '\0';
769: return;
770: }
771:
772: start = up->start;
773: end = up->end;
774: len = end - start + 1;
775:
776: vi_save_insert_buffer (start, len);
777: }
778:
779: void
780: _rl_vi_done_inserting ()
781: {
782: if (_rl_vi_doing_insert)
783: {
784: /* The `C', `s', and `S' commands set this. */
785: rl_end_undo_group ();
786: /* Now, the text between rl_undo_list->next->start and
787: rl_undo_list->next->end is what was inserted while in insert
788: mode. It gets copied to VI_INSERT_BUFFER because it depends
789: on absolute indices into the line which may change (though they
790: probably will not). */
791: _rl_vi_doing_insert = 0;
792: if (_rl_vi_last_key_before_insert == 'R')
793: _rl_vi_save_replace (); /* Half the battle */
794: else
795: _rl_vi_save_insert (rl_undo_list->next);
796: vi_continued_command = 1;
797: }
798: else
799: {
800: if (rl_undo_list && (_rl_vi_last_key_before_insert == 'i' ||
801: _rl_vi_last_key_before_insert == 'a' ||
802: _rl_vi_last_key_before_insert == 'I' ||
803: _rl_vi_last_key_before_insert == 'A'))
804: _rl_vi_save_insert (rl_undo_list);
805: /* XXX - Other keys probably need to be checked. */
806: else if (_rl_vi_last_key_before_insert == 'C')
807: rl_end_undo_group ();
808: while (_rl_undo_group_level > 0)
809: rl_end_undo_group ();
810: vi_continued_command = 0;
811: }
812: }
813:
814: int
815: rl_vi_movement_mode (count, key)
816: int count, key;
817: {
818: if (rl_point > 0)
819: rl_backward_char (1, key);
820:
821: _rl_keymap = vi_movement_keymap;
822: _rl_vi_done_inserting ();
823:
824: /* This is how POSIX.2 says `U' should behave -- everything up until the
825: first time you go into command mode should not be undone. */
826: if (RL_ISSTATE (RL_STATE_VICMDONCE) == 0)
827: rl_free_undo_list ();
828:
829: if (_rl_show_mode_in_prompt)
830: _rl_reset_prompt ();
831:
832: RL_SETSTATE (RL_STATE_VICMDONCE);
833: return (0);
834: }
835:
836: int
837: rl_vi_arg_digit (count, c)
838: int count, c;
839: {
840: if (c == '0' && rl_numeric_arg == 1 && !rl_explicit_arg)
841: return (rl_beg_of_line (1, c));
842: else
843: return (rl_digit_argument (count, c));
844: }
845:
846: /* Change the case of the next COUNT characters. */
847: #if defined (HANDLE_MULTIBYTE)
848: static int
849: _rl_vi_change_mbchar_case (count)
850: int count;
851: {
852: wchar_t wc;
853: char mb[MB_LEN_MAX+1];
854: int mlen, p;
855: size_t m;
856: mbstate_t ps;
857:
858: memset (&ps, 0, sizeof (mbstate_t));
859: if (_rl_adjust_point (rl_line_buffer, rl_point, &ps) > 0)
860: count--;
861: while (count-- && rl_point < rl_end)
862: {
863: m = mbrtowc (&wc, rl_line_buffer + rl_point, rl_end - rl_point, &ps);
864: if (MB_INVALIDCH (m))
865: wc = (wchar_t)rl_line_buffer[rl_point];
866: else if (MB_NULLWCH (m))
867: wc = L'\0';
868: if (iswupper (wc))
869: wc = towlower (wc);
870: else if (iswlower (wc))
871: wc = towupper (wc);
872: else
873: {
874: /* Just skip over chars neither upper nor lower case */
875: rl_forward_char (1, 0);
876: continue;
877: }
878:
879: /* Vi is kind of strange here. */
880: if (wc)
881: {
882: p = rl_point;
883: mlen = wcrtomb (mb, wc, &ps);
884: if (mlen >= 0)
885: mb[mlen] = '\0';
886: rl_begin_undo_group ();
887: rl_vi_delete (1, 0);
888: if (rl_point < p) /* Did we retreat at EOL? */
889: rl_point++; /* XXX - should we advance more than 1 for mbchar? */
890: rl_insert_text (mb);
891: rl_end_undo_group ();
892: rl_vi_check ();
893: }
894: else
895: rl_forward_char (1, 0);
896: }
897:
898: return 0;
899: }
900: #endif
901:
902: int
903: rl_vi_change_case (count, ignore)
904: int count, ignore;
905: {
906: int c, p;
907:
908: /* Don't try this on an empty line. */
909: if (rl_point >= rl_end)
910: return (0);
911:
912: c = 0;
913: #if defined (HANDLE_MULTIBYTE)
914: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
915: return (_rl_vi_change_mbchar_case (count));
916: #endif
917:
918: while (count-- && rl_point < rl_end)
919: {
920: if (_rl_uppercase_p (rl_line_buffer[rl_point]))
921: c = _rl_to_lower (rl_line_buffer[rl_point]);
922: else if (_rl_lowercase_p (rl_line_buffer[rl_point]))
923: c = _rl_to_upper (rl_line_buffer[rl_point]);
924: else
925: {
926: /* Just skip over characters neither upper nor lower case. */
927: rl_forward_char (1, c);
928: continue;
929: }
930:
931: /* Vi is kind of strange here. */
932: if (c)
933: {
934: p = rl_point;
935: rl_begin_undo_group ();
936: rl_vi_delete (1, c);
937: if (rl_point < p) /* Did we retreat at EOL? */
938: rl_point++;
939: _rl_insert_char (1, c);
940: rl_end_undo_group ();
941: rl_vi_check ();
942: }
943: else
944: rl_forward_char (1, c);
945: }
946: return (0);
947: }
948:
949: int
950: rl_vi_put (count, key)
951: int count, key;
952: {
953: if (!_rl_uppercase_p (key) && (rl_point + 1 <= rl_end))
954: rl_point = _rl_find_next_mbchar (rl_line_buffer, rl_point, 1, MB_FIND_NONZERO);
955:
956: while (count--)
957: rl_yank (1, key);
958:
959: rl_backward_char (1, key);
960: return (0);
961: }
962:
963: static void
964: _rl_vi_backup ()
965: {
966: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
967: rl_point = _rl_find_prev_mbchar (rl_line_buffer, rl_point, MB_FIND_NONZERO);
968: else
969: rl_point--;
970: }
971:
972: int
973: rl_vi_check ()
974: {
975: if (rl_point && rl_point == rl_end)
976: {
977: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
978: rl_point = _rl_find_prev_mbchar (rl_line_buffer, rl_point, MB_FIND_NONZERO);
979: else
980: rl_point--;
981: }
982: return (0);
983: }
984:
985: int
986: rl_vi_column (count, key)
987: int count, key;
988: {
989: if (count > rl_end)
990: rl_end_of_line (1, key);
991: else
992: rl_point = count - 1;
993: return (0);
994: }
995:
996: /* Process C as part of the current numeric argument. Return -1 if the
997: argument should be aborted, 0 if we should not read any more chars, and
998: 1 if we should continue to read chars. */
999: static int
1000: _rl_vi_arg_dispatch (c)
1001: int c;
1002: {
1003: int key;
1004:
1005: key = c;
1006: if (c >= 0 && _rl_keymap[c].type == ISFUNC && _rl_keymap[c].function == rl_universal_argument)
1007: {
1008: rl_numeric_arg *= 4;
1009: return 1;
1010: }
1011:
1012: c = UNMETA (c);
1013:
1014: if (_rl_digit_p (c))
1015: {
1016: if (rl_explicit_arg)
1017: rl_numeric_arg = (rl_numeric_arg * 10) + _rl_digit_value (c);
1018: else
1019: rl_numeric_arg = _rl_digit_value (c);
1020: rl_explicit_arg = 1;
1021: return 1; /* keep going */
1022: }
1023: else
1024: {
1025: rl_clear_message ();
1026: rl_stuff_char (key);
1027: return 0; /* done */
1028: }
1029: }
1030:
1031: /* A simplified loop for vi. Don't dispatch key at end.
1032: Don't recognize minus sign?
1033: Should this do rl_save_prompt/rl_restore_prompt? */
1034: static int
1035: rl_digit_loop1 ()
1036: {
1037: int c, r;
1038:
1039: while (1)
1040: {
1041: if (_rl_arg_overflow ())
1042: return 1;
1043:
1044: c = _rl_arg_getchar ();
1045:
1046: r = _rl_vi_arg_dispatch (c);
1047: if (r <= 0)
1048: break;
1049: }
1050:
1051: RL_UNSETSTATE(RL_STATE_NUMERICARG);
1052: return (0);
1053: }
1054:
1055: static void
1056: _rl_mvcxt_init (m, op, key)
1057: _rl_vimotion_cxt *m;
1058: int op, key;
1059: {
1060: m->op = op;
1061: m->state = m->flags = 0;
1062: m->ncxt = 0;
1063: m->numeric_arg = -1;
1064: m->start = rl_point;
1065: m->end = rl_end;
1066: m->key = key;
1067: m->motion = -1;
1068: }
1069:
1070: static _rl_vimotion_cxt *
1071: _rl_mvcxt_alloc (op, key)
1072: int op, key;
1073: {
1074: _rl_vimotion_cxt *m;
1075:
1076: m = xmalloc (sizeof (_rl_vimotion_cxt));
1077: _rl_mvcxt_init (m, op, key);
1078: return m;
1079: }
1080:
1081: static void
1082: _rl_mvcxt_dispose (m)
1083: _rl_vimotion_cxt *m;
1084: {
1085: xfree (m);
1086: }
1087:
1088: static int
1089: rl_domove_motion_callback (m)
1090: _rl_vimotion_cxt *m;
1091: {
1092: int c, save, r;
1093: int old_end;
1094:
1095: _rl_vi_last_motion = c = m->motion;
1096:
1097: /* Append a blank character temporarily so that the motion routines
1098: work right at the end of the line. */
1099: old_end = rl_end;
1100: rl_line_buffer[rl_end++] = ' ';
1101: rl_line_buffer[rl_end] = '\0';
1102:
1103: _rl_dispatch (c, _rl_keymap);
1104:
1105: /* Remove the blank that we added. */
1106: rl_end = old_end;
1107: rl_line_buffer[rl_end] = '\0';
1108: if (rl_point > rl_end)
1109: rl_point = rl_end;
1110:
1111: /* No change in position means the command failed. */
1112: if (rl_mark == rl_point)
1113: return (-1);
1114:
1115: /* rl_vi_f[wW]ord () leaves the cursor on the first character of the next
1116: word. If we are not at the end of the line, and we are on a
1117: non-whitespace character, move back one (presumably to whitespace). */
1118: if ((_rl_to_upper (c) == 'W') && rl_point < rl_end && rl_point > rl_mark &&
1119: !whitespace (rl_line_buffer[rl_point]))
1120: rl_point--;
1121:
1122: /* If cw or cW, back up to the end of a word, so the behaviour of ce
1123: or cE is the actual result. Brute-force, no subtlety. */
1124: if (m->key == 'c' && rl_point >= rl_mark && (_rl_to_upper (c) == 'W'))
1125: {
1126: /* Don't move farther back than where we started. */
1127: while (rl_point > rl_mark && whitespace (rl_line_buffer[rl_point]))
1128: rl_point--;
1129:
1130: /* Posix.2 says that if cw or cW moves the cursor towards the end of
1131: the line, the character under the cursor should be deleted. */
1132: if (rl_point == rl_mark)
1133: rl_point++;
1134: else
1135: {
1136: /* Move past the end of the word so that the kill doesn't
1137: remove the last letter of the previous word. Only do this
1138: if we are not at the end of the line. */
1139: if (rl_point >= 0 && rl_point < (rl_end - 1) && !whitespace (rl_line_buffer[rl_point]))
1140: rl_point++;
1141: }
1142: }
1143:
1144: if (rl_mark < rl_point)
1145: SWAP (rl_point, rl_mark);
1146:
1147: #if defined (READLINE_CALLBACKS)
1148: if (RL_ISSTATE (RL_STATE_CALLBACK))
1149: (*rl_redisplay_function)(); /* make sure motion is displayed */
1150: #endif
1151:
1152: r = vidomove_dispatch (m);
1153:
1154: return (r);
1155: }
1156:
1157: #define RL_VIMOVENUMARG() (RL_ISSTATE (RL_STATE_VIMOTION) && RL_ISSTATE (RL_STATE_NUMERICARG))
1158:
1159: static int
1160: rl_domove_read_callback (m)
1161: _rl_vimotion_cxt *m;
1162: {
1163: int c, save;
1164:
1165: c = m->motion;
1166:
1167: if (member (c, vi_motion))
1168: {
1169: #if defined (READLINE_CALLBACKS)
1170: /* If we just read a vi-mode motion command numeric argument, turn off
1171: the `reading numeric arg' state */
1172: if (RL_ISSTATE (RL_STATE_CALLBACK) && RL_VIMOVENUMARG())
1173: RL_UNSETSTATE (RL_STATE_NUMERICARG);
1174: #endif
1175: /* Should do everything, including turning off RL_STATE_VIMOTION */
1176: return (rl_domove_motion_callback (m));
1177: }
1178: else if (m->key == c && (m->key == 'd' || m->key == 'y' || m->key == 'c'))
1179: {
1180: rl_mark = rl_end;
1181: rl_beg_of_line (1, c);
1182: _rl_vi_last_motion = c;
1183: RL_UNSETSTATE (RL_STATE_VIMOTION);
1184: return (vidomove_dispatch (m));
1185: }
1186: #if defined (READLINE_CALLBACKS)
1187: /* XXX - these need to handle rl_universal_argument bindings */
1188: /* Reading vi motion char continuing numeric argument */
1189: else if (_rl_digit_p (c) && RL_ISSTATE (RL_STATE_CALLBACK) && RL_VIMOVENUMARG())
1190: {
1191: return (_rl_vi_arg_dispatch (c));
1192: }
1193: /* Readine vi motion char starting numeric argument */
1194: else if (_rl_digit_p (c) && RL_ISSTATE (RL_STATE_CALLBACK) && RL_ISSTATE (RL_STATE_VIMOTION) && (RL_ISSTATE (RL_STATE_NUMERICARG) == 0))
1195: {
1196: RL_SETSTATE (RL_STATE_NUMERICARG);
1197: return (_rl_vi_arg_dispatch (c));
1198: }
1199: #endif
1200: else if (_rl_digit_p (c))
1201: {
1202: /* This code path taken when not in callback mode */
1203: save = rl_numeric_arg;
1204: rl_numeric_arg = _rl_digit_value (c);
1205: rl_explicit_arg = 1;
1206: RL_SETSTATE (RL_STATE_NUMERICARG);
1207: rl_digit_loop1 ();
1208: rl_numeric_arg *= save;
1209: c = rl_vi_domove_getchar (m);
1210: if (c < 0)
1211: {
1212: m->motion = 0;
1213: return -1;
1214: }
1215: m->motion = c;
1216: return (rl_domove_motion_callback (m));
1217: }
1218: else
1219: {
1220: RL_UNSETSTATE (RL_STATE_VIMOTION);
1221: RL_UNSETSTATE (RL_STATE_NUMERICARG);
1222: return (1);
1223: }
1224: }
1225:
1226: static int
1227: rl_vi_domove_getchar (m)
1228: _rl_vimotion_cxt *m;
1229: {
1230: int c;
1231:
1232: RL_SETSTATE(RL_STATE_MOREINPUT);
1233: c = rl_read_key ();
1234: RL_UNSETSTATE(RL_STATE_MOREINPUT);
1235:
1236: return c;
1237: }
1238:
1239: #if defined (READLINE_CALLBACKS)
1240: int
1241: _rl_vi_domove_callback (m)
1242: _rl_vimotion_cxt *m;
1243: {
1244: int c, r;
1245:
1246: m->motion = c = rl_vi_domove_getchar (m);
1247: /* XXX - what to do if this returns -1? Should we return 1 for eof to
1248: callback code? */
1249: r = rl_domove_read_callback (m);
1250:
1251: return ((r == 0) ? r : 1); /* normalize return values */
1252: }
1253: #endif
1254:
1255: /* This code path taken when not in callback mode. */
1256: int
1257: rl_vi_domove (x, ignore)
1258: int x, *ignore;
1259: {
1260: int r;
1261: _rl_vimotion_cxt *m;
1262:
1263: m = _rl_vimvcxt;
1264: *ignore = m->motion = rl_vi_domove_getchar (m);
1265:
1266: if (m->motion < 0)
1267: {
1268: m->motion = 0;
1269: return -1;
1270: }
1271:
1272: return (rl_domove_read_callback (m));
1273: }
1274:
1275: static int
1276: vi_delete_dispatch (m)
1277: _rl_vimotion_cxt *m;
1278: {
1279: /* These are the motion commands that do not require adjusting the
1280: mark. */
1281: if (((strchr (" l|h^0bBFT`", m->motion) == 0) && (rl_point >= m->start)) &&
1282: (rl_mark < rl_end))
1283: rl_mark++;
1284:
1285: rl_kill_text (rl_point, rl_mark);
1286: return (0);
1287: }
1288:
1289: int
1290: rl_vi_delete_to (count, key)
1291: int count, key;
1292: {
1293: int c, r;
1294:
1295: _rl_vimvcxt = _rl_mvcxt_alloc (VIM_DELETE, key);
1296: _rl_vimvcxt->start = rl_point;
1297:
1298: rl_mark = rl_point;
1299: if (_rl_uppercase_p (key))
1300: {
1301: _rl_vimvcxt->motion = '$';
1302: r = rl_domove_motion_callback (_rl_vimvcxt);
1303: }
1304: else if (vi_redoing && _rl_vi_last_motion != 'd') /* `dd' is special */
1305: {
1306: _rl_vimvcxt->motion = _rl_vi_last_motion;
1307: r = rl_domove_motion_callback (_rl_vimvcxt);
1308: }
1309: else if (vi_redoing) /* handle redoing `dd' here */
1310: {
1311: _rl_vimvcxt->motion = _rl_vi_last_motion;
1312: rl_mark = rl_end;
1313: rl_beg_of_line (1, key);
1314: RL_UNSETSTATE (RL_STATE_VIMOTION);
1315: r = vidomove_dispatch (_rl_vimvcxt);
1316: }
1317: #if defined (READLINE_CALLBACKS)
1318: else if (RL_ISSTATE (RL_STATE_CALLBACK))
1319: {
1320: RL_SETSTATE (RL_STATE_VIMOTION);
1321: return (0);
1322: }
1323: #endif
1324: else
1325: r = rl_vi_domove (key, &c);
1326:
1327: if (r < 0)
1328: {
1329: rl_ding ();
1330: r = -1;
1331: }
1332:
1333: _rl_mvcxt_dispose (_rl_vimvcxt);
1334: _rl_vimvcxt = 0;
1335:
1336: return r;
1337: }
1338:
1339: static int
1340: vi_change_dispatch (m)
1341: _rl_vimotion_cxt *m;
1342: {
1343: /* These are the motion commands that do not require adjusting the
1344: mark. c[wW] are handled by special-case code in rl_vi_domove(),
1345: and already leave the mark at the correct location. */
1346: if (((strchr (" l|hwW^0bBFT`", m->motion) == 0) && (rl_point >= m->start)) &&
1347: (rl_mark < rl_end))
1348: rl_mark++;
1349:
1350: /* The cursor never moves with c[wW]. */
1351: if ((_rl_to_upper (m->motion) == 'W') && rl_point < m->start)
1352: rl_point = m->start;
1353:
1354: if (vi_redoing)
1355: {
1356: if (vi_insert_buffer && *vi_insert_buffer)
1357: rl_begin_undo_group ();
1358: rl_delete_text (rl_point, rl_mark);
1359: if (vi_insert_buffer && *vi_insert_buffer)
1360: {
1361: rl_insert_text (vi_insert_buffer);
1362: rl_end_undo_group ();
1363: }
1364: }
1365: else
1366: {
1367: rl_begin_undo_group (); /* to make the `u' command work */
1368: rl_kill_text (rl_point, rl_mark);
1369: /* `C' does not save the text inserted for undoing or redoing. */
1370: if (_rl_uppercase_p (m->key) == 0)
1371: _rl_vi_doing_insert = 1;
1372: /* XXX -- TODO -- use m->numericarg? */
1373: rl_vi_start_inserting (m->key, rl_numeric_arg, rl_arg_sign);
1374: }
1375:
1376: return (0);
1377: }
1378:
1379: int
1380: rl_vi_change_to (count, key)
1381: int count, key;
1382: {
1383: int c, r;
1384:
1385: _rl_vimvcxt = _rl_mvcxt_alloc (VIM_CHANGE, key);
1386: _rl_vimvcxt->start = rl_point;
1387:
1388: rl_mark = rl_point;
1389: if (_rl_uppercase_p (key))
1390: {
1391: _rl_vimvcxt->motion = '$';
1392: r = rl_domove_motion_callback (_rl_vimvcxt);
1393: }
1394: else if (vi_redoing && _rl_vi_last_motion != 'c') /* `cc' is special */
1395: {
1396: _rl_vimvcxt->motion = _rl_vi_last_motion;
1397: r = rl_domove_motion_callback (_rl_vimvcxt);
1398: }
1399: else if (vi_redoing) /* handle redoing `cc' here */
1400: {
1401: _rl_vimvcxt->motion = _rl_vi_last_motion;
1402: rl_mark = rl_end;
1403: rl_beg_of_line (1, key);
1404: RL_UNSETSTATE (RL_STATE_VIMOTION);
1405: r = vidomove_dispatch (_rl_vimvcxt);
1406: }
1407: #if defined (READLINE_CALLBACKS)
1408: else if (RL_ISSTATE (RL_STATE_CALLBACK))
1409: {
1410: RL_SETSTATE (RL_STATE_VIMOTION);
1411: return (0);
1412: }
1413: #endif
1414: else
1415: r = rl_vi_domove (key, &c);
1416:
1417: if (r < 0)
1418: {
1419: rl_ding ();
1420: r = -1; /* normalize return value */
1421: }
1422:
1423: _rl_mvcxt_dispose (_rl_vimvcxt);
1424: _rl_vimvcxt = 0;
1425:
1426: return r;
1427: }
1428:
1429: static int
1430: vi_yank_dispatch (m)
1431: _rl_vimotion_cxt *m;
1432: {
1433: /* These are the motion commands that do not require adjusting the
1434: mark. */
1435: if (((strchr (" l|h^0%bBFT`", m->motion) == 0) && (rl_point >= m->start)) &&
1436: (rl_mark < rl_end))
1437: rl_mark++;
1438:
1439: rl_begin_undo_group ();
1440: rl_kill_text (rl_point, rl_mark);
1441: rl_end_undo_group ();
1442: rl_do_undo ();
1443: rl_point = m->start;
1444:
1445: return (0);
1446: }
1447:
1448: int
1449: rl_vi_yank_to (count, key)
1450: int count, key;
1451: {
1452: int c, r;
1453:
1454: _rl_vimvcxt = _rl_mvcxt_alloc (VIM_YANK, key);
1455: _rl_vimvcxt->start = rl_point;
1456:
1457: rl_mark = rl_point;
1458: if (_rl_uppercase_p (key))
1459: {
1460: _rl_vimvcxt->motion = '$';
1461: r = rl_domove_motion_callback (_rl_vimvcxt);
1462: }
1463: else if (vi_redoing && _rl_vi_last_motion != 'y') /* `yy' is special */
1464: {
1465: _rl_vimvcxt->motion = _rl_vi_last_motion;
1466: r = rl_domove_motion_callback (_rl_vimvcxt);
1467: }
1468: else if (vi_redoing) /* handle redoing `yy' here */
1469: {
1470: _rl_vimvcxt->motion = _rl_vi_last_motion;
1471: rl_mark = rl_end;
1472: rl_beg_of_line (1, key);
1473: RL_UNSETSTATE (RL_STATE_VIMOTION);
1474: r = vidomove_dispatch (_rl_vimvcxt);
1475: }
1476: #if defined (READLINE_CALLBACKS)
1477: else if (RL_ISSTATE (RL_STATE_CALLBACK))
1478: {
1479: RL_SETSTATE (RL_STATE_VIMOTION);
1480: return (0);
1481: }
1482: #endif
1483: else
1484: r = rl_vi_domove (key, &c);
1485:
1486: if (r < 0)
1487: {
1488: rl_ding ();
1489: r = -1;
1490: }
1491:
1492: _rl_mvcxt_dispose (_rl_vimvcxt);
1493: _rl_vimvcxt = 0;
1494:
1495: return r;
1496: }
1497:
1498: static int
1499: vidomove_dispatch (m)
1500: _rl_vimotion_cxt *m;
1501: {
1502: int r;
1503:
1504: switch (m->op)
1505: {
1506: case VIM_DELETE:
1507: r = vi_delete_dispatch (m);
1508: break;
1509: case VIM_CHANGE:
1510: r = vi_change_dispatch (m);
1511: break;
1512: case VIM_YANK:
1513: r = vi_yank_dispatch (m);
1514: break;
1515: default:
1516: _rl_errmsg ("vidomove_dispatch: unknown operator %d", m->op);
1517: r = 1;
1518: break;
1519: }
1520:
1521: RL_UNSETSTATE (RL_STATE_VIMOTION);
1522: return r;
1523: }
1524:
1525: int
1526: rl_vi_rubout (count, key)
1527: int count, key;
1528: {
1529: int opoint;
1530:
1531: if (count < 0)
1532: return (rl_vi_delete (-count, key));
1533:
1534: if (rl_point == 0)
1535: {
1536: rl_ding ();
1537: return -1;
1538: }
1539:
1540: opoint = rl_point;
1541: if (count > 1 && MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1542: rl_backward_char (count, key);
1543: else if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1544: rl_point = _rl_find_prev_mbchar (rl_line_buffer, rl_point, MB_FIND_NONZERO);
1545: else
1546: rl_point -= count;
1547:
1548: if (rl_point < 0)
1549: rl_point = 0;
1550:
1551: rl_kill_text (rl_point, opoint);
1552:
1553: return (0);
1554: }
1555:
1556: int
1557: rl_vi_delete (count, key)
1558: int count, key;
1559: {
1560: int end;
1561:
1562: if (count < 0)
1563: return (rl_vi_rubout (-count, key));
1564:
1565: if (rl_end == 0)
1566: {
1567: rl_ding ();
1568: return -1;
1569: }
1570:
1571: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1572: end = _rl_find_next_mbchar (rl_line_buffer, rl_point, count, MB_FIND_NONZERO);
1573: else
1574: end = rl_point + count;
1575:
1576: if (end >= rl_end)
1577: end = rl_end;
1578:
1579: rl_kill_text (rl_point, end);
1580:
1581: if (rl_point > 0 && rl_point == rl_end)
1582: rl_backward_char (1, key);
1583:
1584: return (0);
1585: }
1586:
1587: int
1588: rl_vi_back_to_indent (count, key)
1589: int count, key;
1590: {
1591: rl_beg_of_line (1, key);
1592: while (rl_point < rl_end && whitespace (rl_line_buffer[rl_point]))
1593: rl_point++;
1594: return (0);
1595: }
1596:
1597: int
1598: rl_vi_first_print (count, key)
1599: int count, key;
1600: {
1601: return (rl_vi_back_to_indent (1, key));
1602: }
1603:
1604: static int _rl_cs_dir, _rl_cs_orig_dir;
1605:
1606: #if defined (READLINE_CALLBACKS)
1607: static int
1608: _rl_vi_callback_char_search (data)
1609: _rl_callback_generic_arg *data;
1610: {
1611: int c;
1612: #if defined (HANDLE_MULTIBYTE)
1613: c = _rl_vi_last_search_mblen = _rl_read_mbchar (_rl_vi_last_search_mbchar, MB_LEN_MAX);
1614: #else
1615: RL_SETSTATE(RL_STATE_MOREINPUT);
1616: c = rl_read_key ();
1617: RL_UNSETSTATE(RL_STATE_MOREINPUT);
1618: #endif
1619:
1620: if (c <= 0)
1621: return -1;
1622:
1623: #if !defined (HANDLE_MULTIBYTE)
1624: _rl_vi_last_search_char = c;
1625: #endif
1626:
1627: _rl_callback_func = 0;
1628: _rl_want_redisplay = 1;
1629:
1630: #if defined (HANDLE_MULTIBYTE)
1631: return (_rl_char_search_internal (data->count, _rl_cs_dir, _rl_vi_last_search_mbchar, _rl_vi_last_search_mblen));
1632: #else
1633: return (_rl_char_search_internal (data->count, _rl_cs_dir, _rl_vi_last_search_char));
1634: #endif
1635: }
1636: #endif
1637:
1638: int
1639: rl_vi_char_search (count, key)
1640: int count, key;
1641: {
1642: int c;
1643: #if defined (HANDLE_MULTIBYTE)
1644: static char *target;
1645: static int tlen;
1646: #else
1647: static char target;
1648: #endif
1649:
1650: if (key == ';' || key == ',')
1651: {
1652: if (_rl_cs_orig_dir == 0)
1653: return -1;
1654: #if defined (HANDLE_MULTIBYTE)
1655: if (_rl_vi_last_search_mblen == 0)
1656: return -1;
1657: #else
1658: if (_rl_vi_last_search_char == 0)
1659: return -1;
1660: #endif
1661: _rl_cs_dir = (key == ';') ? _rl_cs_orig_dir : -_rl_cs_orig_dir;
1662: }
1663: else
1664: {
1665: switch (key)
1666: {
1667: case 't':
1668: _rl_cs_orig_dir = _rl_cs_dir = FTO;
1669: break;
1670:
1671: case 'T':
1672: _rl_cs_orig_dir = _rl_cs_dir = BTO;
1673: break;
1674:
1675: case 'f':
1676: _rl_cs_orig_dir = _rl_cs_dir = FFIND;
1677: break;
1678:
1679: case 'F':
1680: _rl_cs_orig_dir = _rl_cs_dir = BFIND;
1681: break;
1682: }
1683:
1684: if (vi_redoing)
1685: {
1686: /* set target and tlen below */
1687: }
1688: #if defined (READLINE_CALLBACKS)
1689: else if (RL_ISSTATE (RL_STATE_CALLBACK))
1690: {
1691: _rl_callback_data = _rl_callback_data_alloc (count);
1692: _rl_callback_data->i1 = _rl_cs_dir;
1693: _rl_callback_func = _rl_vi_callback_char_search;
1694: return (0);
1695: }
1696: #endif
1697: else
1698: {
1699: #if defined (HANDLE_MULTIBYTE)
1700: c = _rl_read_mbchar (_rl_vi_last_search_mbchar, MB_LEN_MAX);
1701: if (c <= 0)
1702: return -1;
1703: _rl_vi_last_search_mblen = c;
1704: #else
1705: RL_SETSTATE(RL_STATE_MOREINPUT);
1706: c = rl_read_key ();
1707: RL_UNSETSTATE(RL_STATE_MOREINPUT);
1708: if (c < 0)
1709: return -1;
1710: _rl_vi_last_search_char = c;
1711: #endif
1712: }
1713: }
1714:
1715: #if defined (HANDLE_MULTIBYTE)
1716: target = _rl_vi_last_search_mbchar;
1717: tlen = _rl_vi_last_search_mblen;
1718: #else
1719: target = _rl_vi_last_search_char;
1720: #endif
1721:
1722: #if defined (HANDLE_MULTIBYTE)
1723: return (_rl_char_search_internal (count, _rl_cs_dir, target, tlen));
1724: #else
1725: return (_rl_char_search_internal (count, _rl_cs_dir, target));
1726: #endif
1727: }
1728:
1729: /* Match brackets */
1730: int
1731: rl_vi_match (ignore, key)
1732: int ignore, key;
1733: {
1734: int count = 1, brack, pos, tmp, pre;
1735:
1736: pos = rl_point;
1737: if ((brack = rl_vi_bracktype (rl_line_buffer[rl_point])) == 0)
1738: {
1739: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1740: {
1741: while ((brack = rl_vi_bracktype (rl_line_buffer[rl_point])) == 0)
1742: {
1743: pre = rl_point;
1744: rl_forward_char (1, key);
1745: if (pre == rl_point)
1746: break;
1747: }
1748: }
1749: else
1750: while ((brack = rl_vi_bracktype (rl_line_buffer[rl_point])) == 0 &&
1751: rl_point < rl_end - 1)
1752: rl_forward_char (1, key);
1753:
1754: if (brack <= 0)
1755: {
1756: rl_point = pos;
1757: rl_ding ();
1758: return -1;
1759: }
1760: }
1761:
1762: pos = rl_point;
1763:
1764: if (brack < 0)
1765: {
1766: while (count)
1767: {
1768: tmp = pos;
1769: if (MB_CUR_MAX == 1 || rl_byte_oriented)
1770: pos--;
1771: else
1772: {
1773: pos = _rl_find_prev_mbchar (rl_line_buffer, pos, MB_FIND_ANY);
1774: if (tmp == pos)
1775: pos--;
1776: }
1777: if (pos >= 0)
1778: {
1779: int b = rl_vi_bracktype (rl_line_buffer[pos]);
1780: if (b == -brack)
1781: count--;
1782: else if (b == brack)
1783: count++;
1784: }
1785: else
1786: {
1787: rl_ding ();
1788: return -1;
1789: }
1790: }
1791: }
1792: else
1793: { /* brack > 0 */
1794: while (count)
1795: {
1796: if (MB_CUR_MAX == 1 || rl_byte_oriented)
1797: pos++;
1798: else
1799: pos = _rl_find_next_mbchar (rl_line_buffer, pos, 1, MB_FIND_ANY);
1800:
1801: if (pos < rl_end)
1802: {
1803: int b = rl_vi_bracktype (rl_line_buffer[pos]);
1804: if (b == -brack)
1805: count--;
1806: else if (b == brack)
1807: count++;
1808: }
1809: else
1810: {
1811: rl_ding ();
1812: return -1;
1813: }
1814: }
1815: }
1816: rl_point = pos;
1817: return (0);
1818: }
1819:
1820: int
1821: rl_vi_bracktype (c)
1822: int c;
1823: {
1824: switch (c)
1825: {
1826: case '(': return 1;
1827: case ')': return -1;
1828: case '[': return 2;
1829: case ']': return -2;
1830: case '{': return 3;
1831: case '}': return -3;
1832: default: return 0;
1833: }
1834: }
1835:
1836: static int
1837: _rl_vi_change_char (count, c, mb)
1838: int count, c;
1839: char *mb;
1840: {
1841: int p;
1842:
1843: if (c == '\033' || c == CTRL ('C'))
1844: return -1;
1845:
1846: rl_begin_undo_group ();
1847: while (count-- && rl_point < rl_end)
1848: {
1849: p = rl_point;
1850: rl_vi_delete (1, c);
1851: if (rl_point < p) /* Did we retreat at EOL? */
1852: rl_point++;
1853: #if defined (HANDLE_MULTIBYTE)
1854: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1855: rl_insert_text (mb);
1856: else
1857: #endif
1858: _rl_insert_char (1, c);
1859: }
1860:
1861: /* The cursor shall be left on the last character changed. */
1862: rl_backward_char (1, c);
1863:
1864: rl_end_undo_group ();
1865:
1866: return (0);
1867: }
1868:
1869: static int
1870: _rl_vi_callback_getchar (mb, mlen)
1871: char *mb;
1872: int mlen;
1873: {
1874: int c;
1875:
1876: RL_SETSTATE(RL_STATE_MOREINPUT);
1877: c = rl_read_key ();
1878: RL_UNSETSTATE(RL_STATE_MOREINPUT);
1879:
1880: if (c < 0)
1881: return -1;
1882:
1883: #if defined (HANDLE_MULTIBYTE)
1884: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1885: c = _rl_read_mbstring (c, mb, mlen);
1886: #endif
1887:
1888: return c;
1889: }
1890:
1891: #if defined (READLINE_CALLBACKS)
1892: static int
1893: _rl_vi_callback_change_char (data)
1894: _rl_callback_generic_arg *data;
1895: {
1896: int c;
1897: char mb[MB_LEN_MAX];
1898:
1899: _rl_vi_last_replacement = c = _rl_vi_callback_getchar (mb, MB_LEN_MAX);
1900:
1901: if (c < 0)
1902: return -1;
1903:
1904: _rl_callback_func = 0;
1905: _rl_want_redisplay = 1;
1906:
1907: return (_rl_vi_change_char (data->count, c, mb));
1908: }
1909: #endif
1910:
1911: int
1912: rl_vi_change_char (count, key)
1913: int count, key;
1914: {
1915: int c;
1916: char mb[MB_LEN_MAX];
1917:
1918: if (vi_redoing)
1919: {
1920: c = _rl_vi_last_replacement;
1921: mb[0] = c;
1922: mb[1] = '\0';
1923: }
1924: #if defined (READLINE_CALLBACKS)
1925: else if (RL_ISSTATE (RL_STATE_CALLBACK))
1926: {
1927: _rl_callback_data = _rl_callback_data_alloc (count);
1928: _rl_callback_func = _rl_vi_callback_change_char;
1929: return (0);
1930: }
1931: #endif
1932: else
1933: _rl_vi_last_replacement = c = _rl_vi_callback_getchar (mb, MB_LEN_MAX);
1934:
1935: if (c < 0)
1936: return -1;
1937:
1938: return (_rl_vi_change_char (count, c, mb));
1939: }
1940:
1941: int
1942: rl_vi_subst (count, key)
1943: int count, key;
1944: {
1945: /* If we are redoing, rl_vi_change_to will stuff the last motion char */
1946: if (vi_redoing == 0)
1947: rl_stuff_char ((key == 'S') ? 'c' : 'l'); /* `S' == `cc', `s' == `cl' */
1948:
1949: return (rl_vi_change_to (count, 'c'));
1950: }
1951:
1952: int
1953: rl_vi_overstrike (count, key)
1954: int count, key;
1955: {
1956: if (_rl_vi_doing_insert == 0)
1957: {
1958: _rl_vi_doing_insert = 1;
1959: rl_begin_undo_group ();
1960: }
1961:
1962: if (count > 0)
1963: {
1964: _rl_overwrite_char (count, key);
1965: vi_replace_count += count;
1966: }
1967:
1968: return (0);
1969: }
1970:
1971: int
1972: rl_vi_overstrike_delete (count, key)
1973: int count, key;
1974: {
1975: int i, s;
1976:
1977: for (i = 0; i < count; i++)
1978: {
1979: if (vi_replace_count == 0)
1980: {
1981: rl_ding ();
1982: break;
1983: }
1984: s = rl_point;
1985:
1986: if (rl_do_undo ())
1987: vi_replace_count--;
1988:
1989: if (rl_point == s)
1990: rl_backward_char (1, key);
1991: }
1992:
1993: if (vi_replace_count == 0 && _rl_vi_doing_insert)
1994: {
1995: rl_end_undo_group ();
1996: rl_do_undo ();
1997: _rl_vi_doing_insert = 0;
1998: }
1999: return (0);
2000: }
2001:
2002: int
2003: rl_vi_replace (count, key)
2004: int count, key;
2005: {
2006: int i;
2007:
2008: vi_replace_count = 0;
2009:
2010: if (vi_replace_map == 0)
2011: {
2012: vi_replace_map = rl_make_bare_keymap ();
2013:
2014: for (i = 0; i < ' '; i++)
2015: if (vi_insertion_keymap[i].type == ISFUNC)
2016: vi_replace_map[i].function = vi_insertion_keymap[i].function;
2017:
2018: for (i = ' '; i < KEYMAP_SIZE; i++)
2019: vi_replace_map[i].function = rl_vi_overstrike;
2020:
2021: vi_replace_map[RUBOUT].function = rl_vi_overstrike_delete;
2022:
2023: /* Make sure these are what we want. */
2024: vi_replace_map[ESC].function = rl_vi_movement_mode;
2025: vi_replace_map[RETURN].function = rl_newline;
2026: vi_replace_map[NEWLINE].function = rl_newline;
2027:
2028: /* If the normal vi insertion keymap has ^H bound to erase, do the
2029: same here. Probably should remove the assignment to RUBOUT up
2030: there, but I don't think it will make a difference in real life. */
2031: if (vi_insertion_keymap[CTRL ('H')].type == ISFUNC &&
2032: vi_insertion_keymap[CTRL ('H')].function == rl_rubout)
2033: vi_replace_map[CTRL ('H')].function = rl_vi_overstrike_delete;
2034:
2035: }
2036:
2037: rl_vi_start_inserting (key, 1, rl_arg_sign);
2038:
2039: _rl_vi_last_key_before_insert = key;
2040: _rl_keymap = vi_replace_map;
2041:
2042: return (0);
2043: }
2044:
2045: #if 0
2046: /* Try to complete the word we are standing on or the word that ends with
2047: the previous character. A space matches everything. Word delimiters are
2048: space and ;. */
2049: int
2050: rl_vi_possible_completions()
2051: {
2052: int save_pos = rl_point;
2053:
2054: if (rl_line_buffer[rl_point] != ' ' && rl_line_buffer[rl_point] != ';')
2055: {
2056: while (rl_point < rl_end && rl_line_buffer[rl_point] != ' ' &&
2057: rl_line_buffer[rl_point] != ';')
2058: rl_point++;
2059: }
2060: else if (rl_line_buffer[rl_point - 1] == ';')
2061: {
2062: rl_ding ();
2063: return (0);
2064: }
2065:
2066: rl_possible_completions ();
2067: rl_point = save_pos;
2068:
2069: return (0);
2070: }
2071: #endif
2072:
2073: /* Functions to save and restore marks. */
2074: static int
2075: _rl_vi_set_mark ()
2076: {
2077: int ch;
2078:
2079: RL_SETSTATE(RL_STATE_MOREINPUT);
2080: ch = rl_read_key ();
2081: RL_UNSETSTATE(RL_STATE_MOREINPUT);
2082:
2083: if (ch < 0 || ch < 'a' || ch > 'z') /* make test against 0 explicit */
2084: {
2085: rl_ding ();
2086: return -1;
2087: }
2088: ch -= 'a';
2089: vi_mark_chars[ch] = rl_point;
2090: return 0;
2091: }
2092:
2093: #if defined (READLINE_CALLBACKS)
2094: static int
2095: _rl_vi_callback_set_mark (data)
2096: _rl_callback_generic_arg *data;
2097: {
2098: _rl_callback_func = 0;
2099: _rl_want_redisplay = 1;
2100:
2101: return (_rl_vi_set_mark ());
2102: }
2103: #endif
2104:
2105: int
2106: rl_vi_set_mark (count, key)
2107: int count, key;
2108: {
2109: #if defined (READLINE_CALLBACKS)
2110: if (RL_ISSTATE (RL_STATE_CALLBACK))
2111: {
2112: _rl_callback_data = 0;
2113: _rl_callback_func = _rl_vi_callback_set_mark;
2114: return (0);
2115: }
2116: #endif
2117:
2118: return (_rl_vi_set_mark ());
2119: }
2120:
2121: static int
2122: _rl_vi_goto_mark ()
2123: {
2124: int ch;
2125:
2126: RL_SETSTATE(RL_STATE_MOREINPUT);
2127: ch = rl_read_key ();
2128: RL_UNSETSTATE(RL_STATE_MOREINPUT);
2129:
2130: if (ch == '`')
2131: {
2132: rl_point = rl_mark;
2133: return 0;
2134: }
2135: else if (ch < 0 || ch < 'a' || ch > 'z') /* make test against 0 explicit */
2136: {
2137: rl_ding ();
2138: return -1;
2139: }
2140:
2141: ch -= 'a';
2142: if (vi_mark_chars[ch] == -1)
2143: {
2144: rl_ding ();
2145: return -1;
2146: }
2147: rl_point = vi_mark_chars[ch];
2148: return 0;
2149: }
2150:
2151: #if defined (READLINE_CALLBACKS)
2152: static int
2153: _rl_vi_callback_goto_mark (data)
2154: _rl_callback_generic_arg *data;
2155: {
2156: _rl_callback_func = 0;
2157: _rl_want_redisplay = 1;
2158:
2159: return (_rl_vi_goto_mark ());
2160: }
2161: #endif
2162:
2163: int
2164: rl_vi_goto_mark (count, key)
2165: int count, key;
2166: {
2167: #if defined (READLINE_CALLBACKS)
2168: if (RL_ISSTATE (RL_STATE_CALLBACK))
2169: {
2170: _rl_callback_data = 0;
2171: _rl_callback_func = _rl_vi_callback_goto_mark;
2172: return (0);
2173: }
2174: #endif
2175:
2176: return (_rl_vi_goto_mark ());
2177: }
2178: #endif /* VI_MODE */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to vi_mode.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / readline