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