Annotation of embedaddon/readline/vi_mode.c, revision 1.1
1.1 ! misho 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