lib/libedit/src/vi.c

   1 /*      $NetBSD: vi.c,v 1.62 2016/05/09 21:46:56 christos Exp $ */
   2
   3 /*-
   4  * Copyright (c) 1992, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * This code is derived from software contributed to Berkeley by
   8  * Christos Zoulas of Cornell University.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 3. Neither the name of the University nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 #include "config.h"
  36 #if !defined(lint) && !defined(SCCSID)
  37 #if 0
  38 static char sccsid[] = "@(#)vi.c        8.1 (Berkeley) 6/4/93";
  39 #else
  40 __RCSID("$NetBSD: vi.c,v 1.62 2016/05/09 21:46:56 christos Exp $");
  41 #endif
  42 #endif /* not lint && not SCCSID */
  43
  44 /*
  45  * vi.c: Vi mode commands.
  46  */
  47 #include <sys/wait.h>
  48 #include <ctype.h>
  49 #include <limits.h>
  50 #include <stdlib.h>
  51 #include <string.h>
  52 #include <unistd.h>
  53
  54 #include "el.h"
  55 #include "common.h"
  56 #include "emacs.h"
  57 #include "fcns.h"
  58 #include "vi.h"
  59
  60 static el_action_t      cv_action(EditLine *, wint_t);
  61 static el_action_t      cv_paste(EditLine *, wint_t);
  62
  63 /* cv_action():
  64  *      Handle vi actions.
  65  */
  66 static el_action_t
  67 cv_action(EditLine *el, wint_t c)
  68 {
  69
  70         if (el->el_chared.c_vcmd.action != NOP) {
  71                 /* 'cc', 'dd' and (possibly) friends */
  72                 if (c != (wint_t)el->el_chared.c_vcmd.action)
  73                         return CC_ERROR;
  74
  75                 if (!(c & YANK))
  76                         cv_undo(el);
  77                 cv_yank(el, el->el_line.buffer,
  78                     (int)(el->el_line.lastchar - el->el_line.buffer));
  79                 el->el_chared.c_vcmd.action = NOP;
  80                 el->el_chared.c_vcmd.pos = 0;
  81                 if (!(c & YANK)) {
  82                         el->el_line.lastchar = el->el_line.buffer;
  83                         el->el_line.cursor = el->el_line.buffer;
  84                 }
  85                 if (c & INSERT)
  86                         el->el_map.current = el->el_map.key;
  87
  88                 return CC_REFRESH;
  89         }
  90         el->el_chared.c_vcmd.pos = el->el_line.cursor;
  91         el->el_chared.c_vcmd.action = c;
  92         return CC_ARGHACK;
  93 }
  94
  95 /* cv_paste():
  96  *      Paste previous deletion before or after the cursor
  97  */
  98 static el_action_t
  99 cv_paste(EditLine *el, wint_t c)
 100 {
 101         c_kill_t *k = &el->el_chared.c_kill;
 102         size_t len = (size_t)(k->last - k->buf);
 103
 104         if (k->buf == NULL || len == 0)
 105                 return CC_ERROR;
 106 #ifdef DEBUG_PASTE
 107         (void) fprintf(el->el_errfile, "Paste: \"%.*ls\"\n", (int)len,
 108             k->buf);
 109 #endif
 110
 111         cv_undo(el);
 112
 113         if (!c && el->el_line.cursor < el->el_line.lastchar)
 114                 el->el_line.cursor++;
 115
 116         c_insert(el, (int)len);
 117         if (el->el_line.cursor + len > el->el_line.lastchar)
 118                 return CC_ERROR;
 119         (void) memcpy(el->el_line.cursor, k->buf, len *
 120             sizeof(*el->el_line.cursor));
 121
 122         return CC_REFRESH;
 123 }
 124
 125
 126 /* vi_paste_next():
 127  *      Vi paste previous deletion to the right of the cursor
 128  *      [p]
 129  */
 130 libedit_private el_action_t
 131 /*ARGSUSED*/
 132 vi_paste_next(EditLine *el, wint_t c __attribute__((__unused__)))
 133 {
 134
 135         return cv_paste(el, 0);
 136 }
 137
 138
 139 /* vi_paste_prev():
 140  *      Vi paste previous deletion to the left of the cursor
 141  *      [P]
 142  */
 143 libedit_private el_action_t
 144 /*ARGSUSED*/
 145 vi_paste_prev(EditLine *el, wint_t c __attribute__((__unused__)))
 146 {
 147
 148         return cv_paste(el, 1);
 149 }
 150
 151
 152 /* vi_prev_big_word():
 153  *      Vi move to the previous space delimited word
 154  *      [B]
 155  */
 156 libedit_private el_action_t
 157 /*ARGSUSED*/
 158 vi_prev_big_word(EditLine *el, wint_t c __attribute__((__unused__)))
 159 {
 160
 161         if (el->el_line.cursor == el->el_line.buffer)
 162                 return CC_ERROR;
 163
 164         el->el_line.cursor = cv_prev_word(el->el_line.cursor,
 165             el->el_line.buffer,
 166             el->el_state.argument,
 167             cv__isWord);
 168
 169         if (el->el_chared.c_vcmd.action != NOP) {
 170                 cv_delfini(el);
 171                 return CC_REFRESH;
 172         }
 173         return CC_CURSOR;
 174 }
 175
 176
 177 /* vi_prev_word():
 178  *      Vi move to the previous word
 179  *      [b]
 180  */
 181 libedit_private el_action_t
 182 /*ARGSUSED*/
 183 vi_prev_word(EditLine *el, wint_t c __attribute__((__unused__)))
 184 {
 185
 186         if (el->el_line.cursor == el->el_line.buffer)
 187                 return CC_ERROR;
 188
 189         el->el_line.cursor = cv_prev_word(el->el_line.cursor,
 190             el->el_line.buffer,
 191             el->el_state.argument,
 192             cv__isword);
 193
 194         if (el->el_chared.c_vcmd.action != NOP) {
 195                 cv_delfini(el);
 196                 return CC_REFRESH;
 197         }
 198         return CC_CURSOR;
 199 }
 200
 201
 202 /* vi_next_big_word():
 203  *      Vi move to the next space delimited word
 204  *      [W]
 205  */
 206 libedit_private el_action_t
 207 /*ARGSUSED*/
 208 vi_next_big_word(EditLine *el, wint_t c __attribute__((__unused__)))
 209 {
 210
 211         if (el->el_line.cursor >= el->el_line.lastchar - 1)
 212                 return CC_ERROR;
 213
 214         el->el_line.cursor = cv_next_word(el, el->el_line.cursor,
 215             el->el_line.lastchar, el->el_state.argument, cv__isWord);
 216
 217         if (el->el_map.type == MAP_VI)
 218                 if (el->el_chared.c_vcmd.action != NOP) {
 219                         cv_delfini(el);
 220                         return CC_REFRESH;
 221                 }
 222         return CC_CURSOR;
 223 }
 224
 225
 226 /* vi_next_word():
 227  *      Vi move to the next word
 228  *      [w]
 229  */
 230 libedit_private el_action_t
 231 /*ARGSUSED*/
 232 vi_next_word(EditLine *el, wint_t c __attribute__((__unused__)))
 233 {
 234
 235         if (el->el_line.cursor >= el->el_line.lastchar - 1)
 236                 return CC_ERROR;
 237
 238         el->el_line.cursor = cv_next_word(el, el->el_line.cursor,
 239             el->el_line.lastchar, el->el_state.argument, cv__isword);
 240
 241         if (el->el_map.type == MAP_VI)
 242                 if (el->el_chared.c_vcmd.action != NOP) {
 243                         cv_delfini(el);
 244                         return CC_REFRESH;
 245                 }
 246         return CC_CURSOR;
 247 }
 248
 249
 250 /* vi_change_case():
 251  *      Vi change case of character under the cursor and advance one character
 252  *      [~]
 253  */
 254 libedit_private el_action_t
 255 vi_change_case(EditLine *el, wint_t c)
 256 {
 257         int i;
 258
 259         if (el->el_line.cursor >= el->el_line.lastchar)
 260                 return CC_ERROR;
 261         cv_undo(el);
 262         for (i = 0; i < el->el_state.argument; i++) {
 263
 264                 c = *el->el_line.cursor;
 265                 if (iswupper(c))
 266                         *el->el_line.cursor = towlower(c);
 267                 else if (iswlower(c))
 268                         *el->el_line.cursor = towupper(c);
 269
 270                 if (++el->el_line.cursor >= el->el_line.lastchar) {
 271                         el->el_line.cursor--;
 272                         re_fastaddc(el);
 273                         break;
 274                 }
 275                 re_fastaddc(el);
 276         }
 277         return CC_NORM;
 278 }
 279
 280
 281 /* vi_change_meta():
 282  *      Vi change prefix command
 283  *      [c]
 284  */
 285 libedit_private el_action_t
 286 /*ARGSUSED*/
 287 vi_change_meta(EditLine *el, wint_t c __attribute__((__unused__)))
 288 {
 289
 290         /*
 291          * Delete with insert == change: first we delete and then we leave in
 292          * insert mode.
 293          */
 294         return cv_action(el, DELETE | INSERT);
 295 }
 296
 297
 298 /* vi_insert_at_bol():
 299  *      Vi enter insert mode at the beginning of line
 300  *      [I]
 301  */
 302 libedit_private el_action_t
 303 /*ARGSUSED*/
 304 vi_insert_at_bol(EditLine *el, wint_t c __attribute__((__unused__)))
 305 {
 306
 307         el->el_line.cursor = el->el_line.buffer;
 308         cv_undo(el);
 309         el->el_map.current = el->el_map.key;
 310         return CC_CURSOR;
 311 }
 312
 313
 314 /* vi_replace_char():
 315  *      Vi replace character under the cursor with the next character typed
 316  *      [r]
 317  */
 318 libedit_private el_action_t
 319 /*ARGSUSED*/
 320 vi_replace_char(EditLine *el, wint_t c __attribute__((__unused__)))
 321 {
 322
 323         if (el->el_line.cursor >= el->el_line.lastchar)
 324                 return CC_ERROR;
 325
 326         el->el_map.current = el->el_map.key;
 327         el->el_state.inputmode = MODE_REPLACE_1;
 328         cv_undo(el);
 329         return CC_ARGHACK;
 330 }
 331
 332
 333 /* vi_replace_mode():
 334  *      Vi enter replace mode
 335  *      [R]
 336  */
 337 libedit_private el_action_t
 338 /*ARGSUSED*/
 339 vi_replace_mode(EditLine *el, wint_t c __attribute__((__unused__)))
 340 {
 341
 342         el->el_map.current = el->el_map.key;
 343         el->el_state.inputmode = MODE_REPLACE;
 344         cv_undo(el);
 345         return CC_NORM;
 346 }
 347
 348
 349 /* vi_substitute_char():
 350  *      Vi replace character under the cursor and enter insert mode
 351  *      [s]
 352  */
 353 libedit_private el_action_t
 354 /*ARGSUSED*/
 355 vi_substitute_char(EditLine *el, wint_t c __attribute__((__unused__)))
 356 {
 357
 358         c_delafter(el, el->el_state.argument);
 359         el->el_map.current = el->el_map.key;
 360         return CC_REFRESH;
 361 }
 362
 363
 364 /* vi_substitute_line():
 365  *      Vi substitute entire line
 366  *      [S]
 367  */
 368 libedit_private el_action_t
 369 /*ARGSUSED*/
 370 vi_substitute_line(EditLine *el, wint_t c __attribute__((__unused__)))
 371 {
 372
 373         cv_undo(el);
 374         cv_yank(el, el->el_line.buffer,
 375             (int)(el->el_line.lastchar - el->el_line.buffer));
 376         (void) em_kill_line(el, 0);
 377         el->el_map.current = el->el_map.key;
 378         return CC_REFRESH;
 379 }
 380
 381
 382 /* vi_change_to_eol():
 383  *      Vi change to end of line
 384  *      [C]
 385  */
 386 libedit_private el_action_t
 387 /*ARGSUSED*/
 388 vi_change_to_eol(EditLine *el, wint_t c __attribute__((__unused__)))
 389 {
 390
 391         cv_undo(el);
 392         cv_yank(el, el->el_line.cursor,
 393             (int)(el->el_line.lastchar - el->el_line.cursor));
 394         (void) ed_kill_line(el, 0);
 395         el->el_map.current = el->el_map.key;
 396         return CC_REFRESH;
 397 }
 398
 399
 400 /* vi_insert():
 401  *      Vi enter insert mode
 402  *      [i]
 403  */
 404 libedit_private el_action_t
 405 /*ARGSUSED*/
 406 vi_insert(EditLine *el, wint_t c __attribute__((__unused__)))
 407 {
 408
 409         el->el_map.current = el->el_map.key;
 410         cv_undo(el);
 411         return CC_NORM;
 412 }
 413
 414
 415 /* vi_add():
 416  *      Vi enter insert mode after the cursor
 417  *      [a]
 418  */
 419 libedit_private el_action_t
 420 /*ARGSUSED*/
 421 vi_add(EditLine *el, wint_t c __attribute__((__unused__)))
 422 {
 423         int ret;
 424
 425         el->el_map.current = el->el_map.key;
 426         if (el->el_line.cursor < el->el_line.lastchar) {
 427                 el->el_line.cursor++;
 428                 if (el->el_line.cursor > el->el_line.lastchar)
 429                         el->el_line.cursor = el->el_line.lastchar;
 430                 ret = CC_CURSOR;
 431         } else
 432                 ret = CC_NORM;
 433
 434         cv_undo(el);
 435
 436         return (el_action_t)ret;
 437 }
 438
 439
 440 /* vi_add_at_eol():
 441  *      Vi enter insert mode at end of line
 442  *      [A]
 443  */
 444 libedit_private el_action_t
 445 /*ARGSUSED*/
 446 vi_add_at_eol(EditLine *el, wint_t c __attribute__((__unused__)))
 447 {
 448
 449         el->el_map.current = el->el_map.key;
 450         el->el_line.cursor = el->el_line.lastchar;
 451         cv_undo(el);
 452         return CC_CURSOR;
 453 }
 454
 455
 456 /* vi_delete_meta():
 457  *      Vi delete prefix command
 458  *      [d]
 459  */
 460 libedit_private el_action_t
 461 /*ARGSUSED*/
 462 vi_delete_meta(EditLine *el, wint_t c __attribute__((__unused__)))
 463 {
 464
 465         return cv_action(el, DELETE);
 466 }
 467
 468
 469 /* vi_end_big_word():
 470  *      Vi move to the end of the current space delimited word
 471  *      [E]
 472  */
 473 libedit_private el_action_t
 474 /*ARGSUSED*/
 475 vi_end_big_word(EditLine *el, wint_t c __attribute__((__unused__)))
 476 {
 477
 478         if (el->el_line.cursor == el->el_line.lastchar)
 479                 return CC_ERROR;
 480
 481         el->el_line.cursor = cv__endword(el->el_line.cursor,
 482             el->el_line.lastchar, el->el_state.argument, cv__isWord);
 483
 484         if (el->el_chared.c_vcmd.action != NOP) {
 485                 el->el_line.cursor++;
 486                 cv_delfini(el);
 487                 return CC_REFRESH;
 488         }
 489         return CC_CURSOR;
 490 }
 491
 492
 493 /* vi_end_word():
 494  *      Vi move to the end of the current word
 495  *      [e]
 496  */
 497 libedit_private el_action_t
 498 /*ARGSUSED*/
 499 vi_end_word(EditLine *el, wint_t c __attribute__((__unused__)))
 500 {
 501
 502         if (el->el_line.cursor == el->el_line.lastchar)
 503                 return CC_ERROR;
 504
 505         el->el_line.cursor = cv__endword(el->el_line.cursor,
 506             el->el_line.lastchar, el->el_state.argument, cv__isword);
 507
 508         if (el->el_chared.c_vcmd.action != NOP) {
 509                 el->el_line.cursor++;
 510                 cv_delfini(el);
 511                 return CC_REFRESH;
 512         }
 513         return CC_CURSOR;
 514 }
 515
 516
 517 /* vi_undo():
 518  *      Vi undo last change
 519  *      [u]
 520  */
 521 libedit_private el_action_t
 522 /*ARGSUSED*/
 523 vi_undo(EditLine *el, wint_t c __attribute__((__unused__)))
 524 {
 525         c_undo_t un = el->el_chared.c_undo;
 526
 527         if (un.len == -1)
 528                 return CC_ERROR;
 529
 530         /* switch line buffer and undo buffer */
 531         el->el_chared.c_undo.buf = el->el_line.buffer;
 532         el->el_chared.c_undo.len = el->el_line.lastchar - el->el_line.buffer;
 533         el->el_chared.c_undo.cursor =
 534             (int)(el->el_line.cursor - el->el_line.buffer);
 535         el->el_line.limit = un.buf + (el->el_line.limit - el->el_line.buffer);
 536         el->el_line.buffer = un.buf;
 537         el->el_line.cursor = un.buf + un.cursor;
 538         el->el_line.lastchar = un.buf + un.len;
 539
 540         return CC_REFRESH;
 541 }
 542
 543
 544 /* vi_command_mode():
 545  *      Vi enter command mode (use alternative key bindings)
 546  *      [<ESC>]
 547  */
 548 libedit_private el_action_t
 549 /*ARGSUSED*/
 550 vi_command_mode(EditLine *el, wint_t c __attribute__((__unused__)))
 551 {
 552
 553         /* [Esc] cancels pending action */
 554         el->el_chared.c_vcmd.action = NOP;
 555         el->el_chared.c_vcmd.pos = 0;
 556
 557         el->el_state.doingarg = 0;
 558
 559         el->el_state.inputmode = MODE_INSERT;
 560         el->el_map.current = el->el_map.alt;
 561 #ifdef VI_MOVE
 562         if (el->el_line.cursor > el->el_line.buffer)
 563                 el->el_line.cursor--;
 564 #endif
 565         return CC_CURSOR;
 566 }
 567
 568
 569 /* vi_zero():
 570  *      Vi move to the beginning of line
 571  *      [0]
 572  */
 573 libedit_private el_action_t
 574 vi_zero(EditLine *el, wint_t c)
 575 {
 576
 577         if (el->el_state.doingarg)
 578                 return ed_argument_digit(el, c);
 579
 580         el->el_line.cursor = el->el_line.buffer;
 581         if (el->el_chared.c_vcmd.action != NOP) {
 582                 cv_delfini(el);
 583                 return CC_REFRESH;
 584         }
 585         return CC_CURSOR;
 586 }
 587
 588
 589 /* vi_delete_prev_char():
 590  *      Vi move to previous character (backspace)
 591  *      [^H] in insert mode only
 592  */
 593 libedit_private el_action_t
 594 /*ARGSUSED*/
 595 vi_delete_prev_char(EditLine *el, wint_t c __attribute__((__unused__)))
 596 {
 597
 598         if (el->el_line.cursor <= el->el_line.buffer)
 599                 return CC_ERROR;
 600
 601         c_delbefore1(el);
 602         el->el_line.cursor--;
 603         return CC_REFRESH;
 604 }
 605
 606
 607 /* vi_list_or_eof():
 608  *      Vi list choices for completion or indicate end of file if empty line
 609  *      [^D]
 610  */
 611 libedit_private el_action_t
 612 /*ARGSUSED*/
 613 vi_list_or_eof(EditLine *el, wint_t c)
 614 {
 615
 616         if (el->el_line.cursor == el->el_line.lastchar) {
 617                 if (el->el_line.cursor == el->el_line.buffer) {
 618                         terminal_writec(el, c); /* then do a EOF */
 619                         return CC_EOF;
 620                 } else {
 621                         /*
 622                          * Here we could list completions, but it is an
 623                          * error right now
 624                          */
 625                         terminal_beep(el);
 626                         return CC_ERROR;
 627                 }
 628         } else {
 629 #ifdef notyet
 630                 re_goto_bottom(el);
 631                 *el->el_line.lastchar = '\0';   /* just in case */
 632                 return CC_LIST_CHOICES;
 633 #else
 634                 /*
 635                  * Just complain for now.
 636                  */
 637                 terminal_beep(el);
 638                 return CC_ERROR;
 639 #endif
 640         }
 641 }
 642
 643
 644 /* vi_kill_line_prev():
 645  *      Vi cut from beginning of line to cursor
 646  *      [^U]
 647  */
 648 libedit_private el_action_t
 649 /*ARGSUSED*/
 650 vi_kill_line_prev(EditLine *el, wint_t c __attribute__((__unused__)))
 651 {
 652         wchar_t *kp, *cp;
 653
 654         cp = el->el_line.buffer;
 655         kp = el->el_chared.c_kill.buf;
 656         while (cp < el->el_line.cursor)
 657                 *kp++ = *cp++;  /* copy it */
 658         el->el_chared.c_kill.last = kp;
 659         c_delbefore(el, (int)(el->el_line.cursor - el->el_line.buffer));
 660         el->el_line.cursor = el->el_line.buffer;        /* zap! */
 661         return CC_REFRESH;
 662 }
 663
 664
 665 /* vi_search_prev():
 666  *      Vi search history previous
 667  *      [?]
 668  */
 669 libedit_private el_action_t
 670 /*ARGSUSED*/
 671 vi_search_prev(EditLine *el, wint_t c __attribute__((__unused__)))
 672 {
 673
 674         return cv_search(el, ED_SEARCH_PREV_HISTORY);
 675 }
 676
 677
 678 /* vi_search_next():
 679  *      Vi search history next
 680  *      [/]
 681  */
 682 libedit_private el_action_t
 683 /*ARGSUSED*/
 684 vi_search_next(EditLine *el, wint_t c __attribute__((__unused__)))
 685 {
 686
 687         return cv_search(el, ED_SEARCH_NEXT_HISTORY);
 688 }
 689
 690
 691 /* vi_repeat_search_next():
 692  *      Vi repeat current search in the same search direction
 693  *      [n]
 694  */
 695 libedit_private el_action_t
 696 /*ARGSUSED*/
 697 vi_repeat_search_next(EditLine *el, wint_t c __attribute__((__unused__)))
 698 {
 699
 700         if (el->el_search.patlen == 0)
 701                 return CC_ERROR;
 702         else
 703                 return cv_repeat_srch(el, el->el_search.patdir);
 704 }
 705
 706
 707 /* vi_repeat_search_prev():
 708  *      Vi repeat current search in the opposite search direction
 709  *      [N]
 710  */
 711 /*ARGSUSED*/
 712 libedit_private el_action_t
 713 vi_repeat_search_prev(EditLine *el, wint_t c __attribute__((__unused__)))
 714 {
 715
 716         if (el->el_search.patlen == 0)
 717                 return CC_ERROR;
 718         else
 719                 return (cv_repeat_srch(el,
 720                     el->el_search.patdir == ED_SEARCH_PREV_HISTORY ?
 721                     ED_SEARCH_NEXT_HISTORY : ED_SEARCH_PREV_HISTORY));
 722 }
 723
 724
 725 /* vi_next_char():
 726  *      Vi move to the character specified next
 727  *      [f]
 728  */
 729 libedit_private el_action_t
 730 /*ARGSUSED*/
 731 vi_next_char(EditLine *el, wint_t c __attribute__((__unused__)))
 732 {
 733         return cv_csearch(el, CHAR_FWD, -1, el->el_state.argument, 0);
 734 }
 735
 736
 737 /* vi_prev_char():
 738  *      Vi move to the character specified previous
 739  *      [F]
 740  */
 741 libedit_private el_action_t
 742 /*ARGSUSED*/
 743 vi_prev_char(EditLine *el, wint_t c __attribute__((__unused__)))
 744 {
 745         return cv_csearch(el, CHAR_BACK, -1, el->el_state.argument, 0);
 746 }
 747
 748
 749 /* vi_to_next_char():
 750  *      Vi move up to the character specified next
 751  *      [t]
 752  */
 753 libedit_private el_action_t
 754 /*ARGSUSED*/
 755 vi_to_next_char(EditLine *el, wint_t c __attribute__((__unused__)))
 756 {
 757         return cv_csearch(el, CHAR_FWD, -1, el->el_state.argument, 1);
 758 }
 759
 760
 761 /* vi_to_prev_char():
 762  *      Vi move up to the character specified previous
 763  *      [T]
 764  */
 765 libedit_private el_action_t
 766 /*ARGSUSED*/
 767 vi_to_prev_char(EditLine *el, wint_t c __attribute__((__unused__)))
 768 {
 769         return cv_csearch(el, CHAR_BACK, -1, el->el_state.argument, 1);
 770 }
 771
 772
 773 /* vi_repeat_next_char():
 774  *      Vi repeat current character search in the same search direction
 775  *      [;]
 776  */
 777 libedit_private el_action_t
 778 /*ARGSUSED*/
 779 vi_repeat_next_char(EditLine *el, wint_t c __attribute__((__unused__)))
 780 {
 781
 782         return cv_csearch(el, el->el_search.chadir, el->el_search.chacha,
 783                 el->el_state.argument, el->el_search.chatflg);
 784 }
 785
 786
 787 /* vi_repeat_prev_char():
 788  *      Vi repeat current character search in the opposite search direction
 789  *      [,]
 790  */
 791 libedit_private el_action_t
 792 /*ARGSUSED*/
 793 vi_repeat_prev_char(EditLine *el, wint_t c __attribute__((__unused__)))
 794 {
 795         el_action_t r;
 796         int dir = el->el_search.chadir;
 797
 798         r = cv_csearch(el, -dir, el->el_search.chacha,
 799                 el->el_state.argument, el->el_search.chatflg);
 800         el->el_search.chadir = dir;
 801         return r;
 802 }
 803
 804
 805 /* vi_match():
 806  *      Vi go to matching () {} or []
 807  *      [%]
 808  */
 809 libedit_private el_action_t
 810 /*ARGSUSED*/
 811 vi_match(EditLine *el, wint_t c __attribute__((__unused__)))
 812 {
 813         const wchar_t match_chars[] = L"()[]{}";
 814         wchar_t *cp;
 815         size_t delta, i, count;
 816         wchar_t o_ch, c_ch;
 817
 818         *el->el_line.lastchar = '\0';           /* just in case */
 819
 820         i = wcscspn(el->el_line.cursor, match_chars);
 821         o_ch = el->el_line.cursor[i];
 822         if (o_ch == 0)
 823                 return CC_ERROR;
 824         delta = (size_t)(wcschr(match_chars, o_ch) - match_chars);
 825         c_ch = match_chars[delta ^ 1];
 826         count = 1;
 827         delta = 1 - (delta & 1) * 2;
 828
 829         for (cp = &el->el_line.cursor[i]; count; ) {
 830                 cp += delta;
 831                 if (cp < el->el_line.buffer || cp >= el->el_line.lastchar)
 832                         return CC_ERROR;
 833                 if (*cp == o_ch)
 834                         count++;
 835                 else if (*cp == c_ch)
 836                         count--;
 837         }
 838
 839         el->el_line.cursor = cp;
 840
 841         if (el->el_chared.c_vcmd.action != NOP) {
 842                 /* NB posix says char under cursor should NOT be deleted
 843                    for -ve delta - this is different to netbsd vi. */
 844                 if (delta > 0)
 845                         el->el_line.cursor++;
 846                 cv_delfini(el);
 847                 return CC_REFRESH;
 848         }
 849         return CC_CURSOR;
 850 }
 851
 852 /* vi_undo_line():
 853  *      Vi undo all changes to line
 854  *      [U]
 855  */
 856 libedit_private el_action_t
 857 /*ARGSUSED*/
 858 vi_undo_line(EditLine *el, wint_t c __attribute__((__unused__)))
 859 {
 860
 861         cv_undo(el);
 862         return hist_get(el);
 863 }
 864
 865 /* vi_to_column():
 866  *      Vi go to specified column
 867  *      [|]
 868  * NB netbsd vi goes to screen column 'n', posix says nth character
 869  */
 870 libedit_private el_action_t
 871 /*ARGSUSED*/
 872 vi_to_column(EditLine *el, wint_t c __attribute__((__unused__)))
 873 {
 874
 875         el->el_line.cursor = el->el_line.buffer;
 876         el->el_state.argument--;
 877         return ed_next_char(el, 0);
 878 }
 879
 880 /* vi_yank_end():
 881  *      Vi yank to end of line
 882  *      [Y]
 883  */
 884 libedit_private el_action_t
 885 /*ARGSUSED*/
 886 vi_yank_end(EditLine *el, wint_t c __attribute__((__unused__)))
 887 {
 888
 889         cv_yank(el, el->el_line.cursor,
 890             (int)(el->el_line.lastchar - el->el_line.cursor));
 891         return CC_REFRESH;
 892 }
 893
 894 /* vi_yank():
 895  *      Vi yank
 896  *      [y]
 897  */
 898 libedit_private el_action_t
 899 /*ARGSUSED*/
 900 vi_yank(EditLine *el, wint_t c __attribute__((__unused__)))
 901 {
 902
 903         return cv_action(el, YANK);
 904 }
 905
 906 /* vi_comment_out():
 907  *      Vi comment out current command
 908  *      [#]
 909  */
 910 libedit_private el_action_t
 911 /*ARGSUSED*/
 912 vi_comment_out(EditLine *el, wint_t c __attribute__((__unused__)))
 913 {
 914
 915         el->el_line.cursor = el->el_line.buffer;
 916         c_insert(el, 1);
 917         *el->el_line.cursor = '#';
 918         re_refresh(el);
 919         return ed_newline(el, 0);
 920 }
 921
 922 /* vi_alias():
 923  *      Vi include shell alias
 924  *      [@]
 925  * NB: posix implies that we should enter insert mode, however
 926  * this is against historical precedent...
 927  */
 928 libedit_private el_action_t
 929 /*ARGSUSED*/
 930 vi_alias(EditLine *el, wint_t c __attribute__((__unused__)))
 931 {
 932         char alias_name[3];
 933         const char *alias_text;
 934
 935         if (el->el_chared.c_aliasfun == NULL)
 936                 return CC_ERROR;
 937
 938         alias_name[0] = '_';
 939         alias_name[2] = 0;
 940         if (el_getc(el, &alias_name[1]) != 1)
 941                 return CC_ERROR;
 942
 943         alias_text = (*el->el_chared.c_aliasfun)(el->el_chared.c_aliasarg,
 944             alias_name);
 945         if (alias_text != NULL)
 946                 el_wpush(el, ct_decode_string(alias_text, &el->el_scratch));
 947         return CC_NORM;
 948 }
 949
 950 /* vi_to_history_line():
 951  *      Vi go to specified history file line.
 952  *      [G]
 953  */
 954 libedit_private el_action_t
 955 /*ARGSUSED*/
 956 vi_to_history_line(EditLine *el, wint_t c __attribute__((__unused__)))
 957 {
 958         int sv_event_no = el->el_history.eventno;
 959         el_action_t rval;
 960
 961
 962         if (el->el_history.eventno == 0) {
 963                  (void) wcsncpy(el->el_history.buf, el->el_line.buffer,
 964                      EL_BUFSIZ);
 965                  el->el_history.last = el->el_history.buf +
 966                          (el->el_line.lastchar - el->el_line.buffer);
 967         }
 968
 969         /* Lack of a 'count' means oldest, not 1 */
 970         if (!el->el_state.doingarg) {
 971                 el->el_history.eventno = 0x7fffffff;
 972                 hist_get(el);
 973         } else {
 974                 /* This is brain dead, all the rest of this code counts
 975                  * upwards going into the past.  Here we need count in the
 976                  * other direction (to match the output of fc -l).
 977                  * I could change the world, but this seems to suffice.
 978                  */
 979                 el->el_history.eventno = 1;
 980                 if (hist_get(el) == CC_ERROR)
 981                         return CC_ERROR;
 982                 el->el_history.eventno = 1 + el->el_history.ev.num
 983                                         - el->el_state.argument;
 984                 if (el->el_history.eventno < 0) {
 985                         el->el_history.eventno = sv_event_no;
 986                         return CC_ERROR;
 987                 }
 988         }
 989         rval = hist_get(el);
 990         if (rval == CC_ERROR)
 991                 el->el_history.eventno = sv_event_no;
 992         return rval;
 993 }
 994
 995 /* vi_histedit():
 996  *      Vi edit history line with vi
 997  *      [v]
 998  */
 999 libedit_private el_action_t
