src/getchar.c

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