1 /* vi:set ts=8 sts=4 sw=4: 2 * 3 * VIM - Vi IMproved by Bram Moolenaar 4 * 5 * Do ":help uganda" in Vim to read copying and usage conditions. 6 * Do ":help credits" in Vim to see a list of people who contributed. 7 * See README.txt for an overview of the Vim source code. 8 */ 9 10 /* 11 * getchar.c 12 * 13 * functions related with getting a character from the user/mapping/redo/... 14 * 15 * manipulations with redo buffer and stuff buffer 16 * mappings and abbreviations 17 */ 18 19 #include "vim.h" 20 21 /* 22 * These buffers are used for storing: 23 * - stuffed characters: A command that is translated into another command. 24 * - redo characters: will redo the last change. 25 * - recorded characters: for the "q" command. 26 * 27 * The bytes are stored like in the typeahead buffer: 28 * - K_SPECIAL introduces a special key (two more bytes follow). A literal 29 * K_SPECIAL is stored as K_SPECIAL KS_SPECIAL KE_FILLER. 30 * - CSI introduces a GUI termcap code (also when gui.in_use is FALSE, 31 * otherwise switching the GUI on would make mappings invalid). 32 * A literal CSI is stored as CSI KS_EXTRA KE_CSI. 33 * These translations are also done on multi-byte characters! 34 * 35 * Escaping CSI bytes is done by the system-specific input functions, called 36 * by ui_inchar(). 37 * Escaping K_SPECIAL is done by inchar(). 38 * Un-escaping is done by vgetc(). 39 */ 40 41 #define MINIMAL_SIZE 20 /* minimal size for b_str */ 42 43 static buffheader_T redobuff = {{NULL, {NUL}}, NULL, 0, 0}; 44 static buffheader_T old_redobuff = {{NULL, {NUL}}, NULL, 0, 0}; 45 #if defined(FEAT_AUTOCMD) || defined(FEAT_EVAL) || defined(PROTO) 46 static buffheader_T save_redobuff = {{NULL, {NUL}}, NULL, 0, 0}; 47 static buffheader_T save_old_redobuff = {{NULL, {NUL}}, NULL, 0, 0}; 48 #endif 49 static buffheader_T recordbuff = {{NULL, {NUL}}, NULL, 0, 0}; 50 51 static int typeahead_char = 0; /* typeahead char that's not flushed */ 52 53 /* 54 * when block_redo is TRUE redo buffer will not be changed 55 * used by edit() to repeat insertions and 'V' command for redoing 56 */ 57 static int block_redo = FALSE; 58 59 /* 60 * Make a hash value for a mapping. 61 * "mode" is the lower 4 bits of the State for the mapping. 62 * "c1" is the first character of the "lhs". 63 * Returns a value between 0 and 255, index in maphash. 64 * Put Normal/Visual mode mappings mostly separately from Insert/Cmdline mode. 65 */ 66 #define MAP_HASH(mode, c1) (((mode) & (NORMAL + VISUAL + SELECTMODE + OP_PENDING)) ? (c1) : ((c1) ^ 0x80)) 67 68 /* 69 * Each mapping is put in one of the 256 hash lists, to speed up finding it. 70 */ 71 static mapblock_T *(maphash[256]); 72 static int maphash_valid = FALSE; 73 74 /* 75 * List used for abbreviations. 76 */ 77 static mapblock_T *first_abbr = NULL; /* first entry in abbrlist */ 78 79 static int KeyNoremap = 0; /* remapping flags */ 80 81 /* 82 * variables used by vgetorpeek() and flush_buffers() 83 * 84 * typebuf.tb_buf[] contains all characters that are not consumed yet. 85 * typebuf.tb_buf[typebuf.tb_off] is the first valid character. 86 * typebuf.tb_buf[typebuf.tb_off + typebuf.tb_len - 1] is the last valid char. 87 * typebuf.tb_buf[typebuf.tb_off + typebuf.tb_len] must be NUL. 88 * The head of the buffer may contain the result of mappings, abbreviations 89 * and @a commands. The length of this part is typebuf.tb_maplen. 90 * typebuf.tb_silent is the part where <silent> applies. 91 * After the head are characters that come from the terminal. 92 * typebuf.tb_no_abbr_cnt is the number of characters in typebuf.tb_buf that 93 * should not be considered for abbreviations. 94 * Some parts of typebuf.tb_buf may not be mapped. These parts are remembered 95 * in typebuf.tb_noremap[], which is the same length as typebuf.tb_buf and 96 * contains RM_NONE for the characters that are not to be remapped. 97 * typebuf.tb_noremap[typebuf.tb_off] is the first valid flag. 98 * (typebuf has been put in globals.h, because check_termcode() needs it). 99 */ 100 #define RM_YES 0 /* tb_noremap: remap */ 101 #define RM_NONE 1 /* tb_noremap: don't remap */ 102 #define RM_SCRIPT 2 /* tb_noremap: remap local script mappings */ 103 #define RM_ABBR 4 /* tb_noremap: don't remap, do abbrev. */ 104 105 /* typebuf.tb_buf has three parts: room in front (for result of mappings), the 106 * middle for typeahead and room for new characters (which needs to be 3 * 107 * MAXMAPLEN) for the Amiga). 108 */ 109 #define TYPELEN_INIT (5 * (MAXMAPLEN + 3)) 110 static char_u typebuf_init[TYPELEN_INIT]; /* initial typebuf.tb_buf */ 111 static char_u noremapbuf_init[TYPELEN_INIT]; /* initial typebuf.tb_noremap */ 112 113 static int last_recorded_len = 0; /* number of last recorded chars */ 114 115 static char_u *get_buffcont(buffheader_T *, int); 116 static void add_buff(buffheader_T *, char_u *, long n); 117 static void add_num_buff(buffheader_T *, long); 118 static void add_char_buff(buffheader_T *, int); 119 static int read_readbuffers(int advance); 120 static int read_readbuf(buffheader_T *buf, int advance); 121 static void start_stuff(void); 122 static int read_redo(int, int); 123 static void copy_redo(int); 124 static void init_typebuf(void); 125 static void gotchars(char_u *, int); 126 static void may_sync_undo(void); 127 static void closescript(void); 128 static int vgetorpeek(int); 129 static void map_free(mapblock_T **); 130 static void validate_maphash(void); 131 static void showmap(mapblock_T *mp, int local); 132 #ifdef FEAT_EVAL 133 static char_u *eval_map_expr(char_u *str, int c); 134 #endif 135 136 /* 137 * Free and clear a buffer. 138 */ 139 void 140 free_buff(buffheader_T *buf) 141 { 142 buffblock_T *p, *np; 143 144 for (p = buf->bh_first.b_next; p != NULL; p = np) 145 { 146 np = p->b_next; 147 vim_free(p); 148 } 149 buf->bh_first.b_next = NULL; 150 } 151 152 /* 153 * Return the contents of a buffer as a single string. 154 * K_SPECIAL and CSI in the returned string are escaped. 155 */ 156 static char_u * 157 get_buffcont( 158 buffheader_T *buffer, 159 int dozero) /* count == zero is not an error */ 160 { 161 long_u count = 0; 162 char_u *p = NULL; 163 char_u *p2; 164 char_u *str; 165 buffblock_T *bp; 166 167 /* compute the total length of the string */ 168 for (bp = buffer->bh_first.b_next; bp != NULL; bp = bp->b_next) 169 count += (long_u)STRLEN(bp->b_str); 170 171 if ((count || dozero) && (p = lalloc(count + 1, TRUE)) != NULL) 172 { 173 p2 = p; 174 for (bp = buffer->bh_first.b_next; bp != NULL; bp = bp->b_next) 175 for (str = bp->b_str; *str; ) 176 *p2++ = *str++; 177 *p2 = NUL; 178 } 179 return (p); 180 } 181 182 /* 183 * Return the contents of the record buffer as a single string 184 * and clear the record buffer. 185 * K_SPECIAL and CSI in the returned string are escaped. 186 */ 187 char_u * 188 get_recorded(void) 189 { 190 char_u *p; 191 size_t len; 192 193 p = get_buffcont(&recordbuff, TRUE); 194 free_buff(&recordbuff); 195 196 /* 197 * Remove the characters that were added the last time, these must be the 198 * (possibly mapped) characters that stopped the recording. 199 */ 200 len = STRLEN(p); 201 if ((int)len >= last_recorded_len) 202 { 203 len -= last_recorded_len; 204 p[len] = NUL; 205 } 206 207 /* 208 * When stopping recording from Insert mode with CTRL-O q, also remove the 209 * CTRL-O. 210 */ 211 if (len > 0 && restart_edit != 0 && p[len - 1] == Ctrl_O) 212 p[len - 1] = NUL; 213 214 return (p); 215 } 216 217 /* 218 * Return the contents of the redo buffer as a single string. 219 * K_SPECIAL and CSI in the returned string are escaped. 220 */ 221 char_u * 222 get_inserted(void) 223 { 224 return get_buffcont(&redobuff, FALSE); 225 } 226 227 /* 228 * Add string "s" after the current block of buffer "buf". 229 * K_SPECIAL and CSI should have been escaped already. 230 */ 231 static void 232 add_buff( 233 buffheader_T *buf, 234 char_u *s, 235 long slen) /* length of "s" or -1 */ 236 { 237 buffblock_T *p; 238 long_u len; 239 240 if (slen < 0) 241 slen = (long)STRLEN(s); 242 if (slen == 0) /* don't add empty strings */ 243 return; 244 245 if (buf->bh_first.b_next == NULL) /* first add to list */ 246 { 247 buf->bh_space = 0; 248 buf->bh_curr = &(buf->bh_first); 249 } 250 else if (buf->bh_curr == NULL) /* buffer has already been read */ 251 { 252 EMSG(_("E222: Add to read buffer")); 253 return; 254 } 255 else if (buf->bh_index != 0) 256 mch_memmove(buf->bh_first.b_next->b_str, 257 buf->bh_first.b_next->b_str + buf->bh_index, 258 STRLEN(buf->bh_first.b_next->b_str + buf->bh_index) + 1); 259 buf->bh_index = 0; 260 261 if (buf->bh_space >= (int)slen) 262 { 263 len = (long_u)STRLEN(buf->bh_curr->b_str); 264 vim_strncpy(buf->bh_curr->b_str + len, s, (size_t)slen); 265 buf->bh_space -= slen; 266 } 267 else 268 { 269 if (slen < MINIMAL_SIZE) 270 len = MINIMAL_SIZE; 271 else 272 len = slen; 273 p = (buffblock_T *)lalloc((long_u)(sizeof(buffblock_T) + len), 274 TRUE); 275 if (p == NULL) 276 return; /* no space, just forget it */ 277 buf->bh_space = (int)(len - slen); 278 vim_strncpy(p->b_str, s, (size_t)slen); 279 280 p->b_next = buf->bh_curr->b_next; 281 buf->bh_curr->b_next = p; 282 buf->bh_curr = p; 283 } 284 return; 285 } 286 287 /* 288 * Add number "n" to buffer "buf". 289 */ 290 static void 291 add_num_buff(buffheader_T *buf, long n) 292 { 293 char_u number[32]; 294 295 sprintf((char *)number, "%ld", n); 296 add_buff(buf, number, -1L); 297 } 298 299 /* 300 * Add character 'c' to buffer "buf". 301 * Translates special keys, NUL, CSI, K_SPECIAL and multibyte characters. 302 */ 303 static void 304 add_char_buff(buffheader_T *buf, int c) 305 { 306 #ifdef FEAT_MBYTE 307 char_u bytes[MB_MAXBYTES + 1]; 308 int len; 309 int i; 310 #endif 311 char_u temp[4]; 312 313 #ifdef FEAT_MBYTE 314 if (IS_SPECIAL(c)) 315 len = 1; 316 else 317 len = (*mb_char2bytes)(c, bytes); 318 for (i = 0; i < len; ++i) 319 { 320 if (!IS_SPECIAL(c)) 321 c = bytes[i]; 322 #endif 323 324 if (IS_SPECIAL(c) || c == K_SPECIAL || c == NUL) 325 { 326 /* translate special key code into three byte sequence */ 327 temp[0] = K_SPECIAL; 328 temp[1] = K_SECOND(c); 329 temp[2] = K_THIRD(c); 330 temp[3] = NUL; 331 } 332 #ifdef FEAT_GUI 333 else if (c == CSI) 334 { 335 /* Translate a CSI to a CSI - KS_EXTRA - KE_CSI sequence */ 336 temp[0] = CSI; 337 temp[1] = KS_EXTRA; 338 temp[2] = (int)KE_CSI; 339 temp[3] = NUL; 340 } 341 #endif 342 else 343 { 344 temp[0] = c; 345 temp[1] = NUL; 346 } 347 add_buff(buf, temp, -1L); 348 #ifdef FEAT_MBYTE 349 } 350 #endif 351 } 352 353 /* First read ahead buffer. Used for translated commands. */ 354 static buffheader_T readbuf1 = {{NULL, {NUL}}, NULL, 0, 0}; 355 356 /* Second read ahead buffer. Used for redo. */ 357 static buffheader_T readbuf2 = {{NULL, {NUL}}, NULL, 0, 0}; 358 359 /* 360 * Get one byte from the read buffers. Use readbuf1 one first, use readbuf2 361 * if that one is empty. 362 * If advance == TRUE go to the next char. 363 * No translation is done K_SPECIAL and CSI are escaped. 364 */ 365 static int 366 read_readbuffers(int advance) 367 { 368 int c; 369 370 c = read_readbuf(&readbuf1, advance); 371 if (c == NUL) 372 c = read_readbuf(&readbuf2, advance); 373 return c; 374 } 375 376 static int 377 read_readbuf(buffheader_T *buf, int advance) 378 { 379 char_u c; 380 buffblock_T *curr; 381 382 if (buf->bh_first.b_next == NULL) /* buffer is empty */ 383 return NUL; 384 385 curr = buf->bh_first.b_next; 386 c = curr->b_str[buf->bh_index]; 387 388 if (advance) 389 { 390 if (curr->b_str[++buf->bh_index] == NUL) 391 { 392 buf->bh_first.b_next = curr->b_next; 393 vim_free(curr); 394 buf->bh_index = 0; 395 } 396 } 397 return c; 398 } 399 400 /* 401 * Prepare the read buffers for reading (if they contain something). 402 */ 403 static void 404 start_stuff(void) 405 { 406 if (readbuf1.bh_first.b_next != NULL) 407 { 408 readbuf1.bh_curr = &(readbuf1.bh_first); 409 readbuf1.bh_space = 0; 410 } 411 if (readbuf2.bh_first.b_next != NULL) 412 { 413 readbuf2.bh_curr = &(readbuf2.bh_first); 414 readbuf2.bh_space = 0; 415 } 416 } 417 418 /* 419 * Return TRUE if the stuff buffer is empty. 420 */ 421 int 422 stuff_empty(void) 423 { 424 return (readbuf1.bh_first.b_next == NULL 425 && readbuf2.bh_first.b_next == NULL); 426 } 427 428 /* 429 * Return TRUE if readbuf1 is empty. There may still be redo characters in 430 * redbuf2. 431 */ 432 int 433 readbuf1_empty(void) 434 { 435 return (readbuf1.bh_first.b_next == NULL); 436 } 437 438 /* 439 * Set a typeahead character that won't be flushed. 440 */ 441 void 442 typeahead_noflush(int c) 443 { 444 typeahead_char = c; 445 } 446 447 /* 448 * Remove the contents of the stuff buffer and the mapped characters in the 449 * typeahead buffer (used in case of an error). If "flush_typeahead" is true, 450 * flush all typeahead characters (used when interrupted by a CTRL-C). 451 */ 452 void 453 flush_buffers(int flush_typeahead) 454 { 455 init_typebuf(); 456 457 start_stuff(); 458 while (read_readbuffers(TRUE) != NUL) 459 ; 460 461 if (flush_typeahead) /* remove all typeahead */ 462 { 463 /* 464 * We have to get all characters, because we may delete the first part 465 * of an escape sequence. 466 * In an xterm we get one char at a time and we have to get them all. 467 */ 468 while (inchar(typebuf.tb_buf, typebuf.tb_buflen - 1, 10L, 469 typebuf.tb_change_cnt) != 0) 470 ; 471 typebuf.tb_off = MAXMAPLEN; 472 typebuf.tb_len = 0; 473 } 474 else /* remove mapped characters at the start only */ 475 { 476 typebuf.tb_off += typebuf.tb_maplen; 477 typebuf.tb_len -= typebuf.tb_maplen; 478 } 479 typebuf.tb_maplen = 0; 480 typebuf.tb_silent = 0; 481 cmd_silent = FALSE; 482 typebuf.tb_no_abbr_cnt = 0; 483 } 484 485 /* 486 * The previous contents of the redo buffer is kept in old_redobuffer. 487 * This is used for the CTRL-O <.> command in insert mode. 488 */ 489 void 490 ResetRedobuff(void) 491 { 492 if (!block_redo) 493 { 494 free_buff(&old_redobuff); 495 old_redobuff = redobuff; 496 redobuff.bh_first.b_next = NULL; 497 } 498 } 499 500 /* 501 * Discard the contents of the redo buffer and restore the previous redo 502 * buffer. 503 */ 504 void 505 CancelRedo(void) 506 { 507 if (!block_redo) 508 { 509 free_buff(&redobuff); 510 redobuff = old_redobuff; 511 old_redobuff.bh_first.b_next = NULL; 512 start_stuff(); 513 while (read_readbuffers(TRUE) != NUL) 514 ; 515 } 516 } 517 518 #if defined(FEAT_AUTOCMD) || defined(FEAT_EVAL) || defined(PROTO) 519 /* 520 * Save redobuff and old_redobuff to save_redobuff and save_old_redobuff. 521 * Used before executing autocommands and user functions. 522 */ 523 static int save_level = 0; 524 525 void 526 saveRedobuff(void) 527 { 528 char_u *s; 529 530 if (save_level++ == 0) 531 { 532 save_redobuff = redobuff; 533 redobuff.bh_first.b_next = NULL; 534 save_old_redobuff = old_redobuff; 535 old_redobuff.bh_first.b_next = NULL; 536 537 /* Make a copy, so that ":normal ." in a function works. */ 538 s = get_buffcont(&save_redobuff, FALSE); 539 if (s != NULL) 540 { 541 add_buff(&redobuff, s, -1L); 542 vim_free(s); 543 } 544 } 545 } 546 547 /* 548 * Restore redobuff and old_redobuff from save_redobuff and save_old_redobuff. 549 * Used after executing autocommands and user functions. 550 */ 551 void 552 restoreRedobuff(void) 553 { 554 if (--save_level == 0) 555 { 556 free_buff(&redobuff); 557 redobuff = save_redobuff; 558 free_buff(&old_redobuff); 559 old_redobuff = save_old_redobuff; 560 } 561 } 562 #endif 563 564 /* 565 * Append "s" to the redo buffer. 566 * K_SPECIAL and CSI should already have been escaped. 567 */ 568 void 569 AppendToRedobuff(char_u *s) 570 { 571 if (!block_redo) 572 add_buff(&redobuff, s, -1L); 573 } 574 575 /* 576 * Append to Redo buffer literally, escaping special characters with CTRL-V. 577 * K_SPECIAL and CSI are escaped as well. 578 */ 579 void 580 AppendToRedobuffLit( 581 char_u *str, 582 int len) /* length of "str" or -1 for up to the NUL */ 583 { 584 char_u *s = str; 585 int c; 586 char_u *start; 587 588 if (block_redo) 589 return; 590 591 while (len < 0 ? *s != NUL : s - str < len) 592 { 593 /* Put a string of normal characters in the redo buffer (that's 594 * faster). */ 595 start = s; 596 while (*s >= ' ' 597 #ifndef EBCDIC 598 && *s < DEL /* EBCDIC: all chars above space are normal */ 599 #endif 600 && (len < 0 || s - str < len)) 601 ++s; 602 603 /* Don't put '0' or '^' as last character, just in case a CTRL-D is 604 * typed next. */ 605 if (*s == NUL && (s[-1] == '0' || s[-1] == '^')) 606 --s; 607 if (s > start) 608 add_buff(&redobuff, start, (long)(s - start)); 609 610 if (*s == NUL || (len >= 0 && s - str >= len)) 611 break; 612 613 /* Handle a special or multibyte character. */ 614 #ifdef FEAT_MBYTE 615 if (has_mbyte) 616 /* Handle composing chars separately. */ 617 c = mb_cptr2char_adv(&s); 618 else 619 #endif 620 c = *s++; 621 if (c < ' ' || c == DEL || (*s == NUL && (c == '0' || c == '^'))) 622 add_char_buff(&redobuff, Ctrl_V); 623 624 /* CTRL-V '0' must be inserted as CTRL-V 048 (EBCDIC: xf0) */ 625 if (*s == NUL && c == '0') 626 #ifdef EBCDIC 627 add_buff(&redobuff, (char_u *)"xf0", 3L); 628 #else 629 add_buff(&redobuff, (char_u *)"048", 3L); 630 #endif 631 else 632 add_char_buff(&redobuff, c); 633 } 634 } 635 636 /* 637 * Append a character to the redo buffer. 638 * Translates special keys, NUL, CSI, K_SPECIAL and multibyte characters. 639 */ 640 void 641 AppendCharToRedobuff(int c) 642 { 643 if (!block_redo) 644 add_char_buff(&redobuff, c); 645 } 646 647 /* 648 * Append a number to the redo buffer. 649 */ 650 void 651 AppendNumberToRedobuff(long n) 652 { 653 if (!block_redo) 654 add_num_buff(&redobuff, n); 655 } 656 657 /* 658 * Append string "s" to the stuff buffer. 659 * CSI and K_SPECIAL must already have been escaped. 660 */ 661 void 662 stuffReadbuff(char_u *s) 663 { 664 add_buff(&readbuf1, s, -1L); 665 } 666 667 /* 668 * Append string "s" to the redo stuff buffer. 669 * CSI and K_SPECIAL must already have been escaped. 670 */ 671 void 672 stuffRedoReadbuff(char_u *s) 673 { 674 add_buff(&readbuf2, s, -1L); 675 } 676 677 void 678 stuffReadbuffLen(char_u *s, long len) 679 { 680 add_buff(&readbuf1, s, len); 681 } 682 683 #if defined(FEAT_EVAL) || defined(PROTO) 684 /* 685 * Stuff "s" into the stuff buffer, leaving special key codes unmodified and 686 * escaping other K_SPECIAL and CSI bytes. 687 * Change CR, LF and ESC into a space. 688 */ 689 void 690 stuffReadbuffSpec(char_u *s) 691 { 692 int c; 693 694 while (*s != NUL) 695 { 696 if (*s == K_SPECIAL && s[1] != NUL && s[2] != NUL) 697 { 698 /* Insert special key literally. */ 699 stuffReadbuffLen(s, 3L); 700 s += 3; 701 } 702 else 703 { 704 #ifdef FEAT_MBYTE 705 c = mb_ptr2char_adv(&s); 706 #else 707 c = *s++; 708 #endif 709 if (c == CAR || c == NL || c == ESC) 710 c = ' '; 711 stuffcharReadbuff(c); 712 } 713 } 714 } 715 #endif 716 717 /* 718 * Append a character to the stuff buffer. 719 * Translates special keys, NUL, CSI, K_SPECIAL and multibyte characters. 720 */ 721 void 722 stuffcharReadbuff(int c) 723 { 724 add_char_buff(&readbuf1, c); 725 } 726 727 /* 728 * Append a number to the stuff buffer. 729 */ 730 void 731 stuffnumReadbuff(long n) 732 { 733 add_num_buff(&readbuf1, n); 734 } 735 736 /* 737 * Read a character from the redo buffer. Translates K_SPECIAL, CSI and 738 * multibyte characters. 739 * The redo buffer is left as it is. 740 * If init is TRUE, prepare for redo, return FAIL if nothing to redo, OK 741 * otherwise. 742 * If old is TRUE, use old_redobuff instead of redobuff. 743 */ 744 static int 745 read_redo(int init, int old_redo) 746 { 747 static buffblock_T *bp; 748 static char_u *p; 749 int c; 750 #ifdef FEAT_MBYTE 751 int n; 752 char_u buf[MB_MAXBYTES + 1]; 753 int i; 754 #endif 755 756 if (init) 757 { 758 if (old_redo) 759 bp = old_redobuff.bh_first.b_next; 760 else 761 bp = redobuff.bh_first.b_next; 762 if (bp == NULL) 763 return FAIL; 764 p = bp->b_str; 765 return OK; 766 } 767 if ((c = *p) != NUL) 768 { 769 /* Reverse the conversion done by add_char_buff() */ 770 #ifdef FEAT_MBYTE 771 /* For a multi-byte character get all the bytes and return the 772 * converted character. */ 773 if (has_mbyte && (c != K_SPECIAL || p[1] == KS_SPECIAL)) 774 n = MB_BYTE2LEN_CHECK(c); 775 else 776 n = 1; 777 for (i = 0; ; ++i) 778 #endif 779 { 780 if (c == K_SPECIAL) /* special key or escaped K_SPECIAL */ 781 { 782 c = TO_SPECIAL(p[1], p[2]); 783 p += 2; 784 } 785 #ifdef FEAT_GUI 786 if (c == CSI) /* escaped CSI */ 787 p += 2; 788 #endif 789 if (*++p == NUL && bp->b_next != NULL) 790 { 791 bp = bp->b_next; 792 p = bp->b_str; 793 } 794 #ifdef FEAT_MBYTE 795 buf[i] = c; 796 if (i == n - 1) /* last byte of a character */ 797 { 798 if (n != 1) 799 c = (*mb_ptr2char)(buf); 800 break; 801 } 802 c = *p; 803 if (c == NUL) /* cannot happen? */ 804 break; 805 #endif 806 } 807 } 808 809 return c; 810 } 811 812 /* 813 * Copy the rest of the redo buffer into the stuff buffer (in a slow way). 814 * If old_redo is TRUE, use old_redobuff instead of redobuff. 815 * The escaped K_SPECIAL and CSI are copied without translation. 816 */ 817 static void 818 copy_redo(int old_redo) 819 { 820 int c; 821 822 while ((c = read_redo(FALSE, old_redo)) != NUL) 823 add_char_buff(&readbuf2, c); 824 } 825 826 /* 827 * Stuff the redo buffer into readbuf2. 828 * Insert the redo count into the command. 829 * If "old_redo" is TRUE, the last but one command is repeated 830 * instead of the last command (inserting text). This is used for 831 * CTRL-O <.> in insert mode 832 * 833 * return FAIL for failure, OK otherwise 834 */ 835 int 836 start_redo(long count, int old_redo) 837 { 838 int c; 839 840 /* init the pointers; return if nothing to redo */ 841 if (read_redo(TRUE, old_redo) == FAIL) 842 return FAIL; 843 844 c = read_redo(FALSE, old_redo); 845 846 /* copy the buffer name, if present */ 847 if (c == '"') 848 { 849 add_buff(&readbuf2, (char_u *)"\"", 1L); 850 c = read_redo(FALSE, old_redo); 851 852 /* if a numbered buffer is used, increment the number */ 853 if (c >= '1' && c < '9') 854 ++c; 855 add_char_buff(&readbuf2, c); 856 c = read_redo(FALSE, old_redo); 857 } 858 859 if (c == 'v') /* redo Visual */ 860 { 861 VIsual = curwin->w_cursor; 862 VIsual_active = TRUE; 863 VIsual_select = FALSE; 864 VIsual_reselect = TRUE; 865 redo_VIsual_busy = TRUE; 866 c = read_redo(FALSE, old_redo); 867 } 868 869 /* try to enter the count (in place of a previous count) */ 870 if (count) 871 { 872 while (VIM_ISDIGIT(c)) /* skip "old" count */ 873 c = read_redo(FALSE, old_redo); 874 add_num_buff(&readbuf2, count); 875 } 876 877 /* copy from the redo buffer into the stuff buffer */ 878 add_char_buff(&readbuf2, c); 879 copy_redo(old_redo); 880 return OK; 881 } 882 883 /* 884 * Repeat the last insert (R, o, O, a, A, i or I command) by stuffing 885 * the redo buffer into readbuf2. 886 * return FAIL for failure, OK otherwise 887 */ 888 int 889 start_redo_ins(void) 890 { 891 int c; 892 893 if (read_redo(TRUE, FALSE) == FAIL) 894 return FAIL; 895 start_stuff(); 896 897 /* skip the count and the command character */ 898 while ((c = read_redo(FALSE, FALSE)) != NUL) 899 { 900 if (vim_strchr((char_u *)"AaIiRrOo", c) != NULL) 901 { 902 if (c == 'O' || c == 'o') 903 add_buff(&readbuf2, NL_STR, -1L); 904 break; 905 } 906 } 907 908 /* copy the typed text from the redo buffer into the stuff buffer */ 909 copy_redo(FALSE); 910 block_redo = TRUE; 911 return OK; 912 } 913 914 void 915 stop_redo_ins(void) 916 { 917 block_redo = FALSE; 918 } 919 920 /* 921 * Initialize typebuf.tb_buf to point to typebuf_init. 922 * alloc() cannot be used here: In out-of-memory situations it would 923 * be impossible to type anything. 924 */ 925 static void 926 init_typebuf(void) 927 { 928 if (typebuf.tb_buf == NULL) 929 { 930 typebuf.tb_buf = typebuf_init; 931 typebuf.tb_noremap = noremapbuf_init; 932 typebuf.tb_buflen = TYPELEN_INIT; 933 typebuf.tb_len = 0; 934 typebuf.tb_off = 0; 935 typebuf.tb_change_cnt = 1; 936 } 937 } 938 939 /* 940 * Insert a string in position 'offset' in the typeahead buffer (for "@r" 941 * and ":normal" command, vgetorpeek() and check_termcode()). 942 * 943 * If noremap is REMAP_YES, new string can be mapped again. 944 * If noremap is REMAP_NONE, new string cannot be mapped again. 945 * If noremap is REMAP_SKIP, fist char of new string cannot be mapped again, 946 * but abbreviations are allowed. 947 * If noremap is REMAP_SCRIPT, new string cannot be mapped again, except for 948 * script-local mappings. 949 * If noremap is > 0, that many characters of the new string cannot be mapped. 950 * 951 * If nottyped is TRUE, the string does not return KeyTyped (don't use when 952 * offset is non-zero!). 953 * 954 * If silent is TRUE, cmd_silent is set when the characters are obtained. 955 * 956 * return FAIL for failure, OK otherwise 957 */ 958 int 959 ins_typebuf( 960 char_u *str, 961 int noremap, 962 int offset, 963 int nottyped, 964 int silent) 965 { 966 char_u *s1, *s2; 967 int newlen; 968 int addlen; 969 int i; 970 int newoff; 971 int val; 972 int nrm; 973 974 init_typebuf(); 975 if (++typebuf.tb_change_cnt == 0) 976 typebuf.tb_change_cnt = 1; 977 978 addlen = (int)STRLEN(str); 979 980 /* 981 * Easy case: there is room in front of typebuf.tb_buf[typebuf.tb_off] 982 */ 983 if (offset == 0 && addlen <= typebuf.tb_off) 984 { 985 typebuf.tb_off -= addlen; 986 mch_memmove(typebuf.tb_buf + typebuf.tb_off, str, (size_t)addlen); 987 } 988 989 /* 990 * Need to allocate a new buffer. 991 * In typebuf.tb_buf there must always be room for 3 * MAXMAPLEN + 4 992 * characters. We add some extra room to avoid having to allocate too 993 * often. 994 */ 995 else 996 { 997 newoff = MAXMAPLEN + 4; 998 newlen = typebuf.tb_len + addlen + newoff + 4 * (MAXMAPLEN + 4); 999 if (newlen < 0) /* string is getting too long */ 1000 { 1001 EMSG(_(e_toocompl)); /* also calls flush_buffers */ 1002 setcursor(); 1003 return FAIL; 1004 } 1005 s1 = alloc(newlen); 1006 if (s1 == NULL) /* out of memory */ 1007 return FAIL; 1008 s2 = alloc(newlen); 1009 if (s2 == NULL) /* out of memory */ 1010 { 1011 vim_free(s1); 1012 return FAIL; 1013 } 1014 typebuf.tb_buflen = newlen; 1015 1016 /* copy the old chars, before the insertion point */ 1017 mch_memmove(s1 + newoff, typebuf.tb_buf + typebuf.tb_off, 1018 (size_t)offset); 1019 /* copy the new chars */ 1020 mch_memmove(s1 + newoff + offset, str, (size_t)addlen); 1021 /* copy the old chars, after the insertion point, including the NUL at 1022 * the end */ 1023 mch_memmove(s1 + newoff + offset + addlen, 1024 typebuf.tb_buf + typebuf.tb_off + offset, 1025 (size_t)(typebuf.tb_len - offset + 1)); 1026 if (typebuf.tb_buf != typebuf_init) 1027 vim_free(typebuf.tb_buf); 1028 typebuf.tb_buf = s1; 1029 1030 mch_memmove(s2 + newoff, typebuf.tb_noremap + typebuf.tb_off, 1031 (size_t)offset); 1032 mch_memmove(s2 + newoff + offset + addlen, 1033 typebuf.tb_noremap + typebuf.tb_off + offset, 1034 (size_t)(typebuf.tb_len - offset)); 1035 if (typebuf.tb_noremap != noremapbuf_init) 1036 vim_free(typebuf.tb_noremap); 1037 typebuf.tb_noremap = s2; 1038 1039 typebuf.tb_off = newoff; 1040 } 1041 typebuf.tb_len += addlen; 1042 1043 /* If noremap == REMAP_SCRIPT: do remap script-local mappings. */ 1044 if (noremap == REMAP_SCRIPT) 1045 val = RM_SCRIPT; 1046 else if (noremap == REMAP_SKIP) 1047 val = RM_ABBR; 1048 else 1049 val = RM_NONE; 1050 1051 /* 1052 * Adjust typebuf.tb_noremap[] for the new characters: 1053 * If noremap == REMAP_NONE or REMAP_SCRIPT: new characters are 1054 * (sometimes) not remappable 1055 * If noremap == REMAP_YES: all the new characters are mappable 1056 * If noremap > 0: "noremap" characters are not remappable, the rest 1057 * mappable 1058 */ 1059 if (noremap == REMAP_SKIP) 1060 nrm = 1; 1061 else if (noremap < 0) 1062 nrm = addlen; 1063 else 1064 nrm = noremap; 1065 for (i = 0; i < addlen; ++i) 1066 typebuf.tb_noremap[typebuf.tb_off + i + offset] = 1067 (--nrm >= 0) ? val : RM_YES; 1068 1069 /* tb_maplen and tb_silent only remember the length of mapped and/or 1070 * silent mappings at the start of the buffer, assuming that a mapped 1071 * sequence doesn't result in typed characters. */ 1072 if (nottyped || typebuf.tb_maplen > offset) 1073 typebuf.tb_maplen += addlen; 1074 if (silent || typebuf.tb_silent > offset) 1075 { 1076 typebuf.tb_silent += addlen; 1077 cmd_silent = TRUE; 1078 } 1079 if (typebuf.tb_no_abbr_cnt && offset == 0) /* and not used for abbrev.s */ 1080 typebuf.tb_no_abbr_cnt += addlen; 1081 1082 return OK; 1083 } 1084 1085 /* 1086 * Put character "c" back into the typeahead buffer. 1087 * Can be used for a character obtained by vgetc() that needs to be put back. 1088 * Uses cmd_silent, KeyTyped and KeyNoremap to restore the flags belonging to 1089 * the char. 1090 */ 1091 void 1092 ins_char_typebuf(int c) 1093 { 1094 #ifdef FEAT_MBYTE 1095 char_u buf[MB_MAXBYTES + 1]; 1096 #else 1097 char_u buf[4]; 1098 #endif 1099 if (IS_SPECIAL(c)) 1100 { 1101 buf[0] = K_SPECIAL; 1102 buf[1] = K_SECOND(c); 1103 buf[2] = K_THIRD(c); 1104 buf[3] = NUL; 1105 } 1106 else 1107 { 1108 #ifdef FEAT_MBYTE 1109 buf[(*mb_char2bytes)(c, buf)] = NUL; 1110 #else 1111 buf[0] = c; 1112 buf[1] = NUL; 1113 #endif 1114 } 1115 (void)ins_typebuf(buf, KeyNoremap, 0, !KeyTyped, cmd_silent); 1116 } 1117 1118 /* 1119 * Return TRUE if the typeahead buffer was changed (while waiting for a 1120 * character to arrive). Happens when a message was received from a client or 1121 * from feedkeys(). 1122 * But check in a more generic way to avoid trouble: When "typebuf.tb_buf" 1123 * changed it was reallocated and the old pointer can no longer be used. 1124 * Or "typebuf.tb_off" may have been changed and we would overwrite characters 1125 * that was just added. 1126 */ 1127 int 1128 typebuf_changed( 1129 int tb_change_cnt) /* old value of typebuf.tb_change_cnt */ 1130 { 1131 return (tb_change_cnt != 0 && (typebuf.tb_change_cnt != tb_change_cnt 1132 #if defined(FEAT_CLIENTSERVER) || defined(FEAT_EVAL) 1133 || typebuf_was_filled 1134 #endif 1135 )); 1136 } 1137 1138 /* 1139 * Return TRUE if there are no characters in the typeahead buffer that have 1140 * not been typed (result from a mapping or come from ":normal"). 1141 */ 1142 int 1143 typebuf_typed(void) 1144 { 1145 return typebuf.tb_maplen == 0; 1146 } 1147 1148 /* 1149 * Return the number of characters that are mapped (or not typed). 1150 */ 1151 int 1152 typebuf_maplen(void) 1153 { 1154 return typebuf.tb_maplen; 1155 } 1156 1157 /* 1158 * remove "len" characters from typebuf.tb_buf[typebuf.tb_off + offset] 1159 */ 1160 void 1161 del_typebuf(int len, int offset) 1162 { 1163 int i; 1164 1165 if (len == 0) 1166 return; /* nothing to do */ 1167 1168 typebuf.tb_len -= len; 1169 1170 /* 1171 * Easy case: Just increase typebuf.tb_off. 1172 */ 1173 if (offset == 0 && typebuf.tb_buflen - (typebuf.tb_off + len) 1174 >= 3 * MAXMAPLEN + 3) 1175 typebuf.tb_off += len; 1176 /* 1177 * Have to move the characters in typebuf.tb_buf[] and typebuf.tb_noremap[] 1178 */ 1179 else 1180 { 1181 i = typebuf.tb_off + offset; 1182 /* 1183 * Leave some extra room at the end to avoid reallocation. 1184 */ 1185 if (typebuf.tb_off > MAXMAPLEN) 1186 { 1187 mch_memmove(typebuf.tb_buf + MAXMAPLEN, 1188 typebuf.tb_buf + typebuf.tb_off, (size_t)offset); 1189 mch_memmove(typebuf.tb_noremap + MAXMAPLEN, 1190 typebuf.tb_noremap + typebuf.tb_off, (size_t)offset); 1191 typebuf.tb_off = MAXMAPLEN; 1192 } 1193 /* adjust typebuf.tb_buf (include the NUL at the end) */ 1194 mch_memmove(typebuf.tb_buf + typebuf.tb_off + offset, 1195 typebuf.tb_buf + i + len, 1196 (size_t)(typebuf.tb_len - offset + 1)); 1197 /* adjust typebuf.tb_noremap[] */ 1198 mch_memmove(typebuf.tb_noremap + typebuf.tb_off + offset, 1199 typebuf.tb_noremap + i + len, 1200 (size_t)(typebuf.tb_len - offset)); 1201 } 1202 1203 if (typebuf.tb_maplen > offset) /* adjust tb_maplen */ 1204 { 1205 if (typebuf.tb_maplen < offset + len) 1206 typebuf.tb_maplen = offset; 1207 else 1208 typebuf.tb_maplen -= len; 1209 } 1210 if (typebuf.tb_silent > offset) /* adjust tb_silent */ 1211 { 1212 if (typebuf.tb_silent < offset + len) 1213 typebuf.tb_silent = offset; 1214 else 1215 typebuf.tb_silent -= len; 1216 } 1217 if (typebuf.tb_no_abbr_cnt > offset) /* adjust tb_no_abbr_cnt */ 1218 { 1219 if (typebuf.tb_no_abbr_cnt < offset + len) 1220 typebuf.tb_no_abbr_cnt = offset; 1221 else 1222 typebuf.tb_no_abbr_cnt -= len; 1223 } 1224 1225 #if defined(FEAT_CLIENTSERVER) || defined(FEAT_EVAL) 1226 /* Reset the flag that text received from a client or from feedkeys() 1227 * was inserted in the typeahead buffer. */ 1228 typebuf_was_filled = FALSE; 1229 #endif 1230 if (++typebuf.tb_change_cnt == 0) 1231 typebuf.tb_change_cnt = 1; 1232 } 1233 1234 /* 1235 * Write typed characters to script file. 1236 * If recording is on put the character in the recordbuffer. 1237 */ 1238 static void 1239 gotchars(char_u *chars, int len) 1240 { 1241 char_u *s = chars; 1242 int c; 1243 char_u buf[2]; 1244 int todo = len; 1245 1246 /* remember how many chars were last recorded */ 1247 if (Recording) 1248 last_recorded_len += len; 1249 1250 buf[1] = NUL; 1251 while (todo--) 1252 { 1253 /* Handle one byte at a time; no translation to be done. */ 1254 c = *s++; 1255 updatescript(c); 1256 1257 if (Recording) 1258 { 1259 buf[0] = c; 1260 add_buff(&recordbuff, buf, 1L); 1261 } 1262 } 1263 may_sync_undo(); 1264 1265 #ifdef FEAT_EVAL 1266 /* output "debug mode" message next time in debug mode */ 1267 debug_did_msg = FALSE; 1268 #endif 1269 1270 /* Since characters have been typed, consider the following to be in 1271 * another mapping. Search string will be kept in history. */ 1272 ++maptick; 1273 } 1274 1275 /* 1276 * Sync undo. Called when typed characters are obtained from the typeahead 1277 * buffer, or when a menu is used. 1278 * Do not sync: 1279 * - In Insert mode, unless cursor key has been used. 1280 * - While reading a script file. 1281 * - When no_u_sync is non-zero. 1282 */ 1283 static void 1284 may_sync_undo(void) 1285 { 1286 if ((!(State & (INSERT + CMDLINE)) || arrow_used) 1287 && scriptin[curscript] == NULL) 1288 u_sync(FALSE); 1289 } 1290 1291 /* 1292 * Make "typebuf" empty and allocate new buffers. 1293 * Returns FAIL when out of memory. 1294 */ 1295 int 1296 alloc_typebuf(void) 1297 { 1298 typebuf.tb_buf = alloc(TYPELEN_INIT); 1299 typebuf.tb_noremap = alloc(TYPELEN_INIT); 1300 if (typebuf.tb_buf == NULL || typebuf.tb_noremap == NULL) 1301 { 1302 free_typebuf(); 1303 return FAIL; 1304 } 1305 typebuf.tb_buflen = TYPELEN_INIT; 1306 typebuf.tb_off = 0; 1307 typebuf.tb_len = 0; 1308 typebuf.tb_maplen = 0; 1309 typebuf.tb_silent = 0; 1310 typebuf.tb_no_abbr_cnt = 0; 1311 if (++typebuf.tb_change_cnt == 0) 1312 typebuf.tb_change_cnt = 1; 1313 return OK; 1314 } 1315 1316 /* 1317 * Free the buffers of "typebuf". 1318 */ 1319 void 1320 free_typebuf(void) 1321 { 1322 if (typebuf.tb_buf == typebuf_init) 1323 EMSG2(_(e_intern2), "Free typebuf 1"); 1324 else 1325 vim_free(typebuf.tb_buf); 1326 if (typebuf.tb_noremap == noremapbuf_init) 1327 EMSG2(_(e_intern2), "Free typebuf 2"); 1328 else 1329 vim_free(typebuf.tb_noremap); 1330 } 1331 1332 /* 1333 * When doing ":so! file", the current typeahead needs to be saved, and 1334 * restored when "file" has been read completely. 1335 */ 1336 static typebuf_T saved_typebuf[NSCRIPT]; 1337 1338 int 1339 save_typebuf(void) 1340 { 1341 init_typebuf(); 1342 saved_typebuf[curscript] = typebuf; 1343 /* If out of memory: restore typebuf and close file. */ 1344 if (alloc_typebuf() == FAIL) 1345 { 1346 closescript(); 1347 return FAIL; 1348 } 1349 return OK; 1350 } 1351 1352 static int old_char = -1; /* character put back by vungetc() */ 1353 static int old_mod_mask; /* mod_mask for ungotten character */ 1354 #ifdef FEAT_MOUSE 1355 static int old_mouse_row; /* mouse_row related to old_char */ 1356 static int old_mouse_col; /* mouse_col related to old_char */ 1357 #endif 1358 1359 /* 1360 * Save all three kinds of typeahead, so that the user must type at a prompt. 1361 */ 1362 void 1363 save_typeahead(tasave_T *tp) 1364 { 1365 tp->save_typebuf = typebuf; 1366 tp->typebuf_valid = (alloc_typebuf() == OK); 1367 if (!tp->typebuf_valid) 1368 typebuf = tp->save_typebuf; 1369 1370 tp->old_char = old_char; 1371 tp->old_mod_mask = old_mod_mask; 1372 old_char = -1; 1373 1374 tp->save_readbuf1 = readbuf1; 1375 readbuf1.bh_first.b_next = NULL; 1376 tp->save_readbuf2 = readbuf2; 1377 readbuf2.bh_first.b_next = NULL; 1378 # ifdef USE_INPUT_BUF 1379 tp->save_inputbuf = get_input_buf(); 1380 # endif 1381 } 1382 1383 /* 1384 * Restore the typeahead to what it was before calling save_typeahead(). 1385 * The allocated memory is freed, can only be called once! 1386 */ 1387 void 1388 restore_typeahead(tasave_T *tp) 1389 { 1390 if (tp->typebuf_valid) 1391 { 1392 free_typebuf(); 1393 typebuf = tp->save_typebuf; 1394 } 1395 1396 old_char = tp->old_char; 1397 old_mod_mask = tp->old_mod_mask; 1398 1399 free_buff(&readbuf1); 1400 readbuf1 = tp->save_readbuf1; 1401 free_buff(&readbuf2); 1402 readbuf2 = tp->save_readbuf2; 1403 # ifdef USE_INPUT_BUF 1404 set_input_buf(tp->save_inputbuf); 1405 # endif 1406 } 1407 1408 /* 1409 * Open a new script file for the ":source!" command. 1410 */ 1411 void 1412 openscript( 1413 char_u *name, 1414 int directly) /* when TRUE execute directly */ 1415 { 1416 if (curscript + 1 == NSCRIPT) 1417 { 1418 EMSG(_(e_nesting)); 1419 return; 1420 } 1421 #ifdef FEAT_EVAL 1422 if (ignore_script) 1423 /* Not reading from script, also don't open one. Warning message? */ 1424 return; 1425 #endif 1426 1427 if (scriptin[curscript] != NULL) /* already reading script */ 1428 ++curscript; 1429 /* use NameBuff for expanded name */ 1430 expand_env(name, NameBuff, MAXPATHL); 1431 if ((scriptin[curscript] = mch_fopen((char *)NameBuff, READBIN)) == NULL) 1432 { 1433 EMSG2(_(e_notopen), name); 1434 if (curscript) 1435 --curscript; 1436 return; 1437 } 1438 if (save_typebuf() == FAIL) 1439 return; 1440 1441 /* 1442 * Execute the commands from the file right now when using ":source!" 1443 * after ":global" or ":argdo" or in a loop. Also when another command 1444 * follows. This means the display won't be updated. Don't do this 1445 * always, "make test" would fail. 1446 */ 1447 if (directly) 1448 { 1449 oparg_T oa; 1450 int oldcurscript; 1451 int save_State = State; 1452 int save_restart_edit = restart_edit; 1453 int save_insertmode = p_im; 1454 int save_finish_op = finish_op; 1455 int save_msg_scroll = msg_scroll; 1456 1457 State = NORMAL; 1458 msg_scroll = FALSE; /* no msg scrolling in Normal mode */ 1459 restart_edit = 0; /* don't go to Insert mode */ 1460 p_im = FALSE; /* don't use 'insertmode' */ 1461 clear_oparg(&oa); 1462 finish_op = FALSE; 1463 1464 oldcurscript = curscript; 1465 do 1466 { 1467 update_topline_cursor(); /* update cursor position and topline */ 1468 normal_cmd(&oa, FALSE); /* execute one command */ 1469 vpeekc(); /* check for end of file */ 1470 } 1471 while (scriptin[oldcurscript] != NULL); 1472 1473 State = save_State; 1474 msg_scroll = save_msg_scroll; 1475 restart_edit = save_restart_edit; 1476 p_im = save_insertmode; 1477 finish_op = save_finish_op; 1478 } 1479 } 1480 1481 /* 1482 * Close the currently active input script. 1483 */ 1484 static void 1485 closescript(void) 1486 { 1487 free_typebuf(); 1488 typebuf = saved_typebuf[curscript]; 1489 1490 fclose(scriptin[curscript]); 1491 scriptin[curscript] = NULL; 1492 if (curscript > 0) 1493 --curscript; 1494 } 1495 1496 #if defined(EXITFREE) || defined(PROTO) 1497 void 1498 close_all_scripts(void) 1499 { 1500 while (scriptin[0] != NULL) 1501 closescript(); 1502 } 1503 #endif 1504 1505 #if defined(FEAT_INS_EXPAND) || defined(PROTO) 1506 /* 1507 * Return TRUE when reading keys from a script file. 1508 */ 1509 int 1510 using_script(void) 1511 { 1512 return scriptin[curscript] != NULL; 1513 } 1514 #endif 1515 1516 /* 1517 * This function is called just before doing a blocking wait. Thus after 1518 * waiting 'updatetime' for a character to arrive. 1519 */ 1520 void 1521 before_blocking(void) 1522 { 1523 updatescript(0); 1524 #ifdef FEAT_EVAL 1525 if (may_garbage_collect) 1526 garbage_collect(); 1527 #endif 1528 } 1529 1530 /* 1531 * updatescipt() is called when a character can be written into the script file 1532 * or when we have waited some time for a character (c == 0) 1533 * 1534 * All the changed memfiles are synced if c == 0 or when the number of typed 1535 * characters reaches 'updatecount' and 'updatecount' is non-zero. 1536 */ 1537 void 1538 updatescript(int c) 1539 { 1540 static int count = 0; 1541 1542 if (c && scriptout) 1543 putc(c, scriptout); 1544 if (c == 0 || (p_uc > 0 && ++count >= p_uc)) 1545 { 1546 ml_sync_all(c == 0, TRUE); 1547 count = 0; 1548 } 1549 } 1550 1551 /* 1552 * Get the next input character. 1553 * Can return a special key or a multi-byte character. 1554 * Can return NUL when called recursively, use safe_vgetc() if that's not 1555 * wanted. 1556 * This translates escaped K_SPECIAL and CSI bytes to a K_SPECIAL or CSI byte. 1557 * Collects the bytes of a multibyte character into the whole character. 1558 * Returns the modifiers in the global "mod_mask". 1559 */ 1560 int 1561 vgetc(void) 1562 { 1563 int c, c2; 1564 #ifdef FEAT_MBYTE 1565 int n; 1566 char_u buf[MB_MAXBYTES + 1]; 1567 int i; 1568 #endif 1569 1570 #ifdef FEAT_EVAL 1571 /* Do garbage collection when garbagecollect() was called previously and 1572 * we are now at the toplevel. */ 1573 if (may_garbage_collect && want_garbage_collect) 1574 garbage_collect(); 1575 #endif 1576 1577 /* 1578 * If a character was put back with vungetc, it was already processed. 1579 * Return it directly. 1580 */ 1581 if (old_char != -1) 1582 { 1583 c = old_char; 1584 old_char = -1; 1585 mod_mask = old_mod_mask; 1586 #ifdef FEAT_MOUSE 1587 mouse_row = old_mouse_row; 1588 mouse_col = old_mouse_col; 1589 #endif 1590 } 1591 else 1592 { 1593 mod_mask = 0x0; 1594 last_recorded_len = 0; 1595 for (;;) /* this is done twice if there are modifiers */ 1596 { 1597 int did_inc = FALSE; 1598 1599 if (mod_mask) /* no mapping after modifier has been read */ 1600 { 1601 ++no_mapping; 1602 ++allow_keys; 1603 did_inc = TRUE; /* mod_mask may change value */ 1604 } 1605 c = vgetorpeek(TRUE); 1606 if (did_inc) 1607 { 1608 --no_mapping; 1609 --allow_keys; 1610 } 1611 1612 /* Get two extra bytes for special keys */ 1613 if (c == K_SPECIAL 1614 #ifdef FEAT_GUI 1615 || c == CSI 1616 #endif 1617 ) 1618 { 1619 int save_allow_keys = allow_keys; 1620 1621 ++no_mapping; 1622 allow_keys = 0; /* make sure BS is not found */ 1623 c2 = vgetorpeek(TRUE); /* no mapping for these chars */ 1624 c = vgetorpeek(TRUE); 1625 --no_mapping; 1626 allow_keys = save_allow_keys; 1627 if (c2 == KS_MODIFIER) 1628 { 1629 mod_mask = c; 1630 continue; 1631 } 1632 c = TO_SPECIAL(c2, c); 1633 1634 #if defined(FEAT_GUI_W32) && defined(FEAT_MENU) && defined(FEAT_TEAROFF) 1635 /* Handle K_TEAROFF here, the caller of vgetc() doesn't need to 1636 * know that a menu was torn off */ 1637 if (c == K_TEAROFF) 1638 { 1639 char_u name[200]; 1640 int i; 1641 1642 /* get menu path, it ends with a <CR> */ 1643 for (i = 0; (c = vgetorpeek(TRUE)) != '\r'; ) 1644 { 1645 name[i] = c; 1646 if (i < 199) 1647 ++i; 1648 } 1649 name[i] = NUL; 1650 gui_make_tearoff(name); 1651 continue; 1652 } 1653 #endif 1654 #if defined(FEAT_GUI) && defined(FEAT_GUI_GTK) && defined(FEAT_MENU) 1655 /* GTK: <F10> normally selects the menu, but it's passed until 1656 * here to allow mapping it. Intercept and invoke the GTK 1657 * behavior if it's not mapped. */ 1658 if (c == K_F10 && gui.menubar != NULL) 1659 { 1660 gtk_menu_shell_select_first(GTK_MENU_SHELL(gui.menubar), FALSE); 1661 continue; 1662 } 1663 #endif 1664 #ifdef FEAT_GUI 1665 /* Handle focus event here, so that the caller doesn't need to 1666 * know about it. Return K_IGNORE so that we loop once (needed if 1667 * 'lazyredraw' is set). */ 1668 if (c == K_FOCUSGAINED || c == K_FOCUSLOST) 1669 { 1670 ui_focus_change(c == K_FOCUSGAINED); 1671 c = K_IGNORE; 1672 } 1673 1674 /* Translate K_CSI to CSI. The special key is only used to avoid 1675 * it being recognized as the start of a special key. */ 1676 if (c == K_CSI) 1677 c = CSI; 1678 #endif 1679 } 1680 /* a keypad or special function key was not mapped, use it like 1681 * its ASCII equivalent */ 1682 switch (c) 1683 { 1684 case K_KPLUS: c = '+'; break; 1685 case K_KMINUS: c = '-'; break; 1686 case K_KDIVIDE: c = '/'; break; 1687 case K_KMULTIPLY: c = '*'; break; 1688 case K_KENTER: c = CAR; break; 1689 case K_KPOINT: 1690 #ifdef WIN32 1691 /* Can be either '.' or a ',', * 1692 * depending on the type of keypad. */ 1693 c = MapVirtualKey(VK_DECIMAL, 2); break; 1694 #else 1695 c = '.'; break; 1696 #endif 1697 case K_K0: c = '0'; break; 1698 case K_K1: c = '1'; break; 1699 case K_K2: c = '2'; break; 1700 case K_K3: c = '3'; break; 1701 case K_K4: c = '4'; break; 1702 case K_K5: c = '5'; break; 1703 case K_K6: c = '6'; break; 1704 case K_K7: c = '7'; break; 1705 case K_K8: c = '8'; break; 1706 case K_K9: c = '9'; break; 1707 1708 case K_XHOME: 1709 case K_ZHOME: if (mod_mask == MOD_MASK_SHIFT) 1710 { 1711 c = K_S_HOME; 1712 mod_mask = 0; 1713 } 1714 else if (mod_mask == MOD_MASK_CTRL) 1715 { 1716 c = K_C_HOME; 1717 mod_mask = 0; 1718 } 1719 else 1720 c = K_HOME; 1721 break; 1722 case K_XEND: 1723 case K_ZEND: if (mod_mask == MOD_MASK_SHIFT) 1724 { 1725 c = K_S_END; 1726 mod_mask = 0; 1727 } 1728 else if (mod_mask == MOD_MASK_CTRL) 1729 { 1730 c = K_C_END; 1731 mod_mask = 0; 1732 } 1733 else 1734 c = K_END; 1735 break; 1736 1737 case K_XUP: c = K_UP; break; 1738 case K_XDOWN: c = K_DOWN; break; 1739 case K_XLEFT: c = K_LEFT; break; 1740 case K_XRIGHT: c = K_RIGHT; break; 1741 } 1742 1743 #ifdef FEAT_MBYTE 1744 /* For a multi-byte character get all the bytes and return the 1745 * converted character. 1746 * Note: This will loop until enough bytes are received! 1747 */ 1748 if (has_mbyte && (n = MB_BYTE2LEN_CHECK(c)) > 1) 1749 { 1750 ++no_mapping; 1751 buf[0] = c; 1752 for (i = 1; i < n; ++i) 1753 { 1754 buf[i] = vgetorpeek(TRUE); 1755 if (buf[i] == K_SPECIAL 1756 #ifdef FEAT_GUI 1757 || buf[i] == CSI 1758 #endif 1759 ) 1760 { 1761 /* Must be a K_SPECIAL - KS_SPECIAL - KE_FILLER sequence, 1762 * which represents a K_SPECIAL (0x80), 1763 * or a CSI - KS_EXTRA - KE_CSI sequence, which represents 1764 * a CSI (0x9B), 1765 * of a K_SPECIAL - KS_EXTRA - KE_CSI, which is CSI too. */ 1766 c = vgetorpeek(TRUE); 1767 if (vgetorpeek(TRUE) == (int)KE_CSI && c == KS_EXTRA) 1768 buf[i] = CSI; 1769 } 1770 } 1771 --no_mapping; 1772 c = (*mb_ptr2char)(buf); 1773 } 1774 #endif 1775 1776 break; 1777 } 1778 } 1779 1780 #ifdef FEAT_EVAL 1781 /* 1782 * In the main loop "may_garbage_collect" can be set to do garbage 1783 * collection in the first next vgetc(). It's disabled after that to 1784 * avoid internally used Lists and Dicts to be freed. 1785 */ 1786 may_garbage_collect = FALSE; 1787 #endif 1788 1789 return c; 1790 } 1791 1792 /* 1793 * Like vgetc(), but never return a NUL when called recursively, get a key 1794 * directly from the user (ignoring typeahead). 1795 */ 1796 int 1797 safe_vgetc(void) 1798 { 1799 int c; 1800 1801 c = vgetc(); 1802 if (c == NUL) 1803 c = get_keystroke(); 1804 return c; 1805 } 1806 1807 /* 1808 * Like safe_vgetc(), but loop to handle K_IGNORE. 1809 * Also ignore scrollbar events. 1810 */ 1811 int 1812 plain_vgetc(void) 1813 { 1814 int c; 1815 1816 do 1817 { 1818 c = safe_vgetc(); 1819 } while (c == K_IGNORE || c == K_VER_SCROLLBAR || c == K_HOR_SCROLLBAR); 1820 return c; 1821 } 1822 1823 /* 1824 * Check if a character is available, such that vgetc() will not block. 1825 * If the next character is a special character or multi-byte, the returned 1826 * character is not valid!. 1827 */ 1828 int 1829 vpeekc(void) 1830 { 1831 if (old_char != -1) 1832 return old_char; 1833 return vgetorpeek(FALSE); 1834 } 1835 1836 #if defined(FEAT_TERMRESPONSE) || defined(PROTO) 1837 /* 1838 * Like vpeekc(), but don't allow mapping. Do allow checking for terminal 1839 * codes. 1840 */ 1841 int 1842 vpeekc_nomap(void) 1843 { 1844 int c; 1845 1846 ++no_mapping; 1847 ++allow_keys; 1848 c = vpeekc(); 1849 --no_mapping; 1850 --allow_keys; 1851 return c; 1852 } 1853 #endif 1854 1855 #if defined(FEAT_INS_EXPAND) || defined(FEAT_EVAL) || defined(PROTO) 1856 /* 1857 * Check if any character is available, also half an escape sequence. 1858 * Trick: when no typeahead found, but there is something in the typeahead 1859 * buffer, it must be an ESC that is recognized as the start of a key code. 1860 */ 1861 int 1862 vpeekc_any(void) 1863 { 1864 int c; 1865 1866 c = vpeekc(); 1867 if (c == NUL && typebuf.tb_len > 0) 1868 c = ESC; 1869 return c; 1870 } 1871 #endif 1872 1873 /* 1874 * Call vpeekc() without causing anything to be mapped. 1875 * Return TRUE if a character is available, FALSE otherwise. 1876 */ 1877 int 1878 char_avail(void) 1879 { 1880 int retval; 1881 1882 #ifdef FEAT_EVAL 1883 /* When disable_char_avail_for_testing(1) was called pretend there is no 1884 * typeahead. */ 1885 if (disable_char_avail_for_testing) 1886 return FALSE; 1887 #endif 1888 ++no_mapping; 1889 retval = vpeekc(); 1890 --no_mapping; 1891 return (retval != NUL); 1892 } 1893 1894 /* 1895 * unget one character (can only be done once!) 1896 */ 1897 void 1898 vungetc(int c) 1899 { 1900 old_char = c; 1901 old_mod_mask = mod_mask; 1902 #ifdef FEAT_MOUSE 1903 old_mouse_row = mouse_row; 1904 old_mouse_col = mouse_col; 1905 #endif 1906 } 1907 1908 /* 1909 * get a character: 1910 * 1. from the stuffbuffer 1911 * This is used for abbreviated commands like "D" -> "d$". 1912 * Also used to redo a command for ".". 1913 * 2. from the typeahead buffer 1914 * Stores text obtained previously but not used yet. 1915 * Also stores the result of mappings. 1916 * Also used for the ":normal" command. 1917 * 3. from the user 1918 * This may do a blocking wait if "advance" is TRUE. 1919 * 1920 * if "advance" is TRUE (vgetc()): 1921 * really get the character. 1922 * KeyTyped is set to TRUE in the case the user typed the key. 1923 * KeyStuffed is TRUE if the character comes from the stuff buffer. 1924 * if "advance" is FALSE (vpeekc()): 1925 * just look whether there is a character available. 1926 * 1927 * When "no_mapping" is zero, checks for mappings in the current mode. 1928 * Only returns one byte (of a multi-byte character). 1929 * K_SPECIAL and CSI may be escaped, need to get two more bytes then. 1930 */ 1931 static int 1932 vgetorpeek(int advance) 1933 { 1934 int c, c1; 1935 int keylen; 1936 char_u *s; 1937 mapblock_T *mp; 1938 #ifdef FEAT_LOCALMAP 1939 mapblock_T *mp2; 1940 #endif 1941 mapblock_T *mp_match; 1942 int mp_match_len = 0; 1943 int timedout = FALSE; /* waited for more than 1 second 1944 for mapping to complete */ 1945 int mapdepth = 0; /* check for recursive mapping */ 1946 int mode_deleted = FALSE; /* set when mode has been deleted */ 1947 int local_State; 1948 int mlen; 1949 int max_mlen; 1950 int i; 1951 #ifdef FEAT_CMDL_INFO 1952 int new_wcol, new_wrow; 1953 #endif 1954 #ifdef FEAT_GUI 1955 # ifdef FEAT_MENU 1956 int idx; 1957 # endif 1958 int shape_changed = FALSE; /* adjusted cursor shape */ 1959 #endif 1960 int n; 1961 #ifdef FEAT_LANGMAP 1962 int nolmaplen; 1963 #endif 1964 int old_wcol, old_wrow; 1965 int wait_tb_len; 1966 1967 /* 1968 * This function doesn't work very well when called recursively. This may 1969 * happen though, because of: 1970 * 1. The call to add_to_showcmd(). char_avail() is then used to check if 1971 * there is a character available, which calls this function. In that 1972 * case we must return NUL, to indicate no character is available. 1973 * 2. A GUI callback function writes to the screen, causing a 1974 * wait_return(). 1975 * Using ":normal" can also do this, but it saves the typeahead buffer, 1976 * thus it should be OK. But don't get a key from the user then. 1977 */ 1978 if (vgetc_busy > 0 && ex_normal_busy == 0) 1979 return NUL; 1980 1981 local_State = get_real_state(); 1982 1983 ++vgetc_busy; 1984 1985 if (advance) 1986 KeyStuffed = FALSE; 1987 1988 init_typebuf(); 1989 start_stuff(); 1990 if (advance && typebuf.tb_maplen == 0) 1991 Exec_reg = FALSE; 1992 do 1993 { 1994 /* 1995 * get a character: 1. from the stuffbuffer 1996 */ 1997 if (typeahead_char != 0) 1998 { 1999 c = typeahead_char; 2000 if (advance) 2001 typeahead_char = 0; 2002 } 2003 else 2004 c = read_readbuffers(advance); 2005 if (c != NUL && !got_int) 2006 { 2007 if (advance) 2008 { 2009 /* KeyTyped = FALSE; When the command that stuffed something 2010 * was typed, behave like the stuffed command was typed. 2011 * needed for CTRL-W CTRl-] to open a fold, for example. */ 2012 KeyStuffed = TRUE; 2013 } 2014 if (typebuf.tb_no_abbr_cnt == 0) 2015 typebuf.tb_no_abbr_cnt = 1; /* no abbreviations now */ 2016 } 2017 else 2018 { 2019 /* 2020 * Loop until we either find a matching mapped key, or we 2021 * are sure that it is not a mapped key. 2022 * If a mapped key sequence is found we go back to the start to 2023 * try re-mapping. 2024 */ 2025 for (;;) 2026 { 2027 /* 2028 * ui_breakcheck() is slow, don't use it too often when 2029 * inside a mapping. But call it each time for typed 2030 * characters. 2031 */ 2032 if (typebuf.tb_maplen) 2033 line_breakcheck(); 2034 else 2035 ui_breakcheck(); /* check for CTRL-C */ 2036 keylen = 0; 2037 if (got_int) 2038 { 2039 /* flush all input */ 2040 c = inchar(typebuf.tb_buf, typebuf.tb_buflen - 1, 0L, 2041 typebuf.tb_change_cnt); 2042 /* 2043 * If inchar() returns TRUE (script file was active) or we 2044 * are inside a mapping, get out of insert mode. 2045 * Otherwise we behave like having gotten a CTRL-C. 2046 * As a result typing CTRL-C in insert mode will 2047 * really insert a CTRL-C. 2048 */ 2049 if ((c || typebuf.tb_maplen) 2050 && (State & (INSERT + CMDLINE))) 2051 c = ESC; 2052 else 2053 c = Ctrl_C; 2054 flush_buffers(TRUE); /* flush all typeahead */ 2055 2056 if (advance) 2057 { 2058 /* Also record this character, it might be needed to 2059 * get out of Insert mode. */ 2060 *typebuf.tb_buf = c; 2061 gotchars(typebuf.tb_buf, 1); 2062 } 2063 cmd_silent = FALSE; 2064 2065 break; 2066 } 2067 else if (typebuf.tb_len > 0) 2068 { 2069 /* 2070 * Check for a mappable key sequence. 2071 * Walk through one maphash[] list until we find an 2072 * entry that matches. 2073 * 2074 * Don't look for mappings if: 2075 * - no_mapping set: mapping disabled (e.g. for CTRL-V) 2076 * - maphash_valid not set: no mappings present. 2077 * - typebuf.tb_buf[typebuf.tb_off] should not be remapped 2078 * - in insert or cmdline mode and 'paste' option set 2079 * - waiting for "hit return to continue" and CR or SPACE 2080 * typed 2081 * - waiting for a char with --more-- 2082 * - in Ctrl-X mode, and we get a valid char for that mode 2083 */ 2084 mp = NULL; 2085 max_mlen = 0; 2086 c1 = typebuf.tb_buf[typebuf.tb_off]; 2087 if (no_mapping == 0 && maphash_valid 2088 && (no_zero_mapping == 0 || c1 != '0') 2089 && (typebuf.tb_maplen == 0 2090 || (p_remap 2091 && (typebuf.tb_noremap[typebuf.tb_off] 2092 & (RM_NONE|RM_ABBR)) == 0)) 2093 && !(p_paste && (State & (INSERT + CMDLINE))) 2094 && !(State == HITRETURN && (c1 == CAR || c1 == ' ')) 2095 && State != ASKMORE 2096 && State != CONFIRM 2097 #ifdef FEAT_INS_EXPAND 2098 && !((ctrl_x_mode != 0 && vim_is_ctrl_x_key(c1)) 2099 || ((compl_cont_status & CONT_LOCAL) 2100 && (c1 == Ctrl_N || c1 == Ctrl_P))) 2101 #endif 2102 ) 2103 { 2104 #ifdef FEAT_LANGMAP 2105 if (c1 == K_SPECIAL) 2106 nolmaplen = 2; 2107 else 2108 { 2109 LANGMAP_ADJUST(c1, 2110 (State & (CMDLINE | INSERT)) == 0 2111 && get_real_state() != SELECTMODE); 2112 nolmaplen = 0; 2113 } 2114 #endif 2115 #ifdef FEAT_LOCALMAP 2116 /* First try buffer-local mappings. */ 2117 mp = curbuf->b_maphash[MAP_HASH(local_State, c1)]; 2118 mp2 = maphash[MAP_HASH(local_State, c1)]; 2119 if (mp == NULL) 2120 { 2121 /* There are no buffer-local mappings. */ 2122 mp = mp2; 2123 mp2 = NULL; 2124 } 2125 #else 2126 mp = maphash[MAP_HASH(local_State, c1)]; 2127 #endif 2128 /* 2129 * Loop until a partly matching mapping is found or 2130 * all (local) mappings have been checked. 2131 * The longest full match is remembered in "mp_match". 2132 * A full match is only accepted if there is no partly 2133 * match, so "aa" and "aaa" can both be mapped. 2134 */ 2135 mp_match = NULL; 2136 mp_match_len = 0; 2137 for ( ; mp != NULL; 2138 #ifdef FEAT_LOCALMAP 2139 mp->m_next == NULL ? (mp = mp2, mp2 = NULL) : 2140 #endif 2141 (mp = mp->m_next)) 2142 { 2143 /* 2144 * Only consider an entry if the first character 2145 * matches and it is for the current state. 2146 * Skip ":lmap" mappings if keys were mapped. 2147 */ 2148 if (mp->m_keys[0] == c1 2149 && (mp->m_mode & local_State) 2150 && ((mp->m_mode & LANGMAP) == 0 2151 || typebuf.tb_maplen == 0)) 2152 { 2153 #ifdef FEAT_LANGMAP 2154 int nomap = nolmaplen; 2155 int c2; 2156 #endif 2157 /* find the match length of this mapping */ 2158 for (mlen = 1; mlen < typebuf.tb_len; ++mlen) 2159 { 2160 #ifdef FEAT_LANGMAP 2161 c2 = typebuf.tb_buf[typebuf.tb_off + mlen]; 2162 if (nomap > 0) 2163 --nomap; 2164 else if (c2 == K_SPECIAL) 2165 nomap = 2; 2166 else 2167 LANGMAP_ADJUST(c2, TRUE); 2168 if (mp->m_keys[mlen] != c2) 2169 #else 2170 if (mp->m_keys[mlen] != 2171 typebuf.tb_buf[typebuf.tb_off + mlen]) 2172 #endif 2173 break; 2174 } 2175 2176 #ifdef FEAT_MBYTE 2177 /* Don't allow mapping the first byte(s) of a 2178 * multi-byte char. Happens when mapping 2179 * <M-a> and then changing 'encoding'. Beware 2180 * that 0x80 is escaped. */ 2181 { 2182 char_u *p1 = mp->m_keys; 2183 char_u *p2 = mb_unescape(&p1); 2184 2185 if (has_mbyte && p2 != NULL 2186 && MB_BYTE2LEN(c1) > MB_PTR2LEN(p2)) 2187 mlen = 0; 2188 } 2189 #endif 2190 /* 2191 * Check an entry whether it matches. 2192 * - Full match: mlen == keylen 2193 * - Partly match: mlen == typebuf.tb_len 2194 */ 2195 keylen = mp->m_keylen; 2196 if (mlen == keylen 2197 || (mlen == typebuf.tb_len 2198 && typebuf.tb_len < keylen)) 2199 { 2200 /* 2201 * If only script-local mappings are 2202 * allowed, check if the mapping starts 2203 * with K_SNR. 2204 */ 2205 s = typebuf.tb_noremap + typebuf.tb_off; 2206 if (*s == RM_SCRIPT 2207 && (mp->m_keys[0] != K_SPECIAL 2208 || mp->m_keys[1] != KS_EXTRA 2209 || mp->m_keys[2] 2210 != (int)KE_SNR)) 2211 continue; 2212 /* 2213 * If one of the typed keys cannot be 2214 * remapped, skip the entry. 2215 */ 2216 for (n = mlen; --n >= 0; ) 2217 if (*s++ & (RM_NONE|RM_ABBR)) 2218 break; 2219 if (n >= 0) 2220 continue; 2221 2222 if (keylen > typebuf.tb_len) 2223 { 2224 if (!timedout && !(mp_match != NULL 2225 && mp_match->m_nowait)) 2226 { 2227 /* break at a partly match */ 2228 keylen = KEYLEN_PART_MAP; 2229 break; 2230 } 2231 } 2232 else if (keylen > mp_match_len) 2233 { 2234 /* found a longer match */ 2235 mp_match = mp; 2236 mp_match_len = keylen; 2237 } 2238 } 2239 else 2240 /* No match; may have to check for 2241 * termcode at next character. */ 2242 if (max_mlen < mlen) 2243 max_mlen = mlen; 2244 } 2245 } 2246 2247 /* If no partly match found, use the longest full 2248 * match. */ 2249 if (keylen != KEYLEN_PART_MAP) 2250 { 2251 mp = mp_match; 2252 keylen = mp_match_len; 2253 } 2254 } 2255 2256 /* Check for match with 'pastetoggle' */ 2257 if (*p_pt != NUL && mp == NULL && (State & (INSERT|NORMAL))) 2258 { 2259 for (mlen = 0; mlen < typebuf.tb_len && p_pt[mlen]; 2260 ++mlen) 2261 if (p_pt[mlen] != typebuf.tb_buf[typebuf.tb_off 2262 + mlen]) 2263 break; 2264 if (p_pt[mlen] == NUL) /* match */ 2265 { 2266 /* write chars to script file(s) */ 2267 if (mlen > typebuf.tb_maplen) 2268 gotchars(typebuf.tb_buf + typebuf.tb_off 2269 + typebuf.tb_maplen, 2270 mlen - typebuf.tb_maplen); 2271 2272 del_typebuf(mlen, 0); /* remove the chars */ 2273 set_option_value((char_u *)"paste", 2274 (long)!p_paste, NULL, 0); 2275 if (!(State & INSERT)) 2276 { 2277 msg_col = 0; 2278 msg_row = Rows - 1; 2279 msg_clr_eos(); /* clear ruler */ 2280 } 2281 #ifdef FEAT_WINDOWS 2282 status_redraw_all(); 2283 redraw_statuslines(); 2284 #endif 2285 showmode(); 2286 setcursor(); 2287 continue; 2288 } 2289 /* Need more chars for partly match. */ 2290 if (mlen == typebuf.tb_len) 2291 keylen = KEYLEN_PART_KEY; 2292 else if (max_mlen < mlen) 2293 /* no match, may have to check for termcode at 2294 * next character */ 2295 max_mlen = mlen + 1; 2296 } 2297 2298 if ((mp == NULL || max_mlen >= mp_match_len) 2299 && keylen != KEYLEN_PART_MAP) 2300 { 2301 int save_keylen = keylen; 2302 2303 /* 2304 * When no matching mapping found or found a 2305 * non-matching mapping that matches at least what the 2306 * matching mapping matched: 2307 * Check if we have a terminal code, when: 2308 * mapping is allowed, 2309 * keys have not been mapped, 2310 * and not an ESC sequence, not in insert mode or 2311 * p_ek is on, 2312 * and when not timed out, 2313 */ 2314 if ((no_mapping == 0 || allow_keys != 0) 2315 && (typebuf.tb_maplen == 0 2316 || (p_remap && typebuf.tb_noremap[ 2317 typebuf.tb_off] == RM_YES)) 2318 && !timedout) 2319 { 2320 keylen = check_termcode(max_mlen + 1, 2321 NULL, 0, NULL); 2322 2323 /* If no termcode matched but 'pastetoggle' 2324 * matched partially it's like an incomplete key 2325 * sequence. */ 2326 if (keylen == 0 && save_keylen == KEYLEN_PART_KEY) 2327 keylen = KEYLEN_PART_KEY; 2328 2329 /* 2330 * When getting a partial match, but the last 2331 * characters were not typed, don't wait for a 2332 * typed character to complete the termcode. 2333 * This helps a lot when a ":normal" command ends 2334 * in an ESC. 2335 */ 2336 if (keylen < 0 2337 && typebuf.tb_len == typebuf.tb_maplen) 2338 keylen = 0; 2339 } 2340 else 2341 keylen = 0; 2342 if (keylen == 0) /* no matching terminal code */ 2343 { 2344 #ifdef AMIGA /* check for window bounds report */ 2345 if (typebuf.tb_maplen == 0 && (typebuf.tb_buf[ 2346 typebuf.tb_off] & 0xff) == CSI) 2347 { 2348 for (s = typebuf.tb_buf + typebuf.tb_off + 1; 2349 s < typebuf.tb_buf + typebuf.tb_off 2350 + typebuf.tb_len 2351 && (VIM_ISDIGIT(*s) || *s == ';' 2352 || *s == ' '); 2353 ++s) 2354 ; 2355 if (*s == 'r' || *s == '|') /* found one */ 2356 { 2357 del_typebuf((int)(s + 1 - 2358 (typebuf.tb_buf + typebuf.tb_off)), 0); 2359 /* get size and redraw screen */ 2360 shell_resized(); 2361 continue; 2362 } 2363 if (*s == NUL) /* need more characters */ 2364 keylen = KEYLEN_PART_KEY; 2365 } 2366 if (keylen >= 0) 2367 #endif 2368 /* When there was a matching mapping and no 2369 * termcode could be replaced after another one, 2370 * use that mapping (loop around). If there was 2371 * no mapping use the character from the 2372 * typeahead buffer right here. */ 2373 if (mp == NULL) 2374 { 2375 /* 2376 * get a character: 2. from the typeahead buffer 2377 */ 2378 c = typebuf.tb_buf[typebuf.tb_off] & 255; 2379 if (advance) /* remove chars from tb_buf */ 2380 { 2381 cmd_silent = (typebuf.tb_silent > 0); 2382 if (typebuf.tb_maplen > 0) 2383 KeyTyped = FALSE; 2384 else 2385 { 2386 KeyTyped = TRUE; 2387 /* write char to script file(s) */ 2388 gotchars(typebuf.tb_buf 2389 + typebuf.tb_off, 1); 2390 } 2391 KeyNoremap = typebuf.tb_noremap[ 2392 typebuf.tb_off]; 2393 del_typebuf(1, 0); 2394 } 2395 break; /* got character, break for loop */ 2396 } 2397 } 2398 if (keylen > 0) /* full matching terminal code */ 2399 { 2400 #if defined(FEAT_GUI) && defined(FEAT_MENU) 2401 if (typebuf.tb_len >= 2 2402 && typebuf.tb_buf[typebuf.tb_off] == K_SPECIAL 2403 && typebuf.tb_buf[typebuf.tb_off + 1] 2404 == KS_MENU) 2405 { 2406 /* 2407 * Using a menu may cause a break in undo! 2408 * It's like using gotchars(), but without 2409 * recording or writing to a script file. 2410 */ 2411 may_sync_undo(); 2412 del_typebuf(3, 0); 2413 idx = get_menu_index(current_menu, local_State); 2414 if (idx != MENU_INDEX_INVALID) 2415 { 2416 /* 2417 * In Select mode and a Visual mode menu 2418 * is used: Switch to Visual mode 2419 * temporarily. Append K_SELECT to switch 2420 * back to Select mode. 2421 */ 2422 if (VIsual_active && VIsual_select 2423 && (current_menu->modes & VISUAL)) 2424 { 2425 VIsual_select = FALSE; 2426 (void)ins_typebuf(K_SELECT_STRING, 2427 REMAP_NONE, 0, TRUE, FALSE); 2428 } 2429 ins_typebuf(current_menu->strings[idx], 2430 current_menu->noremap[idx], 2431 0, TRUE, 2432 current_menu->silent[idx]); 2433 } 2434 } 2435 #endif /* FEAT_GUI && FEAT_MENU */ 2436 continue; /* try mapping again */ 2437 } 2438 2439 /* Partial match: get some more characters. When a 2440 * matching mapping was found use that one. */ 2441 if (mp == NULL || keylen < 0) 2442 keylen = KEYLEN_PART_KEY; 2443 else 2444 keylen = mp_match_len; 2445 } 2446 2447 /* complete match */ 2448 if (keylen >= 0 && keylen <= typebuf.tb_len) 2449 { 2450 #ifdef FEAT_EVAL 2451 int save_m_expr; 2452 int save_m_noremap; 2453 int save_m_silent; 2454 char_u *save_m_keys; 2455 char_u *save_m_str; 2456 #else 2457 # define save_m_noremap mp->m_noremap 2458 # define save_m_silent mp->m_silent 2459 #endif 2460 2461 /* write chars to script file(s) */ 2462 if (keylen > typebuf.tb_maplen) 2463 gotchars(typebuf.tb_buf + typebuf.tb_off 2464 + typebuf.tb_maplen, 2465 keylen - typebuf.tb_maplen); 2466 2467 cmd_silent = (typebuf.tb_silent > 0); 2468 del_typebuf(keylen, 0); /* remove the mapped keys */ 2469 2470 /* 2471 * Put the replacement string in front of mapstr. 2472 * The depth check catches ":map x y" and ":map y x". 2473 */ 2474 if (++mapdepth >= p_mmd) 2475 { 2476 EMSG(_("E223: recursive mapping")); 2477 if (State & CMDLINE) 2478 redrawcmdline(); 2479 else 2480 setcursor(); 2481 flush_buffers(FALSE); 2482 mapdepth = 0; /* for next one */ 2483 c = -1; 2484 break; 2485 } 2486 2487 /* 2488 * In Select mode and a Visual mode mapping is used: 2489 * Switch to Visual mode temporarily. Append K_SELECT 2490 * to switch back to Select mode. 2491 */ 2492 if (VIsual_active && VIsual_select 2493 && (mp->m_mode & VISUAL)) 2494 { 2495 VIsual_select = FALSE; 2496 (void)ins_typebuf(K_SELECT_STRING, REMAP_NONE, 2497 0, TRUE, FALSE); 2498 } 2499 2500 #ifdef FEAT_EVAL 2501 /* Copy the values from *mp that are used, because 2502 * evaluating the expression may invoke a function 2503 * that redefines the mapping, thereby making *mp 2504 * invalid. */ 2505 save_m_expr = mp->m_expr; 2506 save_m_noremap = mp->m_noremap; 2507 save_m_silent = mp->m_silent; 2508 save_m_keys = NULL; /* only saved when needed */ 2509 save_m_str = NULL; /* only saved when needed */ 2510 2511 /* 2512 * Handle ":map <expr>": evaluate the {rhs} as an 2513 * expression. Also save and restore the command line 2514 * for "normal :". 2515 */ 2516 if (mp->m_expr) 2517 { 2518 int save_vgetc_busy = vgetc_busy; 2519 2520 vgetc_busy = 0; 2521 save_m_keys = vim_strsave(mp->m_keys); 2522 save_m_str = vim_strsave(mp->m_str); 2523 s = eval_map_expr(save_m_str, NUL); 2524 vgetc_busy = save_vgetc_busy; 2525 } 2526 else 2527 #endif 2528 s = mp->m_str; 2529 2530 /* 2531 * Insert the 'to' part in the typebuf.tb_buf. 2532 * If 'from' field is the same as the start of the 2533 * 'to' field, don't remap the first character (but do 2534 * allow abbreviations). 2535 * If m_noremap is set, don't remap the whole 'to' 2536 * part. 2537 */ 2538 if (s == NULL) 2539 i = FAIL; 2540 else 2541 { 2542 int noremap; 2543 2544 if (save_m_noremap != REMAP_YES) 2545 noremap = save_m_noremap; 2546 else if ( 2547 #ifdef FEAT_EVAL 2548 STRNCMP(s, save_m_keys != NULL 2549 ? save_m_keys : mp->m_keys, 2550 (size_t)keylen) 2551 #else 2552 STRNCMP(s, mp->m_keys, (size_t)keylen) 2553 #endif 2554 != 0) 2555 noremap = REMAP_YES; 2556 else 2557 noremap = REMAP_SKIP; 2558 i = ins_typebuf(s, noremap, 2559 0, TRUE, cmd_silent || save_m_silent); 2560 #ifdef FEAT_EVAL 2561 if (save_m_expr) 2562 vim_free(s); 2563 #endif 2564 } 2565 #ifdef FEAT_EVAL 2566 vim_free(save_m_keys); 2567 vim_free(save_m_str); 2568 #endif 2569 if (i == FAIL) 2570 { 2571 c = -1; 2572 break; 2573 } 2574 continue; 2575 } 2576 } 2577 2578 /* 2579 * get a character: 3. from the user - handle <Esc> in Insert mode 2580 */ 2581 /* 2582 * special case: if we get an <ESC> in insert mode and there 2583 * are no more characters at once, we pretend to go out of 2584 * insert mode. This prevents the one second delay after 2585 * typing an <ESC>. If we get something after all, we may 2586 * have to redisplay the mode. That the cursor is in the wrong 2587 * place does not matter. 2588 */ 2589 c = 0; 2590 #ifdef FEAT_CMDL_INFO 2591 new_wcol = curwin->w_wcol; 2592 new_wrow = curwin->w_wrow; 2593 #endif 2594 if ( advance 2595 && typebuf.tb_len == 1 2596 && typebuf.tb_buf[typebuf.tb_off] == ESC 2597 && !no_mapping 2598 && ex_normal_busy == 0 2599 && typebuf.tb_maplen == 0 2600 && (State & INSERT) 2601 && (p_timeout 2602 || (keylen == KEYLEN_PART_KEY && p_ttimeout)) 2603 && (c = inchar(typebuf.tb_buf + typebuf.tb_off 2604 + typebuf.tb_len, 3, 25L, 2605 typebuf.tb_change_cnt)) == 0) 2606 { 2607 colnr_T col = 0, vcol; 2608 char_u *ptr; 2609 2610 if (mode_displayed) 2611 { 2612 unshowmode(TRUE); 2613 mode_deleted = TRUE; 2614 } 2615 #ifdef FEAT_GUI 2616 /* may show different cursor shape */ 2617 if (gui.in_use) 2618 { 2619 int save_State; 2620 2621 save_State = State; 2622 State = NORMAL; 2623 gui_update_cursor(TRUE, FALSE); 2624 State = save_State; 2625 shape_changed = TRUE; 2626 } 2627 #endif 2628 validate_cursor(); 2629 old_wcol = curwin->w_wcol; 2630 old_wrow = curwin->w_wrow; 2631 2632 /* move cursor left, if possible */ 2633 if (curwin->w_cursor.col != 0) 2634 { 2635 if (curwin->w_wcol > 0) 2636 { 2637 if (did_ai) 2638 { 2639 /* 2640 * We are expecting to truncate the trailing 2641 * white-space, so find the last non-white 2642 * character -- webb 2643 */ 2644 col = vcol = curwin->w_wcol = 0; 2645 ptr = ml_get_curline(); 2646 while (col < curwin->w_cursor.col) 2647 { 2648 if (!vim_iswhite(ptr[col])) 2649 curwin->w_wcol = vcol; 2650 vcol += lbr_chartabsize(ptr, ptr + col, 2651 (colnr_T)vcol); 2652 #ifdef FEAT_MBYTE 2653 if (has_mbyte) 2654 col += (*mb_ptr2len)(ptr + col); 2655 else 2656 #endif 2657 ++col; 2658 } 2659 curwin->w_wrow = curwin->w_cline_row 2660 + curwin->w_wcol / W_WIDTH(curwin); 2661 curwin->w_wcol %= W_WIDTH(curwin); 2662 curwin->w_wcol += curwin_col_off(); 2663 #ifdef FEAT_MBYTE 2664 col = 0; /* no correction needed */ 2665 #endif 2666 } 2667 else 2668 { 2669 --curwin->w_wcol; 2670 #ifdef FEAT_MBYTE 2671 col = curwin->w_cursor.col - 1; 2672 #endif 2673 } 2674 } 2675 else if (curwin->w_p_wrap && curwin->w_wrow) 2676 { 2677 --curwin->w_wrow; 2678 curwin->w_wcol = W_WIDTH(curwin) - 1; 2679 #ifdef FEAT_MBYTE 2680 col = curwin->w_cursor.col - 1; 2681 #endif 2682 } 2683 #ifdef FEAT_MBYTE 2684 if (has_mbyte && col > 0 && curwin->w_wcol > 0) 2685 { 2686 /* Correct when the cursor is on the right halve 2687 * of a double-wide character. */ 2688 ptr = ml_get_curline(); 2689 col -= (*mb_head_off)(ptr, ptr + col); 2690 if ((*mb_ptr2cells)(ptr + col) > 1) 2691 --curwin->w_wcol; 2692 } 2693 #endif 2694 } 2695 setcursor(); 2696 out_flush(); 2697 #ifdef FEAT_CMDL_INFO 2698 new_wcol = curwin->w_wcol; 2699 new_wrow = curwin->w_wrow; 2700 #endif 2701 curwin->w_wcol = old_wcol; 2702 curwin->w_wrow = old_wrow; 2703 } 2704 if (c < 0) 2705 continue; /* end of input script reached */ 2706 2707 /* Allow mapping for just typed characters. When we get here c 2708 * is the number of extra bytes and typebuf.tb_len is 1. */ 2709 for (n = 1; n <= c; ++n) 2710 typebuf.tb_noremap[typebuf.tb_off + n] = RM_YES; 2711 typebuf.tb_len += c; 2712 2713 /* buffer full, don't map */ 2714 if (typebuf.tb_len >= typebuf.tb_maplen + MAXMAPLEN) 2715 { 2716 timedout = TRUE; 2717 continue; 2718 } 2719 2720 if (ex_normal_busy > 0) 2721 { 2722 #ifdef FEAT_CMDWIN 2723 static int tc = 0; 2724 #endif 2725 2726 /* No typeahead left and inside ":normal". Must return 2727 * something to avoid getting stuck. When an incomplete 2728 * mapping is present, behave like it timed out. */ 2729 if (typebuf.tb_len > 0) 2730 { 2731 timedout = TRUE; 2732 continue; 2733 } 2734 /* When 'insertmode' is set, ESC just beeps in Insert 2735 * mode. Use CTRL-L to make edit() return. 2736 * For the command line only CTRL-C always breaks it. 2737 * For the cmdline window: Alternate between ESC and 2738 * CTRL-C: ESC for most situations and CTRL-C to close the 2739 * cmdline window. */ 2740 if (p_im && (State & INSERT)) 2741 c = Ctrl_L; 2742 else if ((State & CMDLINE) 2743 #ifdef FEAT_CMDWIN 2744 || (cmdwin_type > 0 && tc == ESC) 2745 #endif 2746 ) 2747 c = Ctrl_C; 2748 else 2749 c = ESC; 2750 #ifdef FEAT_CMDWIN 2751 tc = c; 2752 #endif 2753 break; 2754 } 2755 2756 /* 2757 * get a character: 3. from the user - update display 2758 */ 2759 /* In insert mode a screen update is skipped when characters 2760 * are still available. But when those available characters 2761 * are part of a mapping, and we are going to do a blocking 2762 * wait here. Need to update the screen to display the 2763 * changed text so far. Also for when 'lazyredraw' is set and 2764 * redrawing was postponed because there was something in the 2765 * input buffer (e.g., termresponse). */ 2766 if (((State & INSERT) != 0 || p_lz) && (State & CMDLINE) == 0 2767 && advance && must_redraw != 0 && !need_wait_return) 2768 { 2769 update_screen(0); 2770 setcursor(); /* put cursor back where it belongs */ 2771 } 2772 2773 /* 2774 * If we have a partial match (and are going to wait for more 2775 * input from the user), show the partially matched characters 2776 * to the user with showcmd. 2777 */ 2778 #ifdef FEAT_CMDL_INFO 2779 i = 0; 2780 #endif 2781 c1 = 0; 2782 if (typebuf.tb_len > 0 && advance && !exmode_active) 2783 { 2784 if (((State & (NORMAL | INSERT)) || State == LANGMAP) 2785 && State != HITRETURN) 2786 { 2787 /* this looks nice when typing a dead character map */ 2788 if (State & INSERT 2789 && ptr2cells(typebuf.tb_buf + typebuf.tb_off 2790 + typebuf.tb_len - 1) == 1) 2791 { 2792 edit_putchar(typebuf.tb_buf[typebuf.tb_off 2793 + typebuf.tb_len - 1], FALSE); 2794 setcursor(); /* put cursor back where it belongs */ 2795 c1 = 1; 2796 } 2797 #ifdef FEAT_CMDL_INFO 2798 /* need to use the col and row from above here */ 2799 old_wcol = curwin->w_wcol; 2800 old_wrow = curwin->w_wrow; 2801 curwin->w_wcol = new_wcol; 2802 curwin->w_wrow = new_wrow; 2803 push_showcmd(); 2804 if (typebuf.tb_len > SHOWCMD_COLS) 2805 i = typebuf.tb_len - SHOWCMD_COLS; 2806 while (i < typebuf.tb_len) 2807 (void)add_to_showcmd(typebuf.tb_buf[typebuf.tb_off 2808 + i++]); 2809 curwin->w_wcol = old_wcol; 2810 curwin->w_wrow = old_wrow; 2811 #endif 2812 } 2813 2814 /* this looks nice when typing a dead character map */ 2815 if ((State & CMDLINE) 2816 #if defined(FEAT_CRYPT) || defined(FEAT_EVAL) 2817 && cmdline_star == 0 2818 #endif 2819 && ptr2cells(typebuf.tb_buf + typebuf.tb_off 2820 + typebuf.tb_len - 1) == 1) 2821 { 2822 putcmdline(typebuf.tb_buf[typebuf.tb_off 2823 + typebuf.tb_len - 1], FALSE); 2824 c1 = 1; 2825 } 2826 } 2827 2828 /* 2829 * get a character: 3. from the user - get it 2830 */ 2831 wait_tb_len = typebuf.tb_len; 2832 c = inchar(typebuf.tb_buf + typebuf.tb_off + typebuf.tb_len, 2833 typebuf.tb_buflen - typebuf.tb_off - typebuf.tb_len - 1, 2834 !advance 2835 ? 0 2836 : ((typebuf.tb_len == 0 2837 || !(p_timeout || (p_ttimeout 2838 && keylen == KEYLEN_PART_KEY))) 2839 ? -1L 2840 : ((keylen == KEYLEN_PART_KEY && p_ttm >= 0) 2841 ? p_ttm 2842 : p_tm)), typebuf.tb_change_cnt); 2843 2844 #ifdef FEAT_CMDL_INFO 2845 if (i != 0) 2846 pop_showcmd(); 2847 #endif 2848 if (c1 == 1) 2849 { 2850 if (State & INSERT) 2851 edit_unputchar(); 2852 if (State & CMDLINE) 2853 unputcmdline(); 2854 else 2855 setcursor(); /* put cursor back where it belongs */ 2856 } 2857 2858 if (c < 0) 2859 continue; /* end of input script reached */ 2860 if (c == NUL) /* no character available */ 2861 { 2862 if (!advance) 2863 break; 2864 if (wait_tb_len > 0) /* timed out */ 2865 { 2866 timedout = TRUE; 2867 continue; 2868 } 2869 } 2870 else 2871 { /* allow mapping for just typed characters */ 2872 while (typebuf.tb_buf[typebuf.tb_off 2873 + typebuf.tb_len] != NUL) 2874 typebuf.tb_noremap[typebuf.tb_off 2875 + typebuf.tb_len++] = RM_YES; 2876 #ifdef USE_IM_CONTROL 2877 /* Get IM status right after getting keys, not after the 2878 * timeout for a mapping (focus may be lost by then). */ 2879 vgetc_im_active = im_get_status(); 2880 #endif 2881 } 2882 } /* for (;;) */ 2883 } /* if (!character from stuffbuf) */ 2884 2885 /* if advance is FALSE don't loop on NULs */ 2886 } while (c < 0 || (advance && c == NUL)); 2887 2888 /* 2889 * The "INSERT" message is taken care of here: 2890 * if we return an ESC to exit insert mode, the message is deleted 2891 * if we don't return an ESC but deleted the message before, redisplay it 2892 */ 2893 if (advance && p_smd && msg_silent == 0 && (State & INSERT)) 2894 { 2895 if (c == ESC && !mode_deleted && !no_mapping && mode_displayed) 2896 { 2897 if (typebuf.tb_len && !KeyTyped) 2898 redraw_cmdline = TRUE; /* delete mode later */ 2899 else 2900 unshowmode(FALSE); 2901 } 2902 else if (c != ESC && mode_deleted) 2903 { 2904 if (typebuf.tb_len && !KeyTyped) 2905 redraw_cmdline = TRUE; /* show mode later */ 2906 else 2907 showmode(); 2908 } 2909 } 2910 #ifdef FEAT_GUI 2911 /* may unshow different cursor shape */ 2912 if (gui.in_use && shape_changed) 2913 gui_update_cursor(TRUE, FALSE); 2914 #endif 2915 2916 --vgetc_busy; 2917 2918 return c; 2919 } 2920 2921 /* 2922 * inchar() - get one character from 2923 * 1. a scriptfile 2924 * 2. the keyboard 2925 * 2926 * As much characters as we can get (upto 'maxlen') are put in "buf" and 2927 * NUL terminated (buffer length must be 'maxlen' + 1). 2928 * Minimum for "maxlen" is 3!!!! 2929 * 2930 * "tb_change_cnt" is the value of typebuf.tb_change_cnt if "buf" points into 2931 * it. When typebuf.tb_change_cnt changes (e.g., when a message is received 2932 * from a remote client) "buf" can no longer be used. "tb_change_cnt" is 0 2933 * otherwise. 2934 * 2935 * If we got an interrupt all input is read until none is available. 2936 * 2937 * If wait_time == 0 there is no waiting for the char. 2938 * If wait_time == n we wait for n msec for a character to arrive. 2939 * If wait_time == -1 we wait forever for a character to arrive. 2940 * 2941 * Return the number of obtained characters. 2942 * Return -1 when end of input script reached. 2943 */ 2944 int 2945 inchar( 2946 char_u *buf, 2947 int maxlen, 2948 long wait_time, /* milli seconds */ 2949 int tb_change_cnt) 2950 { 2951 int len = 0; /* init for GCC */ 2952 int retesc = FALSE; /* return ESC with gotint */ 2953 int script_char; 2954 2955 if (wait_time == -1L || wait_time > 100L) /* flush output before waiting */ 2956 { 2957 cursor_on(); 2958 out_flush(); 2959 #ifdef FEAT_GUI 2960 if (gui.in_use) 2961 { 2962 gui_update_cursor(FALSE, FALSE); 2963 # ifdef FEAT_MOUSESHAPE 2964 if (postponed_mouseshape) 2965 update_mouseshape(-1); 2966 # endif 2967 } 2968 #endif 2969 } 2970 2971 /* 2972 * Don't reset these when at the hit-return prompt, otherwise a endless 2973 * recursive loop may result (write error in swapfile, hit-return, timeout 2974 * on char wait, flush swapfile, write error....). 2975 */ 2976 if (State != HITRETURN) 2977 { 2978 did_outofmem_msg = FALSE; /* display out of memory message (again) */ 2979 did_swapwrite_msg = FALSE; /* display swap file write error again */ 2980 } 2981 undo_off = FALSE; /* restart undo now */ 2982 2983 /* 2984 * Get a character from a script file if there is one. 2985 * If interrupted: Stop reading script files, close them all. 2986 */ 2987 script_char = -1; 2988 while (scriptin[curscript] != NULL && script_char < 0 2989 #ifdef FEAT_EVAL 2990 && !ignore_script 2991 #endif 2992 ) 2993 { 2994 2995 #ifdef MESSAGE_QUEUE 2996 parse_queued_messages(); 2997 #endif 2998 2999 if (got_int || (script_char = getc(scriptin[curscript])) < 0) 3000 { 3001 /* Reached EOF. 3002 * Careful: closescript() frees typebuf.tb_buf[] and buf[] may 3003 * point inside typebuf.tb_buf[]. Don't use buf[] after this! */ 3004 closescript(); 3005 /* 3006 * When reading script file is interrupted, return an ESC to get 3007 * back to normal mode. 3008 * Otherwise return -1, because typebuf.tb_buf[] has changed. 3009 */ 3010 if (got_int) 3011 retesc = TRUE; 3012 else 3013 return -1; 3014 } 3015 else 3016 { 3017 buf[0] = script_char; 3018 len = 1; 3019 } 3020 } 3021 3022 if (script_char < 0) /* did not get a character from script */ 3023 { 3024 /* 3025 * If we got an interrupt, skip all previously typed characters and 3026 * return TRUE if quit reading script file. 3027 * Stop reading typeahead when a single CTRL-C was read, 3028 * fill_input_buf() returns this when not able to read from stdin. 3029 * Don't use buf[] here, closescript() may have freed typebuf.tb_buf[] 3030 * and buf may be pointing inside typebuf.tb_buf[]. 3031 */ 3032 if (got_int) 3033 { 3034 #define DUM_LEN MAXMAPLEN * 3 + 3 3035 char_u dum[DUM_LEN + 1]; 3036 3037 for (;;) 3038 { 3039 len = ui_inchar(dum, DUM_LEN, 0L, 0); 3040 if (len == 0 || (len == 1 && dum[0] == 3)) 3041 break; 3042 } 3043 return retesc; 3044 } 3045 3046 /* 3047 * Always flush the output characters when getting input characters 3048 * from the user. 3049 */ 3050 out_flush(); 3051 3052 /* 3053 * Fill up to a third of the buffer, because each character may be 3054 * tripled below. 3055 */ 3056 len = ui_inchar(buf, maxlen / 3, wait_time, tb_change_cnt); 3057 } 3058 3059 if (typebuf_changed(tb_change_cnt)) 3060 return 0; 3061 3062 return fix_input_buffer(buf, len, script_char >= 0); 3063 } 3064 3065 /* 3066 * Fix typed characters for use by vgetc() and check_termcode(). 3067 * buf[] must have room to triple the number of bytes! 3068 * Returns the new length. 3069 */ 3070 int 3071 fix_input_buffer( 3072 char_u *buf, 3073 int len, 3074 int script) /* TRUE when reading from a script */ 3075 { 3076 int i; 3077 char_u *p = buf; 3078 3079 /* 3080 * Two characters are special: NUL and K_SPECIAL. 3081 * When compiled With the GUI CSI is also special. 3082 * Replace NUL by K_SPECIAL KS_ZERO KE_FILLER 3083 * Replace K_SPECIAL by K_SPECIAL KS_SPECIAL KE_FILLER 3084 * Replace CSI by K_SPECIAL KS_EXTRA KE_CSI 3085 * Don't replace K_SPECIAL when reading a script file. 3086 */ 3087 for (i = len; --i >= 0; ++p) 3088 { 3089 #ifdef FEAT_GUI 3090 /* When the GUI is used any character can come after a CSI, don't 3091 * escape it. */ 3092 if (gui.in_use && p[0] == CSI && i >= 2) 3093 { 3094 p += 2; 3095 i -= 2; 3096 } 3097 /* When the GUI is not used CSI needs to be escaped. */ 3098 else if (!gui.in_use && p[0] == CSI) 3099 { 3100 mch_memmove(p + 3, p + 1, (size_t)i); 3101 *p++ = K_SPECIAL; 3102 *p++ = KS_EXTRA; 3103 *p = (int)KE_CSI; 3104 len += 2; 3105 } 3106 else 3107 #endif 3108 if (p[0] == NUL || (p[0] == K_SPECIAL && !script 3109 #ifdef FEAT_AUTOCMD 3110 /* timeout may generate K_CURSORHOLD */ 3111 && (i < 2 || p[1] != KS_EXTRA || p[2] != (int)KE_CURSORHOLD) 3112 #endif 3113 #if defined(WIN3264) && !defined(FEAT_GUI) 3114 /* Win32 console passes modifiers */ 3115 && (i < 2 || p[1] != KS_MODIFIER) 3116 #endif 3117 )) 3118 { 3119 mch_memmove(p + 3, p + 1, (size_t)i); 3120 p[2] = K_THIRD(p[0]); 3121 p[1] = K_SECOND(p[0]); 3122 p[0] = K_SPECIAL; 3123 p += 2; 3124 len += 2; 3125 } 3126 } 3127 *p = NUL; /* add trailing NUL */ 3128 return len; 3129 } 3130 3131 #if defined(USE_INPUT_BUF) || defined(PROTO) 3132 /* 3133 * Return TRUE when bytes are in the input buffer or in the typeahead buffer. 3134 * Normally the input buffer would be sufficient, but the server_to_input_buf() 3135 * or feedkeys() may insert characters in the typeahead buffer while we are 3136 * waiting for input to arrive. 3137 */ 3138 int 3139 input_available(void) 3140 { 3141 return (!vim_is_input_buf_empty() 3142 # if defined(FEAT_CLIENTSERVER) || defined(FEAT_EVAL) 3143 || typebuf_was_filled 3144 # endif 3145 ); 3146 } 3147 #endif 3148 3149 /* 3150 * map[!] : show all key mappings 3151 * map[!] {lhs} : show key mapping for {lhs} 3152 * map[!] {lhs} {rhs} : set key mapping for {lhs} to {rhs} 3153 * noremap[!] {lhs} {rhs} : same, but no remapping for {rhs} 3154 * unmap[!] {lhs} : remove key mapping for {lhs} 3155 * abbr : show all abbreviations 3156 * abbr {lhs} : show abbreviations for {lhs} 3157 * abbr {lhs} {rhs} : set abbreviation for {lhs} to {rhs} 3158 * noreabbr {lhs} {rhs} : same, but no remapping for {rhs} 3159 * unabbr {lhs} : remove abbreviation for {lhs} 3160 * 3161 * maptype: 0 for :map, 1 for :unmap, 2 for noremap. 3162 * 3163 * arg is pointer to any arguments. Note: arg cannot be a read-only string, 3164 * it will be modified. 3165 * 3166 * for :map mode is NORMAL + VISUAL + SELECTMODE + OP_PENDING 3167 * for :map! mode is INSERT + CMDLINE 3168 * for :cmap mode is CMDLINE 3169 * for :imap mode is INSERT 3170 * for :lmap mode is LANGMAP 3171 * for :nmap mode is NORMAL 3172 * for :vmap mode is VISUAL + SELECTMODE 3173 * for :xmap mode is VISUAL 3174 * for :smap mode is SELECTMODE 3175 * for :omap mode is OP_PENDING 3176 * 3177 * for :abbr mode is INSERT + CMDLINE 3178 * for :iabbr mode is INSERT 3179 * for :cabbr mode is CMDLINE 3180 * 3181 * Return 0 for success 3182 * 1 for invalid arguments 3183 * 2 for no match 3184 * 4 for out of mem 3185 * 5 for entry not unique 3186 */ 3187 int 3188 do_map( 3189 int maptype, 3190 char_u *arg, 3191 int mode, 3192 int abbrev) /* not a mapping but an abbreviation */ 3193 { 3194 char_u *keys; 3195 mapblock_T *mp, **mpp; 3196 char_u *rhs; 3197 char_u *p; 3198 int n; 3199 int len = 0; /* init for GCC */ 3200 char_u *newstr; 3201 int hasarg; 3202 int haskey; 3203 int did_it = FALSE; 3204 #ifdef FEAT_LOCALMAP 3205 int did_local = FALSE; 3206 #endif 3207 int round; 3208 char_u *keys_buf = NULL; 3209 char_u *arg_buf = NULL; 3210 int retval = 0; 3211 int do_backslash; 3212 int hash; 3213 int new_hash; 3214 mapblock_T **abbr_table; 3215 mapblock_T **map_table; 3216 int unique = FALSE; 3217 int nowait = FALSE; 3218 int silent = FALSE; 3219 int special = FALSE; 3220 #ifdef FEAT_EVAL 3221 int expr = FALSE; 3222 #endif 3223 int noremap; 3224 char_u *orig_rhs; 3225 3226 keys = arg; 3227 map_table = maphash; 3228 abbr_table = &first_abbr; 3229 3230 /* For ":noremap" don't remap, otherwise do remap. */ 3231 if (maptype == 2) 3232 noremap = REMAP_NONE; 3233 else 3234 noremap = REMAP_YES; 3235 3236 /* Accept <buffer>, <nowait>, <silent>, <expr> <script> and <unique> in 3237 * any order. */ 3238 for (;;) 3239 { 3240 #ifdef FEAT_LOCALMAP 3241 /* 3242 * Check for "<buffer>": mapping local to buffer. 3243 */ 3244 if (STRNCMP(keys, "<buffer>", 8) == 0) 3245 { 3246 keys = skipwhite(keys + 8); 3247 map_table = curbuf->b_maphash; 3248 abbr_table = &curbuf->b_first_abbr; 3249 continue; 3250 } 3251 #endif 3252 3253 /* 3254 * Check for "<nowait>": don't wait for more characters. 3255 */ 3256 if (STRNCMP(keys, "<nowait>", 8) == 0) 3257 { 3258 keys = skipwhite(keys + 8); 3259 nowait = TRUE; 3260 continue; 3261 } 3262 3263 /* 3264 * Check for "<silent>": don't echo commands. 3265 */ 3266 if (STRNCMP(keys, "<silent>", 8) == 0) 3267 { 3268 keys = skipwhite(keys + 8); 3269 silent = TRUE; 3270 continue; 3271 } 3272 3273 /* 3274 * Check for "<special>": accept special keys in <> 3275 */ 3276 if (STRNCMP(keys, "<special>", 9) == 0) 3277 { 3278 keys = skipwhite(keys + 9); 3279 special = TRUE; 3280 continue; 3281 } 3282 3283 #ifdef FEAT_EVAL 3284 /* 3285 * Check for "<script>": remap script-local mappings only 3286 */ 3287 if (STRNCMP(keys, "<script>", 8) == 0) 3288 { 3289 keys = skipwhite(keys + 8); 3290 noremap = REMAP_SCRIPT; 3291 continue; 3292 } 3293 3294 /* 3295 * Check for "<expr>": {rhs} is an expression. 3296 */ 3297 if (STRNCMP(keys, "<expr>", 6) == 0) 3298 { 3299 keys = skipwhite(keys + 6); 3300 expr = TRUE; 3301 continue; 3302 } 3303 #endif 3304 /* 3305 * Check for "<unique>": don't overwrite an existing mapping. 3306 */ 3307 if (STRNCMP(keys, "<unique>", 8) == 0) 3308 { 3309 keys = skipwhite(keys + 8); 3310 unique = TRUE; 3311 continue; 3312 } 3313 break; 3314 } 3315 3316 validate_maphash(); 3317 3318 /* 3319 * Find end of keys and skip CTRL-Vs (and backslashes) in it. 3320 * Accept backslash like CTRL-V when 'cpoptions' does not contain 'B'. 3321 * with :unmap white space is included in the keys, no argument possible. 3322 */ 3323 p = keys; 3324 do_backslash = (vim_strchr(p_cpo, CPO_BSLASH) == NULL); 3325 while (*p && (maptype == 1 || !vim_iswhite(*p))) 3326 { 3327 if ((p[0] == Ctrl_V || (do_backslash && p[0] == '\\')) && 3328 p[1] != NUL) 3329 ++p; /* skip CTRL-V or backslash */ 3330 ++p; 3331 } 3332 if (*p != NUL) 3333 *p++ = NUL; 3334 3335 p = skipwhite(p); 3336 rhs = p; 3337 hasarg = (*rhs != NUL); 3338 haskey = (*keys != NUL); 3339 3340 /* check for :unmap without argument */ 3341 if (maptype == 1 && !haskey) 3342 { 3343 retval = 1; 3344 goto theend; 3345 } 3346 3347 /* 3348 * If mapping has been given as ^V<C_UP> say, then replace the term codes 3349 * with the appropriate two bytes. If it is a shifted special key, unshift 3350 * it too, giving another two bytes. 3351 * replace_termcodes() may move the result to allocated memory, which 3352 * needs to be freed later (*keys_buf and *arg_buf). 3353 * replace_termcodes() also removes CTRL-Vs and sometimes backslashes. 3354 */ 3355 if (haskey) 3356 keys = replace_termcodes(keys, &keys_buf, TRUE, TRUE, special); 3357 orig_rhs = rhs; 3358 if (hasarg) 3359 { 3360 if (STRICMP(rhs, "<nop>") == 0) /* "<Nop>" means nothing */ 3361 rhs = (char_u *)""; 3362 else 3363 rhs = replace_termcodes(rhs, &arg_buf, FALSE, TRUE, special); 3364 } 3365 3366 #ifdef FEAT_FKMAP 3367 /* 3368 * When in right-to-left mode and alternate keymap option set, 3369 * reverse the character flow in the rhs in Farsi. 3370 */ 3371 if (p_altkeymap && curwin->w_p_rl) 3372 lrswap(rhs); 3373 #endif 3374 3375 /* 3376 * check arguments and translate function keys 3377 */ 3378 if (haskey) 3379 { 3380 len = (int)STRLEN(keys); 3381 if (len > MAXMAPLEN) /* maximum length of MAXMAPLEN chars */ 3382 { 3383 retval = 1; 3384 goto theend; 3385 } 3386 3387 if (abbrev && maptype != 1) 3388 { 3389 /* 3390 * If an abbreviation ends in a keyword character, the 3391 * rest must be all keyword-char or all non-keyword-char. 3392 * Otherwise we won't be able to find the start of it in a 3393 * vi-compatible way. 3394 */ 3395 #ifdef FEAT_MBYTE 3396 if (has_mbyte) 3397 { 3398 int first, last; 3399 int same = -1; 3400 3401 first = vim_iswordp(keys); 3402 last = first; 3403 p = keys + (*mb_ptr2len)(keys); 3404 n = 1; 3405 while (p < keys + len) 3406 { 3407 ++n; /* nr of (multi-byte) chars */ 3408 last = vim_iswordp(p); /* type of last char */ 3409 if (same == -1 && last != first) 3410 same = n - 1; /* count of same char type */ 3411 p += (*mb_ptr2len)(p); 3412 } 3413 if (last && n > 2 && same >= 0 && same < n - 1) 3414 { 3415 retval = 1; 3416 goto theend; 3417 } 3418 } 3419 else 3420 #endif 3421 if (vim_iswordc(keys[len - 1])) /* ends in keyword char */ 3422 for (n = 0; n < len - 2; ++n) 3423 if (vim_iswordc(keys[n]) != vim_iswordc(keys[len - 2])) 3424 { 3425 retval = 1; 3426 goto theend; 3427 } 3428 /* An abbreviation cannot contain white space. */ 3429 for (n = 0; n < len; ++n) 3430 if (vim_iswhite(keys[n])) 3431 { 3432 retval = 1; 3433 goto theend; 3434 } 3435 } 3436 } 3437 3438 if (haskey && hasarg && abbrev) /* if we will add an abbreviation */ 3439 no_abbr = FALSE; /* reset flag that indicates there are 3440 no abbreviations */ 3441 3442 if (!haskey || (maptype != 1 && !hasarg)) 3443 msg_start(); 3444 3445 #ifdef FEAT_LOCALMAP 3446 /* 3447 * Check if a new local mapping wasn't already defined globally. 3448 */ 3449 if (map_table == curbuf->b_maphash && haskey && hasarg && maptype != 1) 3450 { 3451 /* need to loop over all global hash lists */ 3452 for (hash = 0; hash < 256 && !got_int; ++hash) 3453 { 3454 if (abbrev) 3455 { 3456 if (hash != 0) /* there is only one abbreviation list */ 3457 break; 3458 mp = first_abbr; 3459 } 3460 else 3461 mp = maphash[hash]; 3462 for ( ; mp != NULL && !got_int; mp = mp->m_next) 3463 { 3464 /* check entries with the same mode */ 3465 if ((mp->m_mode & mode) != 0 3466 && mp->m_keylen == len 3467 && unique 3468 && STRNCMP(mp->m_keys, keys, (size_t)len) == 0) 3469 { 3470 if (abbrev) 3471 EMSG2(_("E224: global abbreviation already exists for %s"), 3472 mp->m_keys); 3473 else 3474 EMSG2(_("E225: global mapping already exists for %s"), 3475 mp->m_keys); 3476 retval = 5; 3477 goto theend; 3478 } 3479 } 3480 } 3481 } 3482 3483 /* 3484 * When listing global mappings, also list buffer-local ones here. 3485 */ 3486 if (map_table != curbuf->b_maphash && !hasarg && maptype != 1) 3487 { 3488 /* need to loop over all global hash lists */ 3489 for (hash = 0; hash < 256 && !got_int; ++hash) 3490 { 3491 if (abbrev) 3492 { 3493 if (hash != 0) /* there is only one abbreviation list */ 3494 break; 3495 mp = curbuf->b_first_abbr; 3496 } 3497 else 3498 mp = curbuf->b_maphash[hash]; 3499 for ( ; mp != NULL && !got_int; mp = mp->m_next) 3500 { 3501 /* check entries with the same mode */ 3502 if ((mp->m_mode & mode) != 0) 3503 { 3504 if (!haskey) /* show all entries */ 3505 { 3506 showmap(mp, TRUE); 3507 did_local = TRUE; 3508 } 3509 else 3510 { 3511 n = mp->m_keylen; 3512 if (STRNCMP(mp->m_keys, keys, 3513 (size_t)(n < len ? n : len)) == 0) 3514 { 3515 showmap(mp, TRUE); 3516 did_local = TRUE; 3517 } 3518 } 3519 } 3520 } 3521 } 3522 } 3523 #endif 3524 3525 /* 3526 * Find an entry in the maphash[] list that matches. 3527 * For :unmap we may loop two times: once to try to unmap an entry with a 3528 * matching 'from' part, a second time, if the first fails, to unmap an 3529 * entry with a matching 'to' part. This was done to allow ":ab foo bar" 3530 * to be unmapped by typing ":unab foo", where "foo" will be replaced by 3531 * "bar" because of the abbreviation. 3532 */ 3533 for (round = 0; (round == 0 || maptype == 1) && round <= 1 3534 && !did_it && !got_int; ++round) 3535 { 3536 /* need to loop over all hash lists */ 3537 for (hash = 0; hash < 256 && !got_int; ++hash) 3538 { 3539 if (abbrev) 3540 { 3541 if (hash > 0) /* there is only one abbreviation list */ 3542 break; 3543 mpp = abbr_table; 3544 } 3545 else 3546 mpp = &(map_table[hash]); 3547 for (mp = *mpp; mp != NULL && !got_int; mp = *mpp) 3548 { 3549 3550 if (!(mp->m_mode & mode)) /* skip entries with wrong mode */ 3551 { 3552 mpp = &(mp->m_next); 3553 continue; 3554 } 3555 if (!haskey) /* show all entries */ 3556 { 3557 showmap(mp, map_table != maphash); 3558 did_it = TRUE; 3559 } 3560 else /* do we have a match? */ 3561 { 3562 if (round) /* second round: Try unmap "rhs" string */ 3563 { 3564 n = (int)STRLEN(mp->m_str); 3565 p = mp->m_str; 3566 } 3567 else 3568 { 3569 n = mp->m_keylen; 3570 p = mp->m_keys; 3571 } 3572 if (STRNCMP(p, keys, (size_t)(n < len ? n : len)) == 0) 3573 { 3574 if (maptype == 1) /* delete entry */ 3575 { 3576 /* Only accept a full match. For abbreviations we 3577 * ignore trailing space when matching with the 3578 * "lhs", since an abbreviation can't have 3579 * trailing space. */ 3580 if (n != len && (!abbrev || round || n > len 3581 || *skipwhite(keys + n) != NUL)) 3582 { 3583 mpp = &(mp->m_next); 3584 continue; 3585 } 3586 /* 3587 * We reset the indicated mode bits. If nothing is 3588 * left the entry is deleted below. 3589 */ 3590 mp->m_mode &= ~mode; 3591 did_it = TRUE; /* remember we did something */ 3592 } 3593 else if (!hasarg) /* show matching entry */ 3594 { 3595 showmap(mp, map_table != maphash); 3596 did_it = TRUE; 3597 } 3598 else if (n != len) /* new entry is ambiguous */ 3599 { 3600 mpp = &(mp->m_next); 3601 continue; 3602 } 3603 else if (unique) 3604 { 3605 if (abbrev) 3606 EMSG2(_("E226: abbreviation already exists for %s"), 3607 p); 3608 else 3609 EMSG2(_("E227: mapping already exists for %s"), p); 3610 retval = 5; 3611 goto theend; 3612 } 3613 else /* new rhs for existing entry */ 3614 { 3615 mp->m_mode &= ~mode; /* remove mode bits */ 3616 if (mp->m_mode == 0 && !did_it) /* reuse entry */ 3617 { 3618 newstr = vim_strsave(rhs); 3619 if (newstr == NULL) 3620 { 3621 retval = 4; /* no mem */ 3622 goto theend; 3623 } 3624 vim_free(mp->m_str); 3625 mp->m_str = newstr; 3626 vim_free(mp->m_orig_str); 3627 mp->m_orig_str = vim_strsave(orig_rhs); 3628 mp->m_noremap = noremap; 3629 mp->m_nowait = nowait; 3630 mp->m_silent = silent; 3631 mp->m_mode = mode; 3632 #ifdef FEAT_EVAL 3633 mp->m_expr = expr; 3634 mp->m_script_ID = current_SID; 3635 #endif 3636 did_it = TRUE; 3637 } 3638 } 3639 if (mp->m_mode == 0) /* entry can be deleted */ 3640 { 3641 map_free(mpp); 3642 continue; /* continue with *mpp */ 3643 } 3644 3645 /* 3646 * May need to put this entry into another hash list. 3647 */ 3648 new_hash = MAP_HASH(mp->m_mode, mp->m_keys[0]); 3649 if (!abbrev && new_hash != hash) 3650 { 3651 *mpp = mp->m_next; 3652 mp->m_next = map_table[new_hash]; 3653 map_table[new_hash] = mp; 3654 3655 continue; /* continue with *mpp */ 3656 } 3657 } 3658 } 3659 mpp = &(mp->m_next); 3660 } 3661 } 3662 } 3663 3664 if (maptype == 1) /* delete entry */ 3665 { 3666 if (!did_it) 3667 retval = 2; /* no match */ 3668 else if (*keys == Ctrl_C) 3669 { 3670 /* If CTRL-C has been unmapped, reuse it for Interrupting. */ 3671 #ifdef FEAT_LOCALMAP 3672 if (map_table == curbuf->b_maphash) 3673 curbuf->b_mapped_ctrl_c &= ~mode; 3674 else 3675 #endif 3676 mapped_ctrl_c &= ~mode; 3677 } 3678 goto theend; 3679 } 3680 3681 if (!haskey || !hasarg) /* print entries */ 3682 { 3683 if (!did_it 3684 #ifdef FEAT_LOCALMAP 3685 && !did_local 3686 #endif 3687 ) 3688 { 3689 if (abbrev) 3690 MSG(_("No abbreviation found")); 3691 else 3692 MSG(_("No mapping found")); 3693 } 3694 goto theend; /* listing finished */ 3695 } 3696 3697 if (did_it) /* have added the new entry already */ 3698 goto theend; 3699 3700 /* 3701 * Get here when adding a new entry to the maphash[] list or abbrlist. 3702 */ 3703 mp = (mapblock_T *)alloc((unsigned)sizeof(mapblock_T)); 3704 if (mp == NULL) 3705 { 3706 retval = 4; /* no mem */ 3707 goto theend; 3708 } 3709 3710 /* If CTRL-C has been mapped, don't always use it for Interrupting. */ 3711 if (*keys == Ctrl_C) 3712 { 3713 #ifdef FEAT_LOCALMAP 3714 if (map_table == curbuf->b_maphash) 3715 curbuf->b_mapped_ctrl_c |= mode; 3716 else 3717 #endif 3718 mapped_ctrl_c |= mode; 3719 } 3720 3721 mp->m_keys = vim_strsave(keys); 3722 mp->m_str = vim_strsave(rhs); 3723 mp->m_orig_str = vim_strsave(orig_rhs); 3724 if (mp->m_keys == NULL || mp->m_str == NULL) 3725 { 3726 vim_free(mp->m_keys); 3727 vim_free(mp->m_str); 3728 vim_free(mp->m_orig_str); 3729 vim_free(mp); 3730 retval = 4; /* no mem */ 3731 goto theend; 3732 } 3733 mp->m_keylen = (int)STRLEN(mp->m_keys); 3734 mp->m_noremap = noremap; 3735 mp->m_nowait = nowait; 3736 mp->m_silent = silent; 3737 mp->m_mode = mode; 3738 #ifdef FEAT_EVAL 3739 mp->m_expr = expr; 3740 mp->m_script_ID = current_SID; 3741 #endif 3742 3743 /* add the new entry in front of the abbrlist or maphash[] list */ 3744 if (abbrev) 3745 { 3746 mp->m_next = *abbr_table; 3747 *abbr_table = mp; 3748 } 3749 else 3750 { 3751 n = MAP_HASH(mp->m_mode, mp->m_keys[0]); 3752 mp->m_next = map_table[n]; 3753 map_table[n] = mp; 3754 } 3755 3756 theend: 3757 vim_free(keys_buf); 3758 vim_free(arg_buf); 3759 return retval; 3760 } 3761 3762 /* 3763 * Delete one entry from the abbrlist or maphash[]. 3764 * "mpp" is a pointer to the m_next field of the PREVIOUS entry! 3765 */ 3766 static void 3767 map_free(mapblock_T **mpp) 3768 { 3769 mapblock_T *mp; 3770 3771 mp = *mpp; 3772 vim_free(mp->m_keys); 3773 vim_free(mp->m_str); 3774 vim_free(mp->m_orig_str); 3775 *mpp = mp->m_next; 3776 vim_free(mp); 3777 } 3778 3779 /* 3780 * Initialize maphash[] for first use. 3781 */ 3782 static void 3783 validate_maphash(void) 3784 { 3785 if (!maphash_valid) 3786 { 3787 vim_memset(maphash, 0, sizeof(maphash)); 3788 maphash_valid = TRUE; 3789 } 3790 } 3791 3792 /* 3793 * Get the mapping mode from the command name. 3794 */ 3795 int 3796 get_map_mode(char_u **cmdp, int forceit) 3797 { 3798 char_u *p; 3799 int modec; 3800 int mode; 3801 3802 p = *cmdp; 3803 modec = *p++; 3804 if (modec == 'i') 3805 mode = INSERT; /* :imap */ 3806 else if (modec == 'l') 3807 mode = LANGMAP; /* :lmap */ 3808 else if (modec == 'c') 3809 mode = CMDLINE; /* :cmap */ 3810 else if (modec == 'n' && *p != 'o') /* avoid :noremap */ 3811 mode = NORMAL; /* :nmap */ 3812 else if (modec == 'v') 3813 mode = VISUAL + SELECTMODE; /* :vmap */ 3814 else if (modec == 'x') 3815 mode = VISUAL; /* :xmap */ 3816 else if (modec == 's') 3817 mode = SELECTMODE; /* :smap */ 3818 else if (modec == 'o') 3819 mode = OP_PENDING; /* :omap */ 3820 else 3821 { 3822 --p; 3823 if (forceit) 3824 mode = INSERT + CMDLINE; /* :map ! */ 3825 else 3826 mode = VISUAL + SELECTMODE + NORMAL + OP_PENDING;/* :map */ 3827 } 3828 3829 *cmdp = p; 3830 return mode; 3831 } 3832 3833 /* 3834 * Clear all mappings or abbreviations. 3835 * 'abbr' should be FALSE for mappings, TRUE for abbreviations. 3836 */ 3837 void 3838 map_clear( 3839 char_u *cmdp, 3840 char_u *arg UNUSED, 3841 int forceit, 3842 int abbr) 3843 { 3844 int mode; 3845 #ifdef FEAT_LOCALMAP 3846 int local; 3847 3848 local = (STRCMP(arg, "<buffer>") == 0); 3849 if (!local && *arg != NUL) 3850 { 3851 EMSG(_(e_invarg)); 3852 return; 3853 } 3854 #endif 3855 3856 mode = get_map_mode(&cmdp, forceit); 3857 map_clear_int(curbuf, mode, 3858 #ifdef FEAT_LOCALMAP 3859 local, 3860 #else 3861 FALSE, 3862 #endif 3863 abbr); 3864 } 3865 3866 /* 3867 * Clear all mappings in "mode". 3868 */ 3869 void 3870 map_clear_int( 3871 buf_T *buf UNUSED, /* buffer for local mappings */ 3872 int mode, /* mode in which to delete */ 3873 int local UNUSED, /* TRUE for buffer-local mappings */ 3874 int abbr) /* TRUE for abbreviations */ 3875 { 3876 mapblock_T *mp, **mpp; 3877 int hash; 3878 int new_hash; 3879 3880 validate_maphash(); 3881 3882 for (hash = 0; hash < 256; ++hash) 3883 { 3884 if (abbr) 3885 { 3886 if (hash > 0) /* there is only one abbrlist */ 3887 break; 3888 #ifdef FEAT_LOCALMAP 3889 if (local) 3890 mpp = &buf->b_first_abbr; 3891 else 3892 #endif 3893 mpp = &first_abbr; 3894 } 3895 else 3896 { 3897 #ifdef FEAT_LOCALMAP 3898 if (local) 3899 mpp = &buf->b_maphash[hash]; 3900 else 3901 #endif 3902 mpp = &maphash[hash]; 3903 } 3904 while (*mpp != NULL) 3905 { 3906 mp = *mpp; 3907 if (mp->m_mode & mode) 3908 { 3909 mp->m_mode &= ~mode; 3910 if (mp->m_mode == 0) /* entry can be deleted */ 3911 { 3912 map_free(mpp); 3913 continue; 3914 } 3915 /* 3916 * May need to put this entry into another hash list. 3917 */ 3918 new_hash = MAP_HASH(mp->m_mode, mp->m_keys[0]); 3919 if (!abbr && new_hash != hash) 3920 { 3921 *mpp = mp->m_next; 3922 #ifdef FEAT_LOCALMAP 3923 if (local) 3924 { 3925 mp->m_next = buf->b_maphash[new_hash]; 3926 buf->b_maphash[new_hash] = mp; 3927 } 3928 else 3929 #endif 3930 { 3931 mp->m_next = maphash[new_hash]; 3932 maphash[new_hash] = mp; 3933 } 3934 continue; /* continue with *mpp */ 3935 } 3936 } 3937 mpp = &(mp->m_next); 3938 } 3939 } 3940 } 3941 3942 /* 3943 * Return characters to represent the map mode in an allocated string. 3944 * Returns NULL when out of memory. 3945 */ 3946 char_u * 3947 map_mode_to_chars(int mode) 3948 { 3949 garray_T mapmode; 3950 3951 ga_init2(&mapmode, 1, 7); 3952 3953 if ((mode & (INSERT + CMDLINE)) == INSERT + CMDLINE) 3954 ga_append(&mapmode, '!'); /* :map! */ 3955 else if (mode & INSERT) 3956 ga_append(&mapmode, 'i'); /* :imap */ 3957 else if (mode & LANGMAP) 3958 ga_append(&mapmode, 'l'); /* :lmap */ 3959 else if (mode & CMDLINE) 3960 ga_append(&mapmode, 'c'); /* :cmap */ 3961 else if ((mode & (NORMAL + VISUAL + SELECTMODE + OP_PENDING)) 3962 == NORMAL + VISUAL + SELECTMODE + OP_PENDING) 3963 ga_append(&mapmode, ' '); /* :map */ 3964 else 3965 { 3966 if (mode & NORMAL) 3967 ga_append(&mapmode, 'n'); /* :nmap */ 3968 if (mode & OP_PENDING) 3969 ga_append(&mapmode, 'o'); /* :omap */ 3970 if ((mode & (VISUAL + SELECTMODE)) == VISUAL + SELECTMODE) 3971 ga_append(&mapmode, 'v'); /* :vmap */ 3972 else 3973 { 3974 if (mode & VISUAL) 3975 ga_append(&mapmode, 'x'); /* :xmap */ 3976 if (mode & SELECTMODE) 3977 ga_append(&mapmode, 's'); /* :smap */ 3978 } 3979 } 3980 3981 ga_append(&mapmode, NUL); 3982 return (char_u *)mapmode.ga_data; 3983 } 3984 3985 static void 3986 showmap( 3987 mapblock_T *mp, 3988 int local) /* TRUE for buffer-local map */ 3989 { 3990 int len = 1; 3991 char_u *mapchars; 3992 3993 if (msg_didout || msg_silent != 0) 3994 { 3995 msg_putchar('\n'); 3996 if (got_int) /* 'q' typed at MORE prompt */ 3997 return; 3998 } 3999 4000 mapchars = map_mode_to_chars(mp->m_mode); 4001 if (mapchars != NULL) 4002 { 4003 msg_puts(mapchars); 4004 len = (int)STRLEN(mapchars); 4005 vim_free(mapchars); 4006 } 4007 4008 while (++len <= 3) 4009 msg_putchar(' '); 4010 4011 /* Display the LHS. Get length of what we write. */ 4012 len = msg_outtrans_special(mp->m_keys, TRUE); 4013 do 4014 { 4015 msg_putchar(' '); /* padd with blanks */ 4016 ++len; 4017 } while (len < 12); 4018 4019 if (mp->m_noremap == REMAP_NONE) 4020 msg_puts_attr((char_u *)"*", hl_attr(HLF_8)); 4021 else if (mp->m_noremap == REMAP_SCRIPT) 4022 msg_puts_attr((char_u *)"&", hl_attr(HLF_8)); 4023 else 4024 msg_putchar(' '); 4025 4026 if (local) 4027 msg_putchar('@'); 4028 else 4029 msg_putchar(' '); 4030 4031 /* Use FALSE below if we only want things like <Up> to show up as such on 4032 * the rhs, and not M-x etc, TRUE gets both -- webb */ 4033 if (*mp->m_str == NUL) 4034 msg_puts_attr((char_u *)"<Nop>", hl_attr(HLF_8)); 4035 else 4036 { 4037 /* Remove escaping of CSI, because "m_str" is in a format to be used 4038 * as typeahead. */ 4039 char_u *s = vim_strsave(mp->m_str); 4040 if (s != NULL) 4041 { 4042 vim_unescape_csi(s); 4043 msg_outtrans_special(s, FALSE); 4044 vim_free(s); 4045 } 4046 } 4047 #ifdef FEAT_EVAL 4048 if (p_verbose > 0) 4049 last_set_msg(mp->m_script_ID); 4050 #endif 4051 out_flush(); /* show one line at a time */ 4052 } 4053 4054 #if defined(FEAT_EVAL) || defined(PROTO) 4055 /* 4056 * Return TRUE if a map exists that has "str" in the rhs for mode "modechars". 4057 * Recognize termcap codes in "str". 4058 * Also checks mappings local to the current buffer. 4059 */ 4060 int 4061 map_to_exists(char_u *str, char_u *modechars, int abbr) 4062 { 4063 int mode = 0; 4064 char_u *rhs; 4065 char_u *buf; 4066 int retval; 4067 4068 rhs = replace_termcodes(str, &buf, FALSE, TRUE, FALSE); 4069 4070 if (vim_strchr(modechars, 'n') != NULL) 4071 mode |= NORMAL; 4072 if (vim_strchr(modechars, 'v') != NULL) 4073 mode |= VISUAL + SELECTMODE; 4074 if (vim_strchr(modechars, 'x') != NULL) 4075 mode |= VISUAL; 4076 if (vim_strchr(modechars, 's') != NULL) 4077 mode |= SELECTMODE; 4078 if (vim_strchr(modechars, 'o') != NULL) 4079 mode |= OP_PENDING; 4080 if (vim_strchr(modechars, 'i') != NULL) 4081 mode |= INSERT; 4082 if (vim_strchr(modechars, 'l') != NULL) 4083 mode |= LANGMAP; 4084 if (vim_strchr(modechars, 'c') != NULL) 4085 mode |= CMDLINE; 4086 4087 retval = map_to_exists_mode(rhs, mode, abbr); 4088 vim_free(buf); 4089 4090 return retval; 4091 } 4092 #endif 4093 4094 /* 4095 * Return TRUE if a map exists that has "str" in the rhs for mode "mode". 4096 * Also checks mappings local to the current buffer. 4097 */ 4098 int 4099 map_to_exists_mode(char_u *rhs, int mode, int abbr) 4100 { 4101 mapblock_T *mp; 4102 int hash; 4103 # ifdef FEAT_LOCALMAP 4104 int expand_buffer = FALSE; 4105 4106 validate_maphash(); 4107 4108 /* Do it twice: once for global maps and once for local maps. */ 4109 for (;;) 4110 { 4111 # endif 4112 for (hash = 0; hash < 256; ++hash) 4113 { 4114 if (abbr) 4115 { 4116 if (hash > 0) /* there is only one abbr list */ 4117 break; 4118 #ifdef FEAT_LOCALMAP 4119 if (expand_buffer) 4120 mp = curbuf->b_first_abbr; 4121 else 4122 #endif 4123 mp = first_abbr; 4124 } 4125 # ifdef FEAT_LOCALMAP 4126 else if (expand_buffer) 4127 mp = curbuf->b_maphash[hash]; 4128 # endif 4129 else 4130 mp = maphash[hash]; 4131 for (; mp; mp = mp->m_next) 4132 { 4133 if ((mp->m_mode & mode) 4134 && strstr((char *)mp->m_str, (char *)rhs) != NULL) 4135 return TRUE; 4136 } 4137 } 4138 # ifdef FEAT_LOCALMAP 4139 if (expand_buffer) 4140 break; 4141 expand_buffer = TRUE; 4142 } 4143 # endif 4144 4145 return FALSE; 4146 } 4147 4148 #if defined(FEAT_CMDL_COMPL) || defined(PROTO) 4149 /* 4150 * Used below when expanding mapping/abbreviation names. 4151 */ 4152 static int expand_mapmodes = 0; 4153 static int expand_isabbrev = 0; 4154 #ifdef FEAT_LOCALMAP 4155 static int expand_buffer = FALSE; 4156 #endif 4157 4158 /* 4159 * Work out what to complete when doing command line completion of mapping 4160 * or abbreviation names. 4161 */ 4162 char_u * 4163 set_context_in_map_cmd( 4164 expand_T *xp, 4165 char_u *cmd, 4166 char_u *arg, 4167 int forceit, /* TRUE if '!' given */ 4168 int isabbrev, /* TRUE if abbreviation */ 4169 int isunmap, /* TRUE if unmap/unabbrev command */ 4170 cmdidx_T cmdidx) 4171 { 4172 if (forceit && cmdidx != CMD_map && cmdidx != CMD_unmap) 4173 xp->xp_context = EXPAND_NOTHING; 4174 else 4175 { 4176 if (isunmap) 4177 expand_mapmodes = get_map_mode(&cmd, forceit || isabbrev); 4178 else 4179 { 4180 expand_mapmodes = INSERT + CMDLINE; 4181 if (!isabbrev) 4182 expand_mapmodes += VISUAL + SELECTMODE + NORMAL + OP_PENDING; 4183 } 4184 expand_isabbrev = isabbrev; 4185 xp->xp_context = EXPAND_MAPPINGS; 4186 #ifdef FEAT_LOCALMAP 4187 expand_buffer = FALSE; 4188 #endif 4189 for (;;) 4190 { 4191 #ifdef FEAT_LOCALMAP 4192 if (STRNCMP(arg, "<buffer>", 8) == 0) 4193 { 4194 expand_buffer = TRUE; 4195 arg = skipwhite(arg + 8); 4196 continue; 4197 } 4198 #endif 4199 if (STRNCMP(arg, "<unique>", 8) == 0) 4200 { 4201 arg = skipwhite(arg + 8); 4202 continue; 4203 } 4204 if (STRNCMP(arg, "<nowait>", 8) == 0) 4205 { 4206 arg = skipwhite(arg + 8); 4207 continue; 4208 } 4209 if (STRNCMP(arg, "<silent>", 8) == 0) 4210 { 4211 arg = skipwhite(arg + 8); 4212 continue; 4213 } 4214 #ifdef FEAT_EVAL 4215 if (STRNCMP(arg, "<script>", 8) == 0) 4216 { 4217 arg = skipwhite(arg + 8); 4218 continue; 4219 } 4220 if (STRNCMP(arg, "<expr>", 6) == 0) 4221 { 4222 arg = skipwhite(arg + 6); 4223 continue; 4224 } 4225 #endif 4226 break; 4227 } 4228 xp->xp_pattern = arg; 4229 } 4230 4231 return NULL; 4232 } 4233 4234 /* 4235 * Find all mapping/abbreviation names that match regexp 'prog'. 4236 * For command line expansion of ":[un]map" and ":[un]abbrev" in all modes. 4237 * Return OK if matches found, FAIL otherwise. 4238 */ 4239 int 4240 ExpandMappings( 4241 regmatch_T *regmatch, 4242 int *num_file, 4243 char_u ***file) 4244 { 4245 mapblock_T *mp; 4246 int hash; 4247 int count; 4248 int round; 4249 char_u *p; 4250 int i; 4251 4252 validate_maphash(); 4253 4254 *num_file = 0; /* return values in case of FAIL */ 4255 *file = NULL; 4256 4257 /* 4258 * round == 1: Count the matches. 4259 * round == 2: Build the array to keep the matches. 4260 */ 4261 for (round = 1; round <= 2; ++round) 4262 { 4263 count = 0; 4264 4265 for (i = 0; i < 6; ++i) 4266 { 4267 if (i == 0) 4268 p = (char_u *)"<silent>"; 4269 else if (i == 1) 4270 p = (char_u *)"<unique>"; 4271 #ifdef FEAT_EVAL 4272 else if (i == 2) 4273 p = (char_u *)"<script>"; 4274 else if (i == 3) 4275 p = (char_u *)"<expr>"; 4276 #endif 4277 #ifdef FEAT_LOCALMAP 4278 else if (i == 4 && !expand_buffer) 4279 p = (char_u *)"<buffer>"; 4280 #endif 4281 else if (i == 5) 4282 p = (char_u *)"<nowait>"; 4283 else 4284 continue; 4285 4286 if (vim_regexec(regmatch, p, (colnr_T)0)) 4287 { 4288 if (round == 1) 4289 ++count; 4290 else 4291 (*file)[count++] = vim_strsave(p); 4292 } 4293 } 4294 4295 for (hash = 0; hash < 256; ++hash) 4296 { 4297 if (expand_isabbrev) 4298 { 4299 if (hash > 0) /* only one abbrev list */ 4300 break; /* for (hash) */ 4301 mp = first_abbr; 4302 } 4303 #ifdef FEAT_LOCALMAP 4304 else if (expand_buffer) 4305 mp = curbuf->b_maphash[hash]; 4306 #endif 4307 else 4308 mp = maphash[hash]; 4309 for (; mp; mp = mp->m_next) 4310 { 4311 if (mp->m_mode & expand_mapmodes) 4312 { 4313 p = translate_mapping(mp->m_keys, TRUE); 4314 if (p != NULL && vim_regexec(regmatch, p, (colnr_T)0)) 4315 { 4316 if (round == 1) 4317 ++count; 4318 else 4319 { 4320 (*file)[count++] = p; 4321 p = NULL; 4322 } 4323 } 4324 vim_free(p); 4325 } 4326 } /* for (mp) */ 4327 } /* for (hash) */ 4328 4329 if (count == 0) /* no match found */ 4330 break; /* for (round) */ 4331 4332 if (round == 1) 4333 { 4334 *file = (char_u **)alloc((unsigned)(count * sizeof(char_u *))); 4335 if (*file == NULL) 4336 return FAIL; 4337 } 4338 } /* for (round) */ 4339 4340 if (count > 1) 4341 { 4342 char_u **ptr1; 4343 char_u **ptr2; 4344 char_u **ptr3; 4345 4346 /* Sort the matches */ 4347 sort_strings(*file, count); 4348 4349 /* Remove multiple entries */ 4350 ptr1 = *file; 4351 ptr2 = ptr1 + 1; 4352 ptr3 = ptr1 + count; 4353 4354 while (ptr2 < ptr3) 4355 { 4356 if (STRCMP(*ptr1, *ptr2)) 4357 *++ptr1 = *ptr2++; 4358 else 4359 { 4360 vim_free(*ptr2++); 4361 count--; 4362 } 4363 } 4364 } 4365 4366 *num_file = count; 4367 return (count == 0 ? FAIL : OK); 4368 } 4369 #endif /* FEAT_CMDL_COMPL */ 4370 4371 /* 4372 * Check for an abbreviation. 4373 * Cursor is at ptr[col]. When inserting, mincol is where insert started. 4374 * "c" is the character typed before check_abbr was called. It may have 4375 * ABBR_OFF added to avoid prepending a CTRL-V to it. 4376 * 4377 * Historic vi practice: The last character of an abbreviation must be an id 4378 * character ([a-zA-Z0-9_]). The characters in front of it must be all id 4379 * characters or all non-id characters. This allows for abbr. "#i" to 4380 * "#include". 4381 * 4382 * Vim addition: Allow for abbreviations that end in a non-keyword character. 4383 * Then there must be white space before the abbr. 4384 * 4385 * return TRUE if there is an abbreviation, FALSE if not 4386 */ 4387 int 4388 check_abbr( 4389 int c, 4390 char_u *ptr, 4391 int col, 4392 int mincol) 4393 { 4394 int len; 4395 int scol; /* starting column of the abbr. */ 4396 int j; 4397 char_u *s; 4398 char_u tb[MB_MAXBYTES + 4]; 4399 mapblock_T *mp; 4400 #ifdef FEAT_LOCALMAP 4401 mapblock_T *mp2; 4402 #endif 4403 #ifdef FEAT_MBYTE 4404 int clen = 0; /* length in characters */ 4405 #endif 4406 int is_id = TRUE; 4407 int vim_abbr; 4408 4409 if (typebuf.tb_no_abbr_cnt) /* abbrev. are not recursive */ 4410 return FALSE; 4411 4412 /* no remapping implies no abbreviation, except for CTRL-] */ 4413 if ((KeyNoremap & (RM_NONE|RM_SCRIPT)) != 0 && c != Ctrl_RSB) 4414 return FALSE; 4415 4416 /* 4417 * Check for word before the cursor: If it ends in a keyword char all 4418 * chars before it must be keyword chars or non-keyword chars, but not 4419 * white space. If it ends in a non-keyword char we accept any characters 4420 * before it except white space. 4421 */ 4422 if (col == 0) /* cannot be an abbr. */ 4423 return FALSE; 4424 4425 #ifdef FEAT_MBYTE 4426 if (has_mbyte) 4427 { 4428 char_u *p; 4429 4430 p = mb_prevptr(ptr, ptr + col); 4431 if (!vim_iswordp(p)) 4432 vim_abbr = TRUE; /* Vim added abbr. */ 4433 else 4434 { 4435 vim_abbr = FALSE; /* vi compatible abbr. */ 4436 if (p > ptr) 4437 is_id = vim_iswordp(mb_prevptr(ptr, p)); 4438 } 4439 clen = 1; 4440 while (p > ptr + mincol) 4441 { 4442 p = mb_prevptr(ptr, p); 4443 if (vim_isspace(*p) || (!vim_abbr && is_id != vim_iswordp(p))) 4444 { 4445 p += (*mb_ptr2len)(p); 4446 break; 4447 } 4448 ++clen; 4449 } 4450 scol = (int)(p - ptr); 4451 } 4452 else 4453 #endif 4454 { 4455 if (!vim_iswordc(ptr[col - 1])) 4456 vim_abbr = TRUE; /* Vim added abbr. */ 4457 else 4458 { 4459 vim_abbr = FALSE; /* vi compatible abbr. */ 4460 if (col > 1) 4461 is_id = vim_iswordc(ptr[col - 2]); 4462 } 4463 for (scol = col - 1; scol > 0 && !vim_isspace(ptr[scol - 1]) 4464 && (vim_abbr || is_id == vim_iswordc(ptr[scol - 1])); --scol) 4465 ; 4466 } 4467 4468 if (scol < mincol) 4469 scol = mincol; 4470 if (scol < col) /* there is a word in front of the cursor */ 4471 { 4472 ptr += scol; 4473 len = col - scol; 4474 #ifdef FEAT_LOCALMAP 4475 mp = curbuf->b_first_abbr; 4476 mp2 = first_abbr; 4477 if (mp == NULL) 4478 { 4479 mp = mp2; 4480 mp2 = NULL; 4481 } 4482 #else 4483 mp = first_abbr; 4484 #endif 4485 for ( ; mp; 4486 #ifdef FEAT_LOCALMAP 4487 mp->m_next == NULL ? (mp = mp2, mp2 = NULL) : 4488 #endif 4489 (mp = mp->m_next)) 4490 { 4491 int qlen = mp->m_keylen; 4492 char_u *q = mp->m_keys; 4493 int match; 4494 4495 if (vim_strbyte(mp->m_keys, K_SPECIAL) != NULL) 4496 { 4497 /* might have CSI escaped mp->m_keys */ 4498 q = vim_strsave(mp->m_keys); 4499 if (q != NULL) 4500 { 4501 vim_unescape_csi(q); 4502 qlen = (int)STRLEN(q); 4503 } 4504 } 4505 4506 /* find entries with right mode and keys */ 4507 match = (mp->m_mode & State) 4508 && qlen == len 4509 && !STRNCMP(q, ptr, (size_t)len); 4510 if (q != mp->m_keys) 4511 vim_free(q); 4512 if (match) 4513 break; 4514 } 4515 if (mp != NULL) 4516 { 4517 /* 4518 * Found a match: 4519 * Insert the rest of the abbreviation in typebuf.tb_buf[]. 4520 * This goes from end to start. 4521 * 4522 * Characters 0x000 - 0x100: normal chars, may need CTRL-V, 4523 * except K_SPECIAL: Becomes K_SPECIAL KS_SPECIAL KE_FILLER 4524 * Characters where IS_SPECIAL() == TRUE: key codes, need 4525 * K_SPECIAL. Other characters (with ABBR_OFF): don't use CTRL-V. 4526 * 4527 * Character CTRL-] is treated specially - it completes the 4528 * abbreviation, but is not inserted into the input stream. 4529 */ 4530 j = 0; 4531 if (c != Ctrl_RSB) 4532 { 4533 /* special key code, split up */ 4534 if (IS_SPECIAL(c) || c == K_SPECIAL) 4535 { 4536 tb[j++] = K_SPECIAL; 4537 tb[j++] = K_SECOND(c); 4538 tb[j++] = K_THIRD(c); 4539 } 4540 else 4541 { 4542 if (c < ABBR_OFF && (c < ' ' || c > '~')) 4543 tb[j++] = Ctrl_V; /* special char needs CTRL-V */ 4544 #ifdef FEAT_MBYTE 4545 if (has_mbyte) 4546 { 4547 /* if ABBR_OFF has been added, remove it here */ 4548 if (c >= ABBR_OFF) 4549 c -= ABBR_OFF; 4550 j += (*mb_char2bytes)(c, tb + j); 4551 } 4552 else 4553 #endif 4554 tb[j++] = c; 4555 } 4556 tb[j] = NUL; 4557 /* insert the last typed char */ 4558 (void)ins_typebuf(tb, 1, 0, TRUE, mp->m_silent); 4559 } 4560 #ifdef FEAT_EVAL 4561 if (mp->m_expr) 4562 s = eval_map_expr(mp->m_str, c); 4563 else 4564 #endif 4565 s = mp->m_str; 4566 if (s != NULL) 4567 { 4568 /* insert the to string */ 4569 (void)ins_typebuf(s, mp->m_noremap, 0, TRUE, mp->m_silent); 4570 /* no abbrev. for these chars */ 4571 typebuf.tb_no_abbr_cnt += (int)STRLEN(s) + j + 1; 4572 #ifdef FEAT_EVAL 4573 if (mp->m_expr) 4574 vim_free(s); 4575 #endif 4576 } 4577 4578 tb[0] = Ctrl_H; 4579 tb[1] = NUL; 4580 #ifdef FEAT_MBYTE 4581 if (has_mbyte) 4582 len = clen; /* Delete characters instead of bytes */ 4583 #endif 4584 while (len-- > 0) /* delete the from string */ 4585 (void)ins_typebuf(tb, 1, 0, TRUE, mp->m_silent); 4586 return TRUE; 4587 } 4588 } 4589 return FALSE; 4590 } 4591 4592 #ifdef FEAT_EVAL 4593 /* 4594 * Evaluate the RHS of a mapping or abbreviations and take care of escaping 4595 * special characters. 4596 */ 4597 static char_u * 4598 eval_map_expr( 4599 char_u *str, 4600 int c) /* NUL or typed character for abbreviation */ 4601 { 4602 char_u *res; 4603 char_u *p; 4604 char_u *expr; 4605 char_u *save_cmd; 4606 pos_T save_cursor; 4607 int save_msg_col; 4608 int save_msg_row; 4609 4610 /* Remove escaping of CSI, because "str" is in a format to be used as 4611 * typeahead. */ 4612 expr = vim_strsave(str); 4613 if (expr == NULL) 4614 return NULL; 4615 vim_unescape_csi(expr); 4616 4617 save_cmd = save_cmdline_alloc(); 4618 if (save_cmd == NULL) 4619 { 4620 vim_free(expr); 4621 return NULL; 4622 } 4623 4624 /* Forbid changing text or using ":normal" to avoid most of the bad side 4625 * effects. Also restore the cursor position. */ 4626 ++textlock; 4627 ++ex_normal_lock; 4628 set_vim_var_char(c); /* set v:char to the typed character */ 4629 save_cursor = curwin->w_cursor; 4630 save_msg_col = msg_col; 4631 save_msg_row = msg_row; 4632 p = eval_to_string(expr, NULL, FALSE); 4633 --textlock; 4634 --ex_normal_lock; 4635 curwin->w_cursor = save_cursor; 4636 msg_col = save_msg_col; 4637 msg_row = save_msg_row; 4638 4639 restore_cmdline_alloc(save_cmd); 4640 vim_free(expr); 4641 4642 if (p == NULL) 4643 return NULL; 4644 /* Escape CSI in the result to be able to use the string as typeahead. */ 4645 res = vim_strsave_escape_csi(p); 4646 vim_free(p); 4647 4648 return res; 4649 } 4650 #endif 4651 4652 /* 4653 * Copy "p" to allocated memory, escaping K_SPECIAL and CSI so that the result 4654 * can be put in the typeahead buffer. 4655 * Returns NULL when out of memory. 4656 */ 4657 char_u * 4658 vim_strsave_escape_csi( 4659 char_u *p) 4660 { 4661 char_u *res; 4662 char_u *s, *d; 4663 4664 /* Need a buffer to hold up to three times as much. */ 4665 res = alloc((unsigned)(STRLEN(p) * 3) + 1); 4666 if (res != NULL) 4667 { 4668 d = res; 4669 for (s = p; *s != NUL; ) 4670 { 4671 if (s[0] == K_SPECIAL && s[1] != NUL && s[2] != NUL) 4672 { 4673 /* Copy special key unmodified. */ 4674 *d++ = *s++; 4675 *d++ = *s++; 4676 *d++ = *s++; 4677 } 4678 else 4679 { 4680 #ifdef FEAT_MBYTE 4681 int len = mb_char2len(PTR2CHAR(s)); 4682 int len2 = mb_ptr2len(s); 4683 #endif 4684 /* Add character, possibly multi-byte to destination, escaping 4685 * CSI and K_SPECIAL. */ 4686 d = add_char2buf(PTR2CHAR(s), d); 4687 #ifdef FEAT_MBYTE 4688 while (len < len2) 4689 { 4690 /* add following combining char */ 4691 d = add_char2buf(PTR2CHAR(s + len), d); 4692 len += mb_char2len(PTR2CHAR(s + len)); 4693 } 4694 #endif 4695 mb_ptr_adv(s); 4696 } 4697 } 4698 *d = NUL; 4699 } 4700 return res; 4701 } 4702 4703 /* 4704 * Remove escaping from CSI and K_SPECIAL characters. Reverse of 4705 * vim_strsave_escape_csi(). Works in-place. 4706 */ 4707 void 4708 vim_unescape_csi(char_u *p) 4709 { 4710 char_u *s = p, *d = p; 4711 4712 while (*s != NUL) 4713 { 4714 if (s[0] == K_SPECIAL && s[1] == KS_SPECIAL && s[2] == KE_FILLER) 4715 { 4716 *d++ = K_SPECIAL; 4717 s += 3; 4718 } 4719 else if ((s[0] == K_SPECIAL || s[0] == CSI) 4720 && s[1] == KS_EXTRA && s[2] == (int)KE_CSI) 4721 { 4722 *d++ = CSI; 4723 s += 3; 4724 } 4725 else 4726 *d++ = *s++; 4727 } 4728 *d = NUL; 4729 } 4730 4731 /* 4732 * Write map commands for the current mappings to an .exrc file. 4733 * Return FAIL on error, OK otherwise. 4734 */ 4735 int 4736 makemap( 4737 FILE *fd, 4738 buf_T *buf) /* buffer for local mappings or NULL */ 4739 { 4740 mapblock_T *mp; 4741 char_u c1, c2, c3; 4742 char_u *p; 4743 char *cmd; 4744 int abbr; 4745 int hash; 4746 int did_cpo = FALSE; 4747 int i; 4748 4749 validate_maphash(); 4750 4751 /* 4752 * Do the loop twice: Once for mappings, once for abbreviations. 4753 * Then loop over all map hash lists. 4754 */ 4755 for (abbr = 0; abbr < 2; ++abbr) 4756 for (hash = 0; hash < 256; ++hash) 4757 { 4758 if (abbr) 4759 { 4760 if (hash > 0) /* there is only one abbr list */ 4761 break; 4762 #ifdef FEAT_LOCALMAP 4763 if (buf != NULL) 4764 mp = buf->b_first_abbr; 4765 else 4766 #endif 4767 mp = first_abbr; 4768 } 4769 else 4770 { 4771 #ifdef FEAT_LOCALMAP 4772 if (buf != NULL) 4773 mp = buf->b_maphash[hash]; 4774 else 4775 #endif 4776 mp = maphash[hash]; 4777 } 4778 4779 for ( ; mp; mp = mp->m_next) 4780 { 4781 /* skip script-local mappings */ 4782 if (mp->m_noremap == REMAP_SCRIPT) 4783 continue; 4784 4785 /* skip mappings that contain a <SNR> (script-local thing), 4786 * they probably don't work when loaded again */ 4787 for (p = mp->m_str; *p != NUL; ++p) 4788 if (p[0] == K_SPECIAL && p[1] == KS_EXTRA 4789 && p[2] == (int)KE_SNR) 4790 break; 4791 if (*p != NUL) 4792 continue; 4793 4794 /* It's possible to create a mapping and then ":unmap" certain 4795 * modes. We recreate this here by mapping the individual 4796 * modes, which requires up to three of them. */ 4797 c1 = NUL; 4798 c2 = NUL; 4799 c3 = NUL; 4800 if (abbr) 4801 cmd = "abbr"; 4802 else 4803 cmd = "map"; 4804 switch (mp->m_mode) 4805 { 4806 case NORMAL + VISUAL + SELECTMODE + OP_PENDING: 4807 break; 4808 case NORMAL: 4809 c1 = 'n'; 4810 break; 4811 case VISUAL: 4812 c1 = 'x'; 4813 break; 4814 case SELECTMODE: 4815 c1 = 's'; 4816 break; 4817 case OP_PENDING: 4818 c1 = 'o'; 4819 break; 4820 case NORMAL + VISUAL: 4821 c1 = 'n'; 4822 c2 = 'x'; 4823 break; 4824 case NORMAL + SELECTMODE: 4825 c1 = 'n'; 4826 c2 = 's'; 4827 break; 4828 case NORMAL + OP_PENDING: 4829 c1 = 'n'; 4830 c2 = 'o'; 4831 break; 4832 case VISUAL + SELECTMODE: 4833 c1 = 'v'; 4834 break; 4835 case VISUAL + OP_PENDING: 4836 c1 = 'x'; 4837 c2 = 'o'; 4838 break; 4839 case SELECTMODE + OP_PENDING: 4840 c1 = 's'; 4841 c2 = 'o'; 4842 break; 4843 case NORMAL + VISUAL + SELECTMODE: 4844 c1 = 'n'; 4845 c2 = 'v'; 4846 break; 4847 case NORMAL + VISUAL + OP_PENDING: 4848 c1 = 'n'; 4849 c2 = 'x'; 4850 c3 = 'o'; 4851 break; 4852 case NORMAL + SELECTMODE + OP_PENDING: 4853 c1 = 'n'; 4854 c2 = 's'; 4855 c3 = 'o'; 4856 break; 4857 case VISUAL + SELECTMODE + OP_PENDING: 4858 c1 = 'v'; 4859 c2 = 'o'; 4860 break; 4861 case CMDLINE + INSERT: 4862 if (!abbr) 4863 cmd = "map!"; 4864 break; 4865 case CMDLINE: 4866 c1 = 'c'; 4867 break; 4868 case INSERT: 4869 c1 = 'i'; 4870 break; 4871 case LANGMAP: 4872 c1 = 'l'; 4873 break; 4874 default: 4875 EMSG(_("E228: makemap: Illegal mode")); 4876 return FAIL; 4877 } 4878 do /* do this twice if c2 is set, 3 times with c3 */ 4879 { 4880 /* When outputting <> form, need to make sure that 'cpo' 4881 * is set to the Vim default. */ 4882 if (!did_cpo) 4883 { 4884 if (*mp->m_str == NUL) /* will use <Nop> */ 4885 did_cpo = TRUE; 4886 else 4887 for (i = 0; i < 2; ++i) 4888 for (p = (i ? mp->m_str : mp->m_keys); *p; ++p) 4889 if (*p == K_SPECIAL || *p == NL) 4890 did_cpo = TRUE; 4891 if (did_cpo) 4892 { 4893 if (fprintf(fd, "let s:cpo_save=&cpo") < 0 4894 || put_eol(fd) < 0 4895 || fprintf(fd, "set cpo&vim") < 0 4896 || put_eol(fd) < 0) 4897 return FAIL; 4898 } 4899 } 4900 if (c1 && putc(c1, fd) < 0) 4901 return FAIL; 4902 if (mp->m_noremap != REMAP_YES && fprintf(fd, "nore") < 0) 4903 return FAIL; 4904 if (fputs(cmd, fd) < 0) 4905 return FAIL; 4906 if (buf != NULL && fputs(" <buffer>", fd) < 0) 4907 return FAIL; 4908 if (mp->m_nowait && fputs(" <nowait>", fd) < 0) 4909 return FAIL; 4910 if (mp->m_silent && fputs(" <silent>", fd) < 0) 4911 return FAIL; 4912 #ifdef FEAT_EVAL 4913 if (mp->m_noremap == REMAP_SCRIPT 4914 && fputs("<script>", fd) < 0) 4915 return FAIL; 4916 if (mp->m_expr && fputs(" <expr>", fd) < 0) 4917 return FAIL; 4918 #endif 4919 4920 if ( putc(' ', fd) < 0 4921 || put_escstr(fd, mp->m_keys, 0) == FAIL 4922 || putc(' ', fd) < 0 4923 || put_escstr(fd, mp->m_str, 1) == FAIL 4924 || put_eol(fd) < 0) 4925 return FAIL; 4926 c1 = c2; 4927 c2 = c3; 4928 c3 = NUL; 4929 } while (c1 != NUL); 4930 } 4931 } 4932 4933 if (did_cpo) 4934 if (fprintf(fd, "let &cpo=s:cpo_save") < 0 4935 || put_eol(fd) < 0 4936 || fprintf(fd, "unlet s:cpo_save") < 0 4937 || put_eol(fd) < 0) 4938 return FAIL; 4939 return OK; 4940 } 4941 4942 /* 4943 * write escape string to file 4944 * "what": 0 for :map lhs, 1 for :map rhs, 2 for :set 4945 * 4946 * return FAIL for failure, OK otherwise 4947 */ 4948 int 4949 put_escstr(FILE *fd, char_u *strstart, int what) 4950 { 4951 char_u *str = strstart; 4952 int c; 4953 int modifiers; 4954 4955 /* :map xx <Nop> */ 4956 if (*str == NUL && what == 1) 4957 { 4958 if (fprintf(fd, "<Nop>") < 0) 4959 return FAIL; 4960 return OK; 4961 } 4962 4963 for ( ; *str != NUL; ++str) 4964 { 4965 #ifdef FEAT_MBYTE 4966 char_u *p; 4967 4968 /* Check for a multi-byte character, which may contain escaped 4969 * K_SPECIAL and CSI bytes */ 4970 p = mb_unescape(&str); 4971 if (p != NULL) 4972 { 4973 while (*p != NUL) 4974 if (fputc(*p++, fd) < 0) 4975 return FAIL; 4976 --str; 4977 continue; 4978 } 4979 #endif 4980 4981 c = *str; 4982 /* 4983 * Special key codes have to be translated to be able to make sense 4984 * when they are read back. 4985 */ 4986 if (c == K_SPECIAL && what != 2) 4987 { 4988 modifiers = 0x0; 4989 if (str[1] == KS_MODIFIER) 4990 { 4991 modifiers = str[2]; 4992 str += 3; 4993 c = *str; 4994 } 4995 if (c == K_SPECIAL) 4996 { 4997 c = TO_SPECIAL(str[1], str[2]); 4998 str += 2; 4999 } 5000 if (IS_SPECIAL(c) || modifiers) /* special key */ 5001 { 5002 if (fputs((char *)get_special_key_name(c, modifiers), fd) < 0) 5003 return FAIL; 5004 continue; 5005 } 5006 } 5007 5008 /* 5009 * A '\n' in a map command should be written as <NL>. 5010 * A '\n' in a set command should be written as \^V^J. 5011 */ 5012 if (c == NL) 5013 { 5014 if (what == 2) 5015 { 5016 if (fprintf(fd, IF_EB("\\\026\n", "\\" CTRL_V_STR "\n")) < 0) 5017 return FAIL; 5018 } 5019 else 5020 { 5021 if (fprintf(fd, "<NL>") < 0) 5022 return FAIL; 5023 } 5024 continue; 5025 } 5026 5027 /* 5028 * Some characters have to be escaped with CTRL-V to 5029 * prevent them from misinterpreted in DoOneCmd(). 5030 * A space, Tab and '"' has to be escaped with a backslash to 5031 * prevent it to be misinterpreted in do_set(). 5032 * A space has to be escaped with a CTRL-V when it's at the start of a 5033 * ":map" rhs. 5034 * A '<' has to be escaped with a CTRL-V to prevent it being 5035 * interpreted as the start of a special key name. 5036 * A space in the lhs of a :map needs a CTRL-V. 5037 */ 5038 if (what == 2 && (vim_iswhite(c) || c == '"' || c == '\\')) 5039 { 5040 if (putc('\\', fd) < 0) 5041 return FAIL; 5042 } 5043 else if (c < ' ' || c > '~' || c == '|' 5044 || (what == 0 && c == ' ') 5045 || (what == 1 && str == strstart && c == ' ') 5046 || (what != 2 && c == '<')) 5047 { 5048 if (putc(Ctrl_V, fd) < 0) 5049 return FAIL; 5050 } 5051 if (putc(c, fd) < 0) 5052 return FAIL; 5053 } 5054 return OK; 5055 } 5056 5057 /* 5058 * Check all mappings for the presence of special key codes. 5059 * Used after ":set term=xxx". 5060 */ 5061 void 5062 check_map_keycodes(void) 5063 { 5064 mapblock_T *mp; 5065 char_u *p; 5066 int i; 5067 char_u buf[3]; 5068 char_u *save_name; 5069 int abbr; 5070 int hash; 5071 #ifdef FEAT_LOCALMAP 5072 buf_T *bp; 5073 #endif 5074 5075 validate_maphash(); 5076 save_name = sourcing_name; 5077 sourcing_name = (char_u *)"mappings"; /* avoids giving error messages */ 5078 5079 #ifdef FEAT_LOCALMAP 5080 /* This this once for each buffer, and then once for global 5081 * mappings/abbreviations with bp == NULL */ 5082 for (bp = firstbuf; ; bp = bp->b_next) 5083 { 5084 #endif 5085 /* 5086 * Do the loop twice: Once for mappings, once for abbreviations. 5087 * Then loop over all map hash lists. 5088 */ 5089 for (abbr = 0; abbr <= 1; ++abbr) 5090 for (hash = 0; hash < 256; ++hash) 5091 { 5092 if (abbr) 5093 { 5094 if (hash) /* there is only one abbr list */ 5095 break; 5096 #ifdef FEAT_LOCALMAP 5097 if (bp != NULL) 5098 mp = bp->b_first_abbr; 5099 else 5100 #endif 5101 mp = first_abbr; 5102 } 5103 else 5104 { 5105 #ifdef FEAT_LOCALMAP 5106 if (bp != NULL) 5107 mp = bp->b_maphash[hash]; 5108 else 5109 #endif 5110 mp = maphash[hash]; 5111 } 5112 for ( ; mp != NULL; mp = mp->m_next) 5113 { 5114 for (i = 0; i <= 1; ++i) /* do this twice */ 5115 { 5116 if (i == 0) 5117 p = mp->m_keys; /* once for the "from" part */ 5118 else 5119 p = mp->m_str; /* and once for the "to" part */ 5120 while (*p) 5121 { 5122 if (*p == K_SPECIAL) 5123 { 5124 ++p; 5125 if (*p < 128) /* for "normal" tcap entries */ 5126 { 5127 buf[0] = p[0]; 5128 buf[1] = p[1]; 5129 buf[2] = NUL; 5130 (void)add_termcap_entry(buf, FALSE); 5131 } 5132 ++p; 5133 } 5134 ++p; 5135 } 5136 } 5137 } 5138 } 5139 #ifdef FEAT_LOCALMAP 5140 if (bp == NULL) 5141 break; 5142 } 5143 #endif 5144 sourcing_name = save_name; 5145 } 5146 5147 #if defined(FEAT_EVAL) || defined(PROTO) 5148 /* 5149 * Check the string "keys" against the lhs of all mappings. 5150 * Return pointer to rhs of mapping (mapblock->m_str). 5151 * NULL when no mapping found. 5152 */ 5153 char_u * 5154 check_map( 5155 char_u *keys, 5156 int mode, 5157 int exact, /* require exact match */ 5158 int ign_mod, /* ignore preceding modifier */ 5159 int abbr, /* do abbreviations */ 5160 mapblock_T **mp_ptr, /* return: pointer to mapblock or NULL */ 5161 int *local_ptr) /* return: buffer-local mapping or NULL */ 5162 { 5163 int hash; 5164 int len, minlen; 5165 mapblock_T *mp; 5166 char_u *s; 5167 #ifdef FEAT_LOCALMAP 5168 int local; 5169 #endif 5170 5171 validate_maphash(); 5172 5173 len = (int)STRLEN(keys); 5174 #ifdef FEAT_LOCALMAP 5175 for (local = 1; local >= 0; --local) 5176 #endif 5177 /* loop over all hash lists */ 5178 for (hash = 0; hash < 256; ++hash) 5179 { 5180 if (abbr) 5181 { 5182 if (hash > 0) /* there is only one list. */ 5183 break; 5184 #ifdef FEAT_LOCALMAP 5185 if (local) 5186 mp = curbuf->b_first_abbr; 5187 else 5188 #endif 5189 mp = first_abbr; 5190 } 5191 #ifdef FEAT_LOCALMAP 5192 else if (local) 5193 mp = curbuf->b_maphash[hash]; 5194 #endif 5195 else 5196 mp = maphash[hash]; 5197 for ( ; mp != NULL; mp = mp->m_next) 5198 { 5199 /* skip entries with wrong mode, wrong length and not matching 5200 * ones */ 5201 if ((mp->m_mode & mode) && (!exact || mp->m_keylen == len)) 5202 { 5203 if (len > mp->m_keylen) 5204 minlen = mp->m_keylen; 5205 else 5206 minlen = len; 5207 s = mp->m_keys; 5208 if (ign_mod && s[0] == K_SPECIAL && s[1] == KS_MODIFIER 5209 && s[2] != NUL) 5210 { 5211 s += 3; 5212 if (len > mp->m_keylen - 3) 5213 minlen = mp->m_keylen - 3; 5214 } 5215 if (STRNCMP(s, keys, minlen) == 0) 5216 { 5217 if (mp_ptr != NULL) 5218 *mp_ptr = mp; 5219 if (local_ptr != NULL) 5220 #ifdef FEAT_LOCALMAP 5221 *local_ptr = local; 5222 #else 5223 *local_ptr = 0; 5224 #endif 5225 return mp->m_str; 5226 } 5227 } 5228 } 5229 } 5230 5231 return NULL; 5232 } 5233 #endif 5234 5235 #if defined(MSWIN) || defined(MACOS) 5236 5237 #define VIS_SEL (VISUAL+SELECTMODE) /* abbreviation */ 5238 5239 /* 5240 * Default mappings for some often used keys. 5241 */ 5242 static struct initmap 5243 { 5244 char_u *arg; 5245 int mode; 5246 } initmappings[] = 5247 { 5248 #if defined(MSWIN) 5249 /* Use the Windows (CUA) keybindings. */ 5250 # ifdef FEAT_GUI 5251 /* paste, copy and cut */ 5252 {(char_u *)"<S-Insert> \"*P", NORMAL}, 5253 {(char_u *)"<S-Insert> \"-d\"*P", VIS_SEL}, 5254 {(char_u *)"<S-Insert> <C-R><C-O>*", INSERT+CMDLINE}, 5255 {(char_u *)"<C-Insert> \"*y", VIS_SEL}, 5256 {(char_u *)"<S-Del> \"*d", VIS_SEL}, 5257 {(char_u *)"<C-Del> \"*d", VIS_SEL}, 5258 {(char_u *)"<C-X> \"*d", VIS_SEL}, 5259 /* Missing: CTRL-C (cancel) and CTRL-V (block selection) */ 5260 # else 5261 {(char_u *)"\316w <C-Home>", NORMAL+VIS_SEL}, 5262 {(char_u *)"\316w <C-Home>", INSERT+CMDLINE}, 5263 {(char_u *)"\316u <C-End>", NORMAL+VIS_SEL}, 5264 {(char_u *)"\316u <C-End>", INSERT+CMDLINE}, 5265 5266 /* paste, copy and cut */ 5267 # ifdef FEAT_CLIPBOARD 5268 {(char_u *)"\316\324 \"*P", NORMAL}, /* SHIFT-Insert is "*P */ 5269 {(char_u *)"\316\324 \"-d\"*P", VIS_SEL}, /* SHIFT-Insert is "-d"*P */ 5270 {(char_u *)"\316\324 \022\017*", INSERT}, /* SHIFT-Insert is ^R^O* */ 5271 {(char_u *)"\316\325 \"*y", VIS_SEL}, /* CTRL-Insert is "*y */ 5272 {(char_u *)"\316\327 \"*d", VIS_SEL}, /* SHIFT-Del is "*d */ 5273 {(char_u *)"\316\330 \"*d", VIS_SEL}, /* CTRL-Del is "*d */ 5274 {(char_u *)"\030 \"-d", VIS_SEL}, /* CTRL-X is "-d */ 5275 # else 5276 {(char_u *)"\316\324 P", NORMAL}, /* SHIFT-Insert is P */ 5277 {(char_u *)"\316\324 \"-dP", VIS_SEL}, /* SHIFT-Insert is "-dP */ 5278 {(char_u *)"\316\324 \022\017\"", INSERT}, /* SHIFT-Insert is ^R^O" */ 5279 {(char_u *)"\316\325 y", VIS_SEL}, /* CTRL-Insert is y */ 5280 {(char_u *)"\316\327 d", VIS_SEL}, /* SHIFT-Del is d */ 5281 {(char_u *)"\316\330 d", VIS_SEL}, /* CTRL-Del is d */ 5282 # endif 5283 # endif 5284 #endif 5285 5286 #if defined(MACOS) 5287 /* Use the Standard MacOS binding. */ 5288 /* paste, copy and cut */ 5289 {(char_u *)"<D-v> \"*P", NORMAL}, 5290 {(char_u *)"<D-v> \"-d\"*P", VIS_SEL}, 5291 {(char_u *)"<D-v> <C-R>*", INSERT+CMDLINE}, 5292 {(char_u *)"<D-c> \"*y", VIS_SEL}, 5293 {(char_u *)"<D-x> \"*d", VIS_SEL}, 5294 {(char_u *)"<Backspace> \"-d", VIS_SEL}, 5295 #endif 5296 }; 5297 5298 # undef VIS_SEL 5299 #endif 5300 5301 /* 5302 * Set up default mappings. 5303 */ 5304 void 5305 init_mappings(void) 5306 { 5307 #if defined(MSWIN) ||defined(MACOS) 5308 int i; 5309 5310 for (i = 0; i < (int)(sizeof(initmappings) / sizeof(struct initmap)); ++i) 5311 add_map(initmappings[i].arg, initmappings[i].mode); 5312 #endif 5313 } 5314 5315 #if defined(MSWIN) || defined(FEAT_CMDWIN) || defined(MACOS) || defined(PROTO) 5316 /* 5317 * Add a mapping "map" for mode "mode". 5318 * Need to put string in allocated memory, because do_map() will modify it. 5319 */ 5320 void 5321 add_map(char_u *map, int mode) 5322 { 5323 char_u *s; 5324 char_u *cpo_save = p_cpo; 5325 5326 p_cpo = (char_u *)""; /* Allow <> notation */ 5327 s = vim_strsave(map); 5328 if (s != NULL) 5329 { 5330 (void)do_map(0, s, mode, FALSE); 5331 vim_free(s); 5332 } 5333 p_cpo = cpo_save; 5334 } 5335 #endif 5336