1000 /*ARGSUSED*/
1001 vi_histedit(EditLine *el, wint_t c __attribute__((__unused__)))
1002 {
1003         int fd;
1004         pid_t pid;
1005         ssize_t st;
1006         int status;
1007         char tempfile[] = "/tmp/histedit.XXXXXXXXXX";
1008         char *cp = NULL;
1009         size_t len;
1010         wchar_t *line = NULL;
1011
1012         if (el->el_state.doingarg) {
1013                 if (vi_to_history_line(el, 0) == CC_ERROR)
1014                         return CC_ERROR;
1015         }
1016
1017         fd = mkstemp(tempfile);
1018         if (fd < 0)
1019                 return CC_ERROR;
1020         len = (size_t)(el->el_line.lastchar - el->el_line.buffer);
1021 #define TMP_BUFSIZ (EL_BUFSIZ * MB_LEN_MAX)
1022         cp = el_malloc(TMP_BUFSIZ * sizeof(*cp));
1023         if (cp == NULL)
1024                 goto error;
1025         line = el_malloc(len * sizeof(*line) + 1);
1026         if (line == NULL)
1027                 goto error;
1028         wcsncpy(line, el->el_line.buffer, len);
1029         line[len] = '\0';
1030         wcstombs(cp, line, TMP_BUFSIZ - 1);
1031         cp[TMP_BUFSIZ - 1] = '\0';
1032         len = strlen(cp);
1033         write(fd, cp, len);
1034         write(fd, "\n", (size_t)1);
1035         pid = fork();
1036         switch (pid) {
1037         case -1:
1038                 goto error;
1039         case 0:
1040                 close(fd);
1041                 execlp("vi", "vi", tempfile, (char *)NULL);
1042                 exit(0);
1043                 /*NOTREACHED*/
1044         default:
1045                 while (waitpid(pid, &status, 0) != pid)
1046                         continue;
1047                 lseek(fd, (off_t)0, SEEK_SET);
1048                 st = read(fd, cp, TMP_BUFSIZ - 1);
1049                 if (st > 0) {
1050                         cp[st] = '\0';
1051                         len = (size_t)(el->el_line.limit - el->el_line.buffer);
1052                         len = mbstowcs(el->el_line.buffer, cp, len);
1053                         if (len > 0 && el->el_line.buffer[len - 1] == '\n')
1054                                 --len;
1055                 }
1056                 else
1057                         len = 0;
1058                 el->el_line.cursor = el->el_line.buffer;
1059                 el->el_line.lastchar = el->el_line.buffer + len;
1060                 el_free(cp);
1061                 el_free(line);
1062                 break;
1063         }
1064
1065         close(fd);
1066         unlink(tempfile);
1067         /* return CC_REFRESH; */
1068         return ed_newline(el, 0);
1069 error:
1070         el_free(line);
1071         el_free(cp);
1072         close(fd);
1073         unlink(tempfile);
1074         return CC_ERROR;
1075 }
1076
1077 /* vi_history_word():
1078  *      Vi append word from previous input line
1079  *      [_]
1080  * Who knows where this one came from!
1081  * '_' in vi means 'entire current line', so 'cc' is a synonym for 'c_'
1082  */
1083 libedit_private el_action_t
1084 /*ARGSUSED*/
1085 vi_history_word(EditLine *el, wint_t c __attribute__((__unused__)))
1086 {
1087         const wchar_t *wp = HIST_FIRST(el);
1088         const wchar_t *wep, *wsp;
1089         int len;
1090         wchar_t *cp;
1091         const wchar_t *lim;
1092
1093         if (wp == NULL)
1094                 return CC_ERROR;
1095
1096         wep = wsp = NULL;
1097         do {
1098                 while (iswspace(*wp))
1099                         wp++;
1100                 if (*wp == 0)
1101                         break;
1102                 wsp = wp;
1103                 while (*wp && !iswspace(*wp))
1104                         wp++;
1105                 wep = wp;
1106         } while ((!el->el_state.doingarg || --el->el_state.argument > 0)
1107             && *wp != 0);
1108
1109         if (wsp == NULL || (el->el_state.doingarg && el->el_state.argument != 0))
1110                 return CC_ERROR;
1111
1112         cv_undo(el);
1113         len = (int)(wep - wsp);
1114         if (el->el_line.cursor < el->el_line.lastchar)
1115                 el->el_line.cursor++;
1116         c_insert(el, len + 1);
1117         cp = el->el_line.cursor;
1118         lim = el->el_line.limit;
1119         if (cp < lim)
1120                 *cp++ = ' ';
1121         while (wsp < wep && cp < lim)
1122                 *cp++ = *wsp++;
1123         el->el_line.cursor = cp;
1124
1125         el->el_map.current = el->el_map.key;
1126         return CC_REFRESH;
1127 }
1128
1129 /* vi_redo():
1130  *      Vi redo last non-motion command
1131  *      [.]
1132  */
1133 libedit_private el_action_t
1134 /*ARGSUSED*/
1135 vi_redo(EditLine *el, wint_t c __attribute__((__unused__)))
1136 {
1137         c_redo_t *r = &el->el_chared.c_redo;
1138
1139         if (!el->el_state.doingarg && r->count) {
1140                 el->el_state.doingarg = 1;
1141                 el->el_state.argument = r->count;
1142         }
1143
1144         el->el_chared.c_vcmd.pos = el->el_line.cursor;
1145         el->el_chared.c_vcmd.action = r->action;
1146         if (r->pos != r->buf) {
1147                 if (r->pos + 1 > r->lim)
1148                         /* sanity */
1149                         r->pos = r->lim - 1;
1150                 r->pos[0] = 0;
1151                 el_wpush(el, r->buf);
1152         }
1153
1154         el->el_state.thiscmd = r->cmd;
1155         el->el_state.thisch = r->ch;
1156         return (*el->el_map.func[r->cmd])(el, r->ch);
1157 }