blob: c6d9492ebd4dbe8dbe78e7ae5a8d7d80f4c654d3 [file] [log] [blame]
Bram Moolenaar071d4272004-06-13 20:20:40 +00001/* 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.
Bram Moolenaarf6f95d92009-11-11 15:23:37 +000025 * - recorded characters: for the "q" command.
Bram Moolenaar071d4272004-06-13 20:20:40 +000026 *
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
43static struct buffheader redobuff = {{NULL, {NUL}}, NULL, 0, 0};
44static struct buffheader old_redobuff = {{NULL, {NUL}}, NULL, 0, 0};
45#if defined(FEAT_AUTOCMD) || defined(FEAT_EVAL) || defined(PROTO)
46static struct buffheader save_redobuff = {{NULL, {NUL}}, NULL, 0, 0};
47static struct buffheader save_old_redobuff = {{NULL, {NUL}}, NULL, 0, 0};
48#endif
49static struct buffheader recordbuff = {{NULL, {NUL}}, NULL, 0, 0};
50
51static 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 */
57static 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 */
Bram Moolenaar371d5402006-03-20 21:47:49 +000066#define MAP_HASH(mode, c1) (((mode) & (NORMAL + VISUAL + SELECTMODE + OP_PENDING)) ? (c1) : ((c1) ^ 0x80))
Bram Moolenaar071d4272004-06-13 20:20:40 +000067
68/*
69 * Each mapping is put in one of the 256 hash lists, to speed up finding it.
70 */
71static mapblock_T *(maphash[256]);
72static int maphash_valid = FALSE;
73
74/*
75 * List used for abbreviations.
76 */
77static mapblock_T *first_abbr = NULL; /* first entry in abbrlist */
78
Bram Moolenaarcf8e7d12006-12-05 20:43:17 +000079static int KeyNoremap = 0; /* remapping flags */
Bram Moolenaar071d4272004-06-13 20:20:40 +000080
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 */
Bram Moolenaarf4b8e572004-06-24 15:53:16 +0000103#define RM_ABBR 4 /* tb_noremap: don't remap, do abbrev. */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000104
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))
110static char_u typebuf_init[TYPELEN_INIT]; /* initial typebuf.tb_buf */
111static char_u noremapbuf_init[TYPELEN_INIT]; /* initial typebuf.tb_noremap */
112
113static int last_recorded_len = 0; /* number of last recorded chars */
114
115static char_u *get_buffcont __ARGS((struct buffheader *, int));
116static void add_buff __ARGS((struct buffheader *, char_u *, long n));
117static void add_num_buff __ARGS((struct buffheader *, long));
118static void add_char_buff __ARGS((struct buffheader *, int));
119static int read_stuff __ARGS((int advance));
120static void start_stuff __ARGS((void));
121static int read_redo __ARGS((int, int));
122static void copy_redo __ARGS((int));
123static void init_typebuf __ARGS((void));
124static void gotchars __ARGS((char_u *, int));
125static void may_sync_undo __ARGS((void));
126static void closescript __ARGS((void));
127static int vgetorpeek __ARGS((int));
128static void map_free __ARGS((mapblock_T **));
129static void validate_maphash __ARGS((void));
130static void showmap __ARGS((mapblock_T *mp, int local));
Bram Moolenaarc1e37902006-04-18 21:55:01 +0000131#ifdef FEAT_EVAL
Bram Moolenaarda9591e2009-09-30 13:17:02 +0000132static char_u *eval_map_expr __ARGS((char_u *str, int c));
Bram Moolenaarc1e37902006-04-18 21:55:01 +0000133#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000134
135/*
136 * Free and clear a buffer.
137 */
138 void
139free_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 *
157get_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 *
188get_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 *
222get_inserted()
223{
Bram Moolenaarf2330482008-06-24 20:19:36 +0000224 return get_buffcont(&redobuff, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000225}
226
227/*
Bram Moolenaar4e86cba2007-05-06 11:56:32 +0000228 * Add string "s" after the current block of buffer "buf".
Bram Moolenaar071d4272004-06-13 20:20:40 +0000229 * K_SPECIAL and CSI should have been escaped already.
230 */
231 static void
232add_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)
Bram Moolenaarc3b73072007-12-07 16:30:42 +0000256 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);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000259 buf->bh_index = 0;
260
261 if (buf->bh_space >= (int)slen)
262 {
263 len = (long_u)STRLEN(buf->bh_curr->b_str);
Bram Moolenaarb6356332005-07-18 21:40:44 +0000264 vim_strncpy(buf->bh_curr->b_str + len, s, (size_t)slen);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000265 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 */
Bram Moolenaara93fa7e2006-04-17 22:14:47 +0000277 buf->bh_space = (int)(len - slen);
Bram Moolenaarb6356332005-07-18 21:40:44 +0000278 vim_strncpy(p->b_str, s, (size_t)slen);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000279
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
291add_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
306add_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
363read_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
391start_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
404stuff_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
413typeahead_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
Bram Moolenaar70b2a562012-01-10 22:26:17 +0100421 * typeahead buffer (used in case of an error). If "flush_typeahead" is true,
Bram Moolenaar071d4272004-06-13 20:20:40 +0000422 * flush all typeahead characters (used when interrupted by a CTRL-C).
423 */
424 void
Bram Moolenaar70b2a562012-01-10 22:26:17 +0100425flush_buffers(flush_typeahead)
426 int flush_typeahead;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000427{
428 init_typebuf();
429
430 start_stuff();
431 while (read_stuff(TRUE) != NUL)
432 ;
433
Bram Moolenaar70b2a562012-01-10 22:26:17 +0100434 if (flush_typeahead) /* remove all typeahead */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000435 {
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
463ResetRedobuff()
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
Bram Moolenaarbe094a12012-02-05 01:18:48 +0100473/*
474 * Discard the contents of the redo buffer and restore the previous redo
475 * buffer.
476 */
477 void
478CancelRedo()
479{
480 if (!block_redo)
481 {
482 free_buff(&redobuff);
483 redobuff = old_redobuff;
484 old_redobuff.bh_first.b_next = NULL;
485 start_stuff();
486 while (read_stuff(TRUE) != NUL)
487 ;
488 }
489}
490
Bram Moolenaar071d4272004-06-13 20:20:40 +0000491#if defined(FEAT_AUTOCMD) || defined(FEAT_EVAL) || defined(PROTO)
492/*
493 * Save redobuff and old_redobuff to save_redobuff and save_old_redobuff.
494 * Used before executing autocommands and user functions.
495 */
496static int save_level = 0;
497
498 void
499saveRedobuff()
500{
501 char_u *s;
502
503 if (save_level++ == 0)
504 {
505 save_redobuff = redobuff;
506 redobuff.bh_first.b_next = NULL;
507 save_old_redobuff = old_redobuff;
508 old_redobuff.bh_first.b_next = NULL;
509
510 /* Make a copy, so that ":normal ." in a function works. */
511 s = get_buffcont(&save_redobuff, FALSE);
512 if (s != NULL)
513 {
514 add_buff(&redobuff, s, -1L);
515 vim_free(s);
516 }
517 }
518}
519
520/*
521 * Restore redobuff and old_redobuff from save_redobuff and save_old_redobuff.
522 * Used after executing autocommands and user functions.
523 */
524 void
525restoreRedobuff()
526{
527 if (--save_level == 0)
528 {
529 free_buff(&redobuff);
530 redobuff = save_redobuff;
531 free_buff(&old_redobuff);
532 old_redobuff = save_old_redobuff;
533 }
534}
535#endif
536
537/*
538 * Append "s" to the redo buffer.
539 * K_SPECIAL and CSI should already have been escaped.
540 */
541 void
542AppendToRedobuff(s)
543 char_u *s;
544{
545 if (!block_redo)
546 add_buff(&redobuff, s, -1L);
547}
548
549/*
550 * Append to Redo buffer literally, escaping special characters with CTRL-V.
551 * K_SPECIAL and CSI are escaped as well.
552 */
553 void
Bram Moolenaarebefac62005-12-28 22:39:57 +0000554AppendToRedobuffLit(str, len)
555 char_u *str;
556 int len; /* length of "str" or -1 for up to the NUL */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000557{
Bram Moolenaarebefac62005-12-28 22:39:57 +0000558 char_u *s = str;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000559 int c;
560 char_u *start;
561
562 if (block_redo)
563 return;
564
Bram Moolenaarebefac62005-12-28 22:39:57 +0000565 while (len < 0 ? *s != NUL : s - str < len)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000566 {
567 /* Put a string of normal characters in the redo buffer (that's
568 * faster). */
569 start = s;
570 while (*s >= ' '
571#ifndef EBCDIC
572 && *s < DEL /* EBCDIC: all chars above space are normal */
573#endif
Bram Moolenaarebefac62005-12-28 22:39:57 +0000574 && (len < 0 || s - str < len))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000575 ++s;
576
577 /* Don't put '0' or '^' as last character, just in case a CTRL-D is
578 * typed next. */
579 if (*s == NUL && (s[-1] == '0' || s[-1] == '^'))
580 --s;
581 if (s > start)
582 add_buff(&redobuff, start, (long)(s - start));
583
Bram Moolenaarebefac62005-12-28 22:39:57 +0000584 if (*s == NUL || (len >= 0 && s - str >= len))
585 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000586
Bram Moolenaarebefac62005-12-28 22:39:57 +0000587 /* Handle a special or multibyte character. */
588#ifdef FEAT_MBYTE
589 if (has_mbyte)
590 /* Handle composing chars separately. */
591 c = mb_cptr2char_adv(&s);
592 else
Bram Moolenaar071d4272004-06-13 20:20:40 +0000593#endif
Bram Moolenaarebefac62005-12-28 22:39:57 +0000594 c = *s++;
595 if (c < ' ' || c == DEL || (*s == NUL && (c == '0' || c == '^')))
596 add_char_buff(&redobuff, Ctrl_V);
597
598 /* CTRL-V '0' must be inserted as CTRL-V 048 (EBCDIC: xf0) */
599 if (*s == NUL && c == '0')
600#ifdef EBCDIC
601 add_buff(&redobuff, (char_u *)"xf0", 3L);
602#else
603 add_buff(&redobuff, (char_u *)"048", 3L);
604#endif
605 else
606 add_char_buff(&redobuff, c);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000607 }
608}
609
610/*
611 * Append a character to the redo buffer.
612 * Translates special keys, NUL, CSI, K_SPECIAL and multibyte characters.
613 */
614 void
615AppendCharToRedobuff(c)
616 int c;
617{
618 if (!block_redo)
619 add_char_buff(&redobuff, c);
620}
621
622/*
623 * Append a number to the redo buffer.
624 */
625 void
626AppendNumberToRedobuff(n)
627 long n;
628{
629 if (!block_redo)
630 add_num_buff(&redobuff, n);
631}
632
633/*
634 * Append string "s" to the stuff buffer.
635 * CSI and K_SPECIAL must already have been escaped.
636 */
637 void
638stuffReadbuff(s)
639 char_u *s;
640{
641 add_buff(&stuffbuff, s, -1L);
642}
643
644 void
645stuffReadbuffLen(s, len)
646 char_u *s;
647 long len;
648{
649 add_buff(&stuffbuff, s, len);
650}
651
652#if defined(FEAT_EVAL) || defined(PROTO)
653/*
654 * Stuff "s" into the stuff buffer, leaving special key codes unmodified and
655 * escaping other K_SPECIAL and CSI bytes.
Bram Moolenaar877b97b2011-04-28 17:30:09 +0200656 * Change CR, LF and ESC into a space.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000657 */
658 void
659stuffReadbuffSpec(s)
660 char_u *s;
661{
Bram Moolenaar877b97b2011-04-28 17:30:09 +0200662 int c;
663
Bram Moolenaar071d4272004-06-13 20:20:40 +0000664 while (*s != NUL)
665 {
666 if (*s == K_SPECIAL && s[1] != NUL && s[2] != NUL)
667 {
668 /* Insert special key literally. */
669 stuffReadbuffLen(s, 3L);
670 s += 3;
671 }
672 else
Bram Moolenaar877b97b2011-04-28 17:30:09 +0200673 {
Bram Moolenaar071d4272004-06-13 20:20:40 +0000674#ifdef FEAT_MBYTE
Bram Moolenaar877b97b2011-04-28 17:30:09 +0200675 c = mb_ptr2char_adv(&s);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000676#else
Bram Moolenaar877b97b2011-04-28 17:30:09 +0200677 c = *s++;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000678#endif
Bram Moolenaar877b97b2011-04-28 17:30:09 +0200679 if (c == CAR || c == NL || c == ESC)
680 c = ' ';
681 stuffcharReadbuff(c);
682 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000683 }
684}
685#endif
686
687/*
688 * Append a character to the stuff buffer.
689 * Translates special keys, NUL, CSI, K_SPECIAL and multibyte characters.
690 */
691 void
692stuffcharReadbuff(c)
693 int c;
694{
695 add_char_buff(&stuffbuff, c);
696}
697
698/*
699 * Append a number to the stuff buffer.
700 */
701 void
702stuffnumReadbuff(n)
703 long n;
704{
705 add_num_buff(&stuffbuff, n);
706}
707
708/*
709 * Read a character from the redo buffer. Translates K_SPECIAL, CSI and
710 * multibyte characters.
711 * The redo buffer is left as it is.
Bram Moolenaarbe094a12012-02-05 01:18:48 +0100712 * If init is TRUE, prepare for redo, return FAIL if nothing to redo, OK
713 * otherwise.
714 * If old is TRUE, use old_redobuff instead of redobuff.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000715 */
716 static int
717read_redo(init, old_redo)
718 int init;
719 int old_redo;
720{
721 static struct buffblock *bp;
722 static char_u *p;
723 int c;
724#ifdef FEAT_MBYTE
725 int n;
Bram Moolenaar9a920d82012-06-01 15:21:02 +0200726 char_u buf[MB_MAXBYTES + 1];
Bram Moolenaar071d4272004-06-13 20:20:40 +0000727 int i;
728#endif
729
730 if (init)
731 {
732 if (old_redo)
733 bp = old_redobuff.bh_first.b_next;
734 else
735 bp = redobuff.bh_first.b_next;
736 if (bp == NULL)
737 return FAIL;
738 p = bp->b_str;
739 return OK;
740 }
741 if ((c = *p) != NUL)
742 {
743 /* Reverse the conversion done by add_char_buff() */
744#ifdef FEAT_MBYTE
745 /* For a multi-byte character get all the bytes and return the
746 * converted character. */
747 if (has_mbyte && (c != K_SPECIAL || p[1] == KS_SPECIAL))
748 n = MB_BYTE2LEN_CHECK(c);
749 else
750 n = 1;
751 for (i = 0; ; ++i)
752#endif
753 {
754 if (c == K_SPECIAL) /* special key or escaped K_SPECIAL */
755 {
756 c = TO_SPECIAL(p[1], p[2]);
757 p += 2;
758 }
759#ifdef FEAT_GUI
760 if (c == CSI) /* escaped CSI */
761 p += 2;
762#endif
763 if (*++p == NUL && bp->b_next != NULL)
764 {
765 bp = bp->b_next;
766 p = bp->b_str;
767 }
768#ifdef FEAT_MBYTE
769 buf[i] = c;
770 if (i == n - 1) /* last byte of a character */
771 {
772 if (n != 1)
773 c = (*mb_ptr2char)(buf);
774 break;
775 }
776 c = *p;
777 if (c == NUL) /* cannot happen? */
778 break;
779#endif
780 }
781 }
782
783 return c;
784}
785
786/*
787 * Copy the rest of the redo buffer into the stuff buffer (in a slow way).
788 * If old_redo is TRUE, use old_redobuff instead of redobuff.
789 * The escaped K_SPECIAL and CSI are copied without translation.
790 */
791 static void
792copy_redo(old_redo)
793 int old_redo;
794{
795 int c;
796
797 while ((c = read_redo(FALSE, old_redo)) != NUL)
798 stuffcharReadbuff(c);
799}
800
801/*
802 * Stuff the redo buffer into the stuffbuff.
803 * Insert the redo count into the command.
804 * If "old_redo" is TRUE, the last but one command is repeated
805 * instead of the last command (inserting text). This is used for
806 * CTRL-O <.> in insert mode
807 *
808 * return FAIL for failure, OK otherwise
809 */
810 int
811start_redo(count, old_redo)
812 long count;
813 int old_redo;
814{
815 int c;
816
817 /* init the pointers; return if nothing to redo */
818 if (read_redo(TRUE, old_redo) == FAIL)
819 return FAIL;
820
821 c = read_redo(FALSE, old_redo);
822
823 /* copy the buffer name, if present */
824 if (c == '"')
825 {
826 add_buff(&stuffbuff, (char_u *)"\"", 1L);
827 c = read_redo(FALSE, old_redo);
828
829 /* if a numbered buffer is used, increment the number */
830 if (c >= '1' && c < '9')
831 ++c;
832 add_char_buff(&stuffbuff, c);
833 c = read_redo(FALSE, old_redo);
834 }
835
836#ifdef FEAT_VISUAL
837 if (c == 'v') /* redo Visual */
838 {
839 VIsual = curwin->w_cursor;
840 VIsual_active = TRUE;
841 VIsual_select = FALSE;
842 VIsual_reselect = TRUE;
843 redo_VIsual_busy = TRUE;
844 c = read_redo(FALSE, old_redo);
845 }
846#endif
847
848 /* try to enter the count (in place of a previous count) */
849 if (count)
850 {
851 while (VIM_ISDIGIT(c)) /* skip "old" count */
852 c = read_redo(FALSE, old_redo);
853 add_num_buff(&stuffbuff, count);
854 }
855
856 /* copy from the redo buffer into the stuff buffer */
857 add_char_buff(&stuffbuff, c);
858 copy_redo(old_redo);
859 return OK;
860}
861
862/*
863 * Repeat the last insert (R, o, O, a, A, i or I command) by stuffing
864 * the redo buffer into the stuffbuff.
865 * return FAIL for failure, OK otherwise
866 */
867 int
868start_redo_ins()
869{
870 int c;
871
872 if (read_redo(TRUE, FALSE) == FAIL)
873 return FAIL;
874 start_stuff();
875
876 /* skip the count and the command character */
877 while ((c = read_redo(FALSE, FALSE)) != NUL)
878 {
879 if (vim_strchr((char_u *)"AaIiRrOo", c) != NULL)
880 {
881 if (c == 'O' || c == 'o')
882 stuffReadbuff(NL_STR);
883 break;
884 }
885 }
886
887 /* copy the typed text from the redo buffer into the stuff buffer */
888 copy_redo(FALSE);
889 block_redo = TRUE;
890 return OK;
891}
892
893 void
894stop_redo_ins()
895{
896 block_redo = FALSE;
897}
898
899/*
900 * Initialize typebuf.tb_buf to point to typebuf_init.
901 * alloc() cannot be used here: In out-of-memory situations it would
902 * be impossible to type anything.
903 */
904 static void
905init_typebuf()
906{
907 if (typebuf.tb_buf == NULL)
908 {
909 typebuf.tb_buf = typebuf_init;
910 typebuf.tb_noremap = noremapbuf_init;
911 typebuf.tb_buflen = TYPELEN_INIT;
912 typebuf.tb_len = 0;
913 typebuf.tb_off = 0;
914 typebuf.tb_change_cnt = 1;
915 }
916}
917
918/*
919 * insert a string in position 'offset' in the typeahead buffer (for "@r"
920 * and ":normal" command, vgetorpeek() and check_termcode())
921 *
922 * If noremap is REMAP_YES, new string can be mapped again.
923 * If noremap is REMAP_NONE, new string cannot be mapped again.
Bram Moolenaarf4b8e572004-06-24 15:53:16 +0000924 * If noremap is REMAP_SKIP, fist char of new string cannot be mapped again,
925 * but abbreviations are allowed.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000926 * If noremap is REMAP_SCRIPT, new string cannot be mapped again, except for
927 * script-local mappings.
928 * If noremap is > 0, that many characters of the new string cannot be mapped.
929 *
930 * If nottyped is TRUE, the string does not return KeyTyped (don't use when
931 * offset is non-zero!).
932 *
933 * If silent is TRUE, cmd_silent is set when the characters are obtained.
934 *
935 * return FAIL for failure, OK otherwise
936 */
937 int
938ins_typebuf(str, noremap, offset, nottyped, silent)
939 char_u *str;
940 int noremap;
941 int offset;
942 int nottyped;
943 int silent;
944{
945 char_u *s1, *s2;
946 int newlen;
947 int addlen;
948 int i;
949 int newoff;
950 int val;
951 int nrm;
952
953 init_typebuf();
954 if (++typebuf.tb_change_cnt == 0)
955 typebuf.tb_change_cnt = 1;
956
957 addlen = (int)STRLEN(str);
Bram Moolenaar4e86cba2007-05-06 11:56:32 +0000958
Bram Moolenaar071d4272004-06-13 20:20:40 +0000959 /*
960 * Easy case: there is room in front of typebuf.tb_buf[typebuf.tb_off]
961 */
962 if (offset == 0 && addlen <= typebuf.tb_off)
963 {
964 typebuf.tb_off -= addlen;
965 mch_memmove(typebuf.tb_buf + typebuf.tb_off, str, (size_t)addlen);
966 }
Bram Moolenaar4e86cba2007-05-06 11:56:32 +0000967
Bram Moolenaar071d4272004-06-13 20:20:40 +0000968 /*
Bram Moolenaar4e86cba2007-05-06 11:56:32 +0000969 * Need to allocate a new buffer.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000970 * In typebuf.tb_buf there must always be room for 3 * MAXMAPLEN + 4
971 * characters. We add some extra room to avoid having to allocate too
972 * often.
973 */
974 else
975 {
976 newoff = MAXMAPLEN + 4;
977 newlen = typebuf.tb_len + addlen + newoff + 4 * (MAXMAPLEN + 4);
978 if (newlen < 0) /* string is getting too long */
979 {
980 EMSG(_(e_toocompl)); /* also calls flush_buffers */
981 setcursor();
982 return FAIL;
983 }
984 s1 = alloc(newlen);
985 if (s1 == NULL) /* out of memory */
986 return FAIL;
987 s2 = alloc(newlen);
988 if (s2 == NULL) /* out of memory */
989 {
990 vim_free(s1);
991 return FAIL;
992 }
993 typebuf.tb_buflen = newlen;
994
995 /* copy the old chars, before the insertion point */
996 mch_memmove(s1 + newoff, typebuf.tb_buf + typebuf.tb_off,
997 (size_t)offset);
998 /* copy the new chars */
999 mch_memmove(s1 + newoff + offset, str, (size_t)addlen);
1000 /* copy the old chars, after the insertion point, including the NUL at
1001 * the end */
1002 mch_memmove(s1 + newoff + offset + addlen,
1003 typebuf.tb_buf + typebuf.tb_off + offset,
1004 (size_t)(typebuf.tb_len - offset + 1));
1005 if (typebuf.tb_buf != typebuf_init)
1006 vim_free(typebuf.tb_buf);
1007 typebuf.tb_buf = s1;
1008
1009 mch_memmove(s2 + newoff, typebuf.tb_noremap + typebuf.tb_off,
1010 (size_t)offset);
1011 mch_memmove(s2 + newoff + offset + addlen,
1012 typebuf.tb_noremap + typebuf.tb_off + offset,
1013 (size_t)(typebuf.tb_len - offset));
1014 if (typebuf.tb_noremap != noremapbuf_init)
1015 vim_free(typebuf.tb_noremap);
1016 typebuf.tb_noremap = s2;
1017
1018 typebuf.tb_off = newoff;
1019 }
1020 typebuf.tb_len += addlen;
1021
1022 /* If noremap == REMAP_SCRIPT: do remap script-local mappings. */
1023 if (noremap == REMAP_SCRIPT)
1024 val = RM_SCRIPT;
Bram Moolenaarf4b8e572004-06-24 15:53:16 +00001025 else if (noremap == REMAP_SKIP)
1026 val = RM_ABBR;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001027 else
1028 val = RM_NONE;
1029
1030 /*
1031 * Adjust typebuf.tb_noremap[] for the new characters:
1032 * If noremap == REMAP_NONE or REMAP_SCRIPT: new characters are
1033 * (sometimes) not remappable
1034 * If noremap == REMAP_YES: all the new characters are mappable
1035 * If noremap > 0: "noremap" characters are not remappable, the rest
1036 * mappable
1037 */
Bram Moolenaarf4b8e572004-06-24 15:53:16 +00001038 if (noremap == REMAP_SKIP)
1039 nrm = 1;
1040 else if (noremap < 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001041 nrm = addlen;
1042 else
1043 nrm = noremap;
1044 for (i = 0; i < addlen; ++i)
1045 typebuf.tb_noremap[typebuf.tb_off + i + offset] =
1046 (--nrm >= 0) ? val : RM_YES;
1047
1048 /* tb_maplen and tb_silent only remember the length of mapped and/or
1049 * silent mappings at the start of the buffer, assuming that a mapped
1050 * sequence doesn't result in typed characters. */
1051 if (nottyped || typebuf.tb_maplen > offset)
1052 typebuf.tb_maplen += addlen;
1053 if (silent || typebuf.tb_silent > offset)
1054 {
1055 typebuf.tb_silent += addlen;
1056 cmd_silent = TRUE;
1057 }
1058 if (typebuf.tb_no_abbr_cnt && offset == 0) /* and not used for abbrev.s */
1059 typebuf.tb_no_abbr_cnt += addlen;
1060
1061 return OK;
1062}
1063
1064/*
Bram Moolenaard8fc5c02006-04-29 21:55:22 +00001065 * Put character "c" back into the typeahead buffer.
1066 * Can be used for a character obtained by vgetc() that needs to be put back.
Bram Moolenaarcf8e7d12006-12-05 20:43:17 +00001067 * Uses cmd_silent, KeyTyped and KeyNoremap to restore the flags belonging to
1068 * the char.
Bram Moolenaard8fc5c02006-04-29 21:55:22 +00001069 */
1070 void
1071ins_char_typebuf(c)
1072 int c;
1073{
1074#ifdef FEAT_MBYTE
Bram Moolenaar9a920d82012-06-01 15:21:02 +02001075 char_u buf[MB_MAXBYTES + 1];
Bram Moolenaard8fc5c02006-04-29 21:55:22 +00001076#else
1077 char_u buf[4];
1078#endif
1079 if (IS_SPECIAL(c))
1080 {
1081 buf[0] = K_SPECIAL;
1082 buf[1] = K_SECOND(c);
1083 buf[2] = K_THIRD(c);
1084 buf[3] = NUL;
1085 }
1086 else
1087 {
1088#ifdef FEAT_MBYTE
1089 buf[(*mb_char2bytes)(c, buf)] = NUL;
1090#else
1091 buf[0] = c;
1092 buf[1] = NUL;
1093#endif
1094 }
Bram Moolenaarcf8e7d12006-12-05 20:43:17 +00001095 (void)ins_typebuf(buf, KeyNoremap, 0, !KeyTyped, cmd_silent);
Bram Moolenaard8fc5c02006-04-29 21:55:22 +00001096}
1097
1098/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00001099 * Return TRUE if the typeahead buffer was changed (while waiting for a
Bram Moolenaar4a85b412006-04-23 22:40:29 +00001100 * character to arrive). Happens when a message was received from a client or
Bram Moolenaarf9393ef2006-04-24 19:47:27 +00001101 * from feedkeys().
Bram Moolenaar071d4272004-06-13 20:20:40 +00001102 * But check in a more generic way to avoid trouble: When "typebuf.tb_buf"
1103 * changed it was reallocated and the old pointer can no longer be used.
1104 * Or "typebuf.tb_off" may have been changed and we would overwrite characters
1105 * that was just added.
1106 */
1107 int
1108typebuf_changed(tb_change_cnt)
1109 int tb_change_cnt; /* old value of typebuf.tb_change_cnt */
1110{
1111 return (tb_change_cnt != 0 && (typebuf.tb_change_cnt != tb_change_cnt
Bram Moolenaar4a85b412006-04-23 22:40:29 +00001112#if defined(FEAT_CLIENTSERVER) || defined(FEAT_EVAL)
1113 || typebuf_was_filled
Bram Moolenaar071d4272004-06-13 20:20:40 +00001114#endif
1115 ));
1116}
1117
1118/*
1119 * Return TRUE if there are no characters in the typeahead buffer that have
1120 * not been typed (result from a mapping or come from ":normal").
1121 */
1122 int
1123typebuf_typed()
1124{
1125 return typebuf.tb_maplen == 0;
1126}
1127
Bram Moolenaar910f66f2006-04-05 20:41:53 +00001128#if defined(FEAT_VISUAL) || defined(PROTO)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001129/*
1130 * Return the number of characters that are mapped (or not typed).
1131 */
1132 int
1133typebuf_maplen()
1134{
1135 return typebuf.tb_maplen;
1136}
Bram Moolenaar910f66f2006-04-05 20:41:53 +00001137#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001138
1139/*
1140 * remove "len" characters from typebuf.tb_buf[typebuf.tb_off + offset]
1141 */
1142 void
1143del_typebuf(len, offset)
1144 int len;
1145 int offset;
1146{
1147 int i;
1148
1149 if (len == 0)
1150 return; /* nothing to do */
1151
1152 typebuf.tb_len -= len;
1153
1154 /*
1155 * Easy case: Just increase typebuf.tb_off.
1156 */
1157 if (offset == 0 && typebuf.tb_buflen - (typebuf.tb_off + len)
1158 >= 3 * MAXMAPLEN + 3)
1159 typebuf.tb_off += len;
1160 /*
1161 * Have to move the characters in typebuf.tb_buf[] and typebuf.tb_noremap[]
1162 */
1163 else
1164 {
1165 i = typebuf.tb_off + offset;
1166 /*
1167 * Leave some extra room at the end to avoid reallocation.
1168 */
1169 if (typebuf.tb_off > MAXMAPLEN)
1170 {
1171 mch_memmove(typebuf.tb_buf + MAXMAPLEN,
1172 typebuf.tb_buf + typebuf.tb_off, (size_t)offset);
1173 mch_memmove(typebuf.tb_noremap + MAXMAPLEN,
1174 typebuf.tb_noremap + typebuf.tb_off, (size_t)offset);
1175 typebuf.tb_off = MAXMAPLEN;
1176 }
1177 /* adjust typebuf.tb_buf (include the NUL at the end) */
1178 mch_memmove(typebuf.tb_buf + typebuf.tb_off + offset,
1179 typebuf.tb_buf + i + len,
1180 (size_t)(typebuf.tb_len - offset + 1));
1181 /* adjust typebuf.tb_noremap[] */
1182 mch_memmove(typebuf.tb_noremap + typebuf.tb_off + offset,
1183 typebuf.tb_noremap + i + len,
1184 (size_t)(typebuf.tb_len - offset));
1185 }
1186
1187 if (typebuf.tb_maplen > offset) /* adjust tb_maplen */
1188 {
1189 if (typebuf.tb_maplen < offset + len)
1190 typebuf.tb_maplen = offset;
1191 else
1192 typebuf.tb_maplen -= len;
1193 }
1194 if (typebuf.tb_silent > offset) /* adjust tb_silent */
1195 {
1196 if (typebuf.tb_silent < offset + len)
1197 typebuf.tb_silent = offset;
1198 else
1199 typebuf.tb_silent -= len;
1200 }
1201 if (typebuf.tb_no_abbr_cnt > offset) /* adjust tb_no_abbr_cnt */
1202 {
1203 if (typebuf.tb_no_abbr_cnt < offset + len)
1204 typebuf.tb_no_abbr_cnt = offset;
1205 else
1206 typebuf.tb_no_abbr_cnt -= len;
1207 }
1208
Bram Moolenaar4a85b412006-04-23 22:40:29 +00001209#if defined(FEAT_CLIENTSERVER) || defined(FEAT_EVAL)
Bram Moolenaarf9393ef2006-04-24 19:47:27 +00001210 /* Reset the flag that text received from a client or from feedkeys()
Bram Moolenaar4a85b412006-04-23 22:40:29 +00001211 * was inserted in the typeahead buffer. */
1212 typebuf_was_filled = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001213#endif
1214 if (++typebuf.tb_change_cnt == 0)
1215 typebuf.tb_change_cnt = 1;
1216}
1217
1218/*
1219 * Write typed characters to script file.
1220 * If recording is on put the character in the recordbuffer.
1221 */
1222 static void
Bram Moolenaar4e86cba2007-05-06 11:56:32 +00001223gotchars(chars, len)
1224 char_u *chars;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001225 int len;
1226{
Bram Moolenaar4e86cba2007-05-06 11:56:32 +00001227 char_u *s = chars;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001228 int c;
1229 char_u buf[2];
Bram Moolenaar4e86cba2007-05-06 11:56:32 +00001230 int todo = len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001231
1232 /* remember how many chars were last recorded */
1233 if (Recording)
1234 last_recorded_len += len;
1235
1236 buf[1] = NUL;
Bram Moolenaar4e86cba2007-05-06 11:56:32 +00001237 while (todo--)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001238 {
1239 /* Handle one byte at a time; no translation to be done. */
1240 c = *s++;
1241 updatescript(c);
1242
1243 if (Recording)
1244 {
1245 buf[0] = c;
1246 add_buff(&recordbuff, buf, 1L);
1247 }
1248 }
1249 may_sync_undo();
1250
1251#ifdef FEAT_EVAL
1252 /* output "debug mode" message next time in debug mode */
1253 debug_did_msg = FALSE;
1254#endif
1255
1256 /* Since characters have been typed, consider the following to be in
1257 * another mapping. Search string will be kept in history. */
1258 ++maptick;
1259}
1260
1261/*
1262 * Sync undo. Called when typed characters are obtained from the typeahead
1263 * buffer, or when a menu is used.
1264 * Do not sync:
1265 * - In Insert mode, unless cursor key has been used.
1266 * - While reading a script file.
1267 * - When no_u_sync is non-zero.
1268 */
1269 static void
1270may_sync_undo()
1271{
1272 if ((!(State & (INSERT + CMDLINE)) || arrow_used)
Bram Moolenaar779b74b2006-04-10 14:55:34 +00001273 && scriptin[curscript] == NULL)
1274 u_sync(FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001275}
1276
1277/*
1278 * Make "typebuf" empty and allocate new buffers.
1279 * Returns FAIL when out of memory.
1280 */
1281 int
1282alloc_typebuf()
1283{
1284 typebuf.tb_buf = alloc(TYPELEN_INIT);
1285 typebuf.tb_noremap = alloc(TYPELEN_INIT);
1286 if (typebuf.tb_buf == NULL || typebuf.tb_noremap == NULL)
1287 {
1288 free_typebuf();
1289 return FAIL;
1290 }
1291 typebuf.tb_buflen = TYPELEN_INIT;
1292 typebuf.tb_off = 0;
1293 typebuf.tb_len = 0;
1294 typebuf.tb_maplen = 0;
1295 typebuf.tb_silent = 0;
1296 typebuf.tb_no_abbr_cnt = 0;
1297 if (++typebuf.tb_change_cnt == 0)
1298 typebuf.tb_change_cnt = 1;
1299 return OK;
1300}
1301
1302/*
1303 * Free the buffers of "typebuf".
1304 */
1305 void
1306free_typebuf()
1307{
Bram Moolenaaree3f7a52008-01-01 13:17:56 +00001308 if (typebuf.tb_buf == typebuf_init)
1309 EMSG2(_(e_intern2), "Free typebuf 1");
1310 else
1311 vim_free(typebuf.tb_buf);
Bram Moolenaarf6f95d92009-11-11 15:23:37 +00001312 if (typebuf.tb_noremap == noremapbuf_init)
Bram Moolenaaree3f7a52008-01-01 13:17:56 +00001313 EMSG2(_(e_intern2), "Free typebuf 2");
1314 else
1315 vim_free(typebuf.tb_noremap);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001316}
1317
1318/*
1319 * When doing ":so! file", the current typeahead needs to be saved, and
1320 * restored when "file" has been read completely.
1321 */
1322static typebuf_T saved_typebuf[NSCRIPT];
1323
1324 int
1325save_typebuf()
1326{
1327 init_typebuf();
1328 saved_typebuf[curscript] = typebuf;
1329 /* If out of memory: restore typebuf and close file. */
1330 if (alloc_typebuf() == FAIL)
1331 {
1332 closescript();
1333 return FAIL;
1334 }
1335 return OK;
1336}
1337
Bram Moolenaar13df0fe2009-07-09 16:24:19 +00001338static int old_char = -1; /* character put back by vungetc() */
1339static int old_mod_mask; /* mod_mask for ungotten character */
1340
Bram Moolenaar071d4272004-06-13 20:20:40 +00001341#if defined(FEAT_EVAL) || defined(FEAT_EX_EXTRA) || defined(PROTO)
1342
1343/*
1344 * Save all three kinds of typeahead, so that the user must type at a prompt.
1345 */
1346 void
1347save_typeahead(tp)
1348 tasave_T *tp;
1349{
1350 tp->save_typebuf = typebuf;
1351 tp->typebuf_valid = (alloc_typebuf() == OK);
1352 if (!tp->typebuf_valid)
1353 typebuf = tp->save_typebuf;
1354
Bram Moolenaar13df0fe2009-07-09 16:24:19 +00001355 tp->old_char = old_char;
1356 tp->old_mod_mask = old_mod_mask;
1357 old_char = -1;
1358
Bram Moolenaar071d4272004-06-13 20:20:40 +00001359 tp->save_stuffbuff = stuffbuff;
1360 stuffbuff.bh_first.b_next = NULL;
1361# ifdef USE_INPUT_BUF
1362 tp->save_inputbuf = get_input_buf();
1363# endif
1364}
1365
1366/*
1367 * Restore the typeahead to what it was before calling save_typeahead().
1368 * The allocated memory is freed, can only be called once!
1369 */
1370 void
1371restore_typeahead(tp)
1372 tasave_T *tp;
1373{
1374 if (tp->typebuf_valid)
1375 {
1376 free_typebuf();
1377 typebuf = tp->save_typebuf;
1378 }
1379
Bram Moolenaar13df0fe2009-07-09 16:24:19 +00001380 old_char = tp->old_char;
1381 old_mod_mask = tp->old_mod_mask;
1382
Bram Moolenaar071d4272004-06-13 20:20:40 +00001383 free_buff(&stuffbuff);
1384 stuffbuff = tp->save_stuffbuff;
1385# ifdef USE_INPUT_BUF
1386 set_input_buf(tp->save_inputbuf);
1387# endif
1388}
1389#endif
1390
1391/*
1392 * Open a new script file for the ":source!" command.
1393 */
1394 void
1395openscript(name, directly)
1396 char_u *name;
1397 int directly; /* when TRUE execute directly */
1398{
1399 if (curscript + 1 == NSCRIPT)
1400 {
1401 EMSG(_(e_nesting));
1402 return;
1403 }
Bram Moolenaaree3f7a52008-01-01 13:17:56 +00001404#ifdef FEAT_EVAL
1405 if (ignore_script)
1406 /* Not reading from script, also don't open one. Warning message? */
1407 return;
1408#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001409
1410 if (scriptin[curscript] != NULL) /* already reading script */
1411 ++curscript;
1412 /* use NameBuff for expanded name */
1413 expand_env(name, NameBuff, MAXPATHL);
1414 if ((scriptin[curscript] = mch_fopen((char *)NameBuff, READBIN)) == NULL)
1415 {
1416 EMSG2(_(e_notopen), name);
1417 if (curscript)
1418 --curscript;
1419 return;
1420 }
1421 if (save_typebuf() == FAIL)
1422 return;
1423
1424 /*
1425 * Execute the commands from the file right now when using ":source!"
1426 * after ":global" or ":argdo" or in a loop. Also when another command
1427 * follows. This means the display won't be updated. Don't do this
1428 * always, "make test" would fail.
1429 */
1430 if (directly)
1431 {
1432 oparg_T oa;
1433 int oldcurscript;
1434 int save_State = State;
1435 int save_restart_edit = restart_edit;
1436 int save_insertmode = p_im;
1437 int save_finish_op = finish_op;
1438 int save_msg_scroll = msg_scroll;
1439
1440 State = NORMAL;
1441 msg_scroll = FALSE; /* no msg scrolling in Normal mode */
1442 restart_edit = 0; /* don't go to Insert mode */
1443 p_im = FALSE; /* don't use 'insertmode' */
1444 clear_oparg(&oa);
1445 finish_op = FALSE;
1446
1447 oldcurscript = curscript;
1448 do
1449 {
1450 update_topline_cursor(); /* update cursor position and topline */
1451 normal_cmd(&oa, FALSE); /* execute one command */
1452 vpeekc(); /* check for end of file */
1453 }
1454 while (scriptin[oldcurscript] != NULL);
1455
1456 State = save_State;
1457 msg_scroll = save_msg_scroll;
1458 restart_edit = save_restart_edit;
1459 p_im = save_insertmode;
1460 finish_op = save_finish_op;
1461 }
1462}
1463
1464/*
1465 * Close the currently active input script.
1466 */
1467 static void
1468closescript()
1469{
1470 free_typebuf();
1471 typebuf = saved_typebuf[curscript];
1472
1473 fclose(scriptin[curscript]);
1474 scriptin[curscript] = NULL;
1475 if (curscript > 0)
1476 --curscript;
1477}
1478
Bram Moolenaarea408852005-06-25 22:49:46 +00001479#if defined(EXITFREE) || defined(PROTO)
1480 void
1481close_all_scripts()
1482{
1483 while (scriptin[0] != NULL)
1484 closescript();
1485}
1486#endif
1487
Bram Moolenaar071d4272004-06-13 20:20:40 +00001488#if defined(FEAT_INS_EXPAND) || defined(PROTO)
1489/*
1490 * Return TRUE when reading keys from a script file.
1491 */
1492 int
1493using_script()
1494{
1495 return scriptin[curscript] != NULL;
1496}
1497#endif
1498
1499/*
Bram Moolenaar238f4fa2005-06-27 22:25:50 +00001500 * This function is called just before doing a blocking wait. Thus after
1501 * waiting 'updatetime' for a character to arrive.
1502 */
1503 void
1504before_blocking()
1505{
1506 updatescript(0);
1507#ifdef FEAT_EVAL
Bram Moolenaar9fecb462006-09-05 10:59:47 +00001508 if (may_garbage_collect)
1509 garbage_collect();
Bram Moolenaar238f4fa2005-06-27 22:25:50 +00001510#endif
1511}
1512
1513/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00001514 * updatescipt() is called when a character can be written into the script file
1515 * or when we have waited some time for a character (c == 0)
1516 *
1517 * All the changed memfiles are synced if c == 0 or when the number of typed
1518 * characters reaches 'updatecount' and 'updatecount' is non-zero.
1519 */
1520 void
1521updatescript(c)
1522 int c;
1523{
1524 static int count = 0;
1525
1526 if (c && scriptout)
1527 putc(c, scriptout);
1528 if (c == 0 || (p_uc > 0 && ++count >= p_uc))
1529 {
1530 ml_sync_all(c == 0, TRUE);
1531 count = 0;
1532 }
1533}
1534
Bram Moolenaar071d4272004-06-13 20:20:40 +00001535/*
1536 * Get the next input character.
1537 * Can return a special key or a multi-byte character.
1538 * Can return NUL when called recursively, use safe_vgetc() if that's not
1539 * wanted.
1540 * This translates escaped K_SPECIAL and CSI bytes to a K_SPECIAL or CSI byte.
1541 * Collects the bytes of a multibyte character into the whole character.
Bram Moolenaarf6f95d92009-11-11 15:23:37 +00001542 * Returns the modifiers in the global "mod_mask".
Bram Moolenaar071d4272004-06-13 20:20:40 +00001543 */
1544 int
1545vgetc()
1546{
1547 int c, c2;
1548#ifdef FEAT_MBYTE
1549 int n;
Bram Moolenaar9a920d82012-06-01 15:21:02 +02001550 char_u buf[MB_MAXBYTES + 1];
Bram Moolenaar071d4272004-06-13 20:20:40 +00001551 int i;
1552#endif
1553
Bram Moolenaar9fecb462006-09-05 10:59:47 +00001554#ifdef FEAT_EVAL
1555 /* Do garbage collection when garbagecollect() was called previously and
1556 * we are now at the toplevel. */
1557 if (may_garbage_collect && want_garbage_collect)
1558 garbage_collect();
1559#endif
1560
Bram Moolenaar071d4272004-06-13 20:20:40 +00001561 /*
1562 * If a character was put back with vungetc, it was already processed.
1563 * Return it directly.
1564 */
1565 if (old_char != -1)
1566 {
1567 c = old_char;
1568 old_char = -1;
1569 mod_mask = old_mod_mask;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001570 }
Bram Moolenaar9fecb462006-09-05 10:59:47 +00001571 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00001572 {
Bram Moolenaar9fecb462006-09-05 10:59:47 +00001573 mod_mask = 0x0;
1574 last_recorded_len = 0;
1575 for (;;) /* this is done twice if there are modifiers */
1576 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00001577 if (mod_mask) /* no mapping after modifier has been read */
1578 {
1579 ++no_mapping;
1580 ++allow_keys;
1581 }
1582 c = vgetorpeek(TRUE);
1583 if (mod_mask)
1584 {
1585 --no_mapping;
1586 --allow_keys;
1587 }
1588
1589 /* Get two extra bytes for special keys */
1590 if (c == K_SPECIAL
1591#ifdef FEAT_GUI
1592 || c == CSI
1593#endif
1594 )
1595 {
Bram Moolenaar19a09a12005-03-04 23:39:37 +00001596 int save_allow_keys = allow_keys;
1597
Bram Moolenaar071d4272004-06-13 20:20:40 +00001598 ++no_mapping;
Bram Moolenaar19a09a12005-03-04 23:39:37 +00001599 allow_keys = 0; /* make sure BS is not found */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001600 c2 = vgetorpeek(TRUE); /* no mapping for these chars */
1601 c = vgetorpeek(TRUE);
1602 --no_mapping;
Bram Moolenaar19a09a12005-03-04 23:39:37 +00001603 allow_keys = save_allow_keys;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001604 if (c2 == KS_MODIFIER)
1605 {
1606 mod_mask = c;
1607 continue;
1608 }
1609 c = TO_SPECIAL(c2, c);
1610
1611#if defined(FEAT_GUI_W32) && defined(FEAT_MENU) && defined(FEAT_TEAROFF)
1612 /* Handle K_TEAROFF here, the caller of vgetc() doesn't need to
1613 * know that a menu was torn off */
1614 if (c == K_TEAROFF)
1615 {
1616 char_u name[200];
1617 int i;
1618
1619 /* get menu path, it ends with a <CR> */
1620 for (i = 0; (c = vgetorpeek(TRUE)) != '\r'; )
1621 {
1622 name[i] = c;
1623 if (i < 199)
1624 ++i;
1625 }
1626 name[i] = NUL;
1627 gui_make_tearoff(name);
1628 continue;
1629 }
1630#endif
Bram Moolenaar0eda7ac2010-06-26 05:38:18 +02001631#if defined(FEAT_GUI) && defined(FEAT_GUI_GTK) && defined(FEAT_MENU)
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00001632 /* GTK: <F10> normally selects the menu, but it's passed until
1633 * here to allow mapping it. Intercept and invoke the GTK
1634 * behavior if it's not mapped. */
1635 if (c == K_F10 && gui.menubar != NULL)
1636 {
1637 gtk_menu_shell_select_first(GTK_MENU_SHELL(gui.menubar), FALSE);
1638 continue;
1639 }
1640#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001641#ifdef FEAT_GUI
Bram Moolenaar61abfd12007-09-13 16:26:47 +00001642 /* Handle focus event here, so that the caller doesn't need to
1643 * know about it. Return K_IGNORE so that we loop once (needed if
1644 * 'lazyredraw' is set). */
Bram Moolenaar9c8791f2007-09-05 19:47:23 +00001645 if (c == K_FOCUSGAINED || c == K_FOCUSLOST)
1646 {
1647 ui_focus_change(c == K_FOCUSGAINED);
Bram Moolenaar61abfd12007-09-13 16:26:47 +00001648 c = K_IGNORE;
Bram Moolenaar9c8791f2007-09-05 19:47:23 +00001649 }
1650
Bram Moolenaar071d4272004-06-13 20:20:40 +00001651 /* Translate K_CSI to CSI. The special key is only used to avoid
1652 * it being recognized as the start of a special key. */
1653 if (c == K_CSI)
1654 c = CSI;
1655#endif
1656 }
1657#ifdef MSDOS
1658 /*
1659 * If K_NUL was typed, it is replaced by K_NUL, 3 in mch_inchar().
1660 * Delete the 3 here.
1661 */
1662 else if (c == K_NUL && vpeekc() == 3)
1663 (void)vgetorpeek(TRUE);
1664#endif
1665
Bram Moolenaara88d9682005-03-25 21:45:43 +00001666 /* a keypad or special function key was not mapped, use it like
1667 * its ASCII equivalent */
1668 switch (c)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001669 {
Bram Moolenaara88d9682005-03-25 21:45:43 +00001670 case K_KPLUS: c = '+'; break;
1671 case K_KMINUS: c = '-'; break;
1672 case K_KDIVIDE: c = '/'; break;
1673 case K_KMULTIPLY: c = '*'; break;
1674 case K_KENTER: c = CAR; break;
1675 case K_KPOINT:
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00001676#ifdef WIN32
Bram Moolenaara88d9682005-03-25 21:45:43 +00001677 /* Can be either '.' or a ',', *
1678 * depending on the type of keypad. */
1679 c = MapVirtualKey(VK_DECIMAL, 2); break;
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00001680#else
Bram Moolenaara88d9682005-03-25 21:45:43 +00001681 c = '.'; break;
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00001682#endif
Bram Moolenaara88d9682005-03-25 21:45:43 +00001683 case K_K0: c = '0'; break;
1684 case K_K1: c = '1'; break;
1685 case K_K2: c = '2'; break;
1686 case K_K3: c = '3'; break;
1687 case K_K4: c = '4'; break;
1688 case K_K5: c = '5'; break;
1689 case K_K6: c = '6'; break;
1690 case K_K7: c = '7'; break;
1691 case K_K8: c = '8'; break;
1692 case K_K9: c = '9'; break;
1693
1694 case K_XHOME:
1695 case K_ZHOME: if (mod_mask == MOD_MASK_SHIFT)
1696 {
1697 c = K_S_HOME;
1698 mod_mask = 0;
1699 }
1700 else if (mod_mask == MOD_MASK_CTRL)
1701 {
1702 c = K_C_HOME;
1703 mod_mask = 0;
1704 }
1705 else
1706 c = K_HOME;
1707 break;
1708 case K_XEND:
1709 case K_ZEND: if (mod_mask == MOD_MASK_SHIFT)
1710 {
1711 c = K_S_END;
1712 mod_mask = 0;
1713 }
1714 else if (mod_mask == MOD_MASK_CTRL)
1715 {
1716 c = K_C_END;
1717 mod_mask = 0;
1718 }
1719 else
1720 c = K_END;
1721 break;
1722
1723 case K_XUP: c = K_UP; break;
1724 case K_XDOWN: c = K_DOWN; break;
1725 case K_XLEFT: c = K_LEFT; break;
1726 case K_XRIGHT: c = K_RIGHT; break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001727 }
1728
1729#ifdef FEAT_MBYTE
1730 /* For a multi-byte character get all the bytes and return the
1731 * converted character.
1732 * Note: This will loop until enough bytes are received!
1733 */
1734 if (has_mbyte && (n = MB_BYTE2LEN_CHECK(c)) > 1)
1735 {
1736 ++no_mapping;
1737 buf[0] = c;
1738 for (i = 1; i < n; ++i)
1739 {
1740 buf[i] = vgetorpeek(TRUE);
1741 if (buf[i] == K_SPECIAL
1742#ifdef FEAT_GUI
1743 || buf[i] == CSI
1744#endif
1745 )
1746 {
1747 /* Must be a K_SPECIAL - KS_SPECIAL - KE_FILLER sequence,
1748 * which represents a K_SPECIAL (0x80),
1749 * or a CSI - KS_EXTRA - KE_CSI sequence, which represents
1750 * a CSI (0x9B),
1751 * of a K_SPECIAL - KS_EXTRA - KE_CSI, which is CSI too. */
1752 c = vgetorpeek(TRUE);
1753 if (vgetorpeek(TRUE) == (int)KE_CSI && c == KS_EXTRA)
1754 buf[i] = CSI;
1755 }
1756 }
1757 --no_mapping;
1758 c = (*mb_ptr2char)(buf);
1759 }
1760#endif
1761
Bram Moolenaar9fecb462006-09-05 10:59:47 +00001762 break;
1763 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001764 }
Bram Moolenaar9fecb462006-09-05 10:59:47 +00001765
1766#ifdef FEAT_EVAL
1767 /*
1768 * In the main loop "may_garbage_collect" can be set to do garbage
1769 * collection in the first next vgetc(). It's disabled after that to
1770 * avoid internally used Lists and Dicts to be freed.
1771 */
1772 may_garbage_collect = FALSE;
1773#endif
1774
1775 return c;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001776}
1777
1778/*
1779 * Like vgetc(), but never return a NUL when called recursively, get a key
1780 * directly from the user (ignoring typeahead).
1781 */
1782 int
1783safe_vgetc()
1784{
1785 int c;
1786
1787 c = vgetc();
1788 if (c == NUL)
1789 c = get_keystroke();
1790 return c;
1791}
1792
1793/*
Bram Moolenaar61abfd12007-09-13 16:26:47 +00001794 * Like safe_vgetc(), but loop to handle K_IGNORE.
1795 * Also ignore scrollbar events.
1796 */
1797 int
1798plain_vgetc()
1799{
1800 int c;
1801
1802 do
1803 {
1804 c = safe_vgetc();
1805 } while (c == K_IGNORE || c == K_VER_SCROLLBAR || c == K_HOR_SCROLLBAR);
1806 return c;
1807}
1808
1809/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00001810 * Check if a character is available, such that vgetc() will not block.
1811 * If the next character is a special character or multi-byte, the returned
1812 * character is not valid!.
1813 */
1814 int
1815vpeekc()
1816{
1817 if (old_char != -1)
1818 return old_char;
1819 return vgetorpeek(FALSE);
1820}
1821
1822#if defined(FEAT_TERMRESPONSE) || defined(PROTO)
1823/*
1824 * Like vpeekc(), but don't allow mapping. Do allow checking for terminal
1825 * codes.
1826 */
1827 int
1828vpeekc_nomap()
1829{
1830 int c;
1831
1832 ++no_mapping;
1833 ++allow_keys;
1834 c = vpeekc();
1835 --no_mapping;
1836 --allow_keys;
1837 return c;
1838}
1839#endif
1840
1841#if defined(FEAT_INS_EXPAND) || defined(PROTO)
1842/*
1843 * Check if any character is available, also half an escape sequence.
1844 * Trick: when no typeahead found, but there is something in the typeahead
1845 * buffer, it must be an ESC that is recognized as the start of a key code.
1846 */
1847 int
1848vpeekc_any()
1849{
1850 int c;
1851
1852 c = vpeekc();
1853 if (c == NUL && typebuf.tb_len > 0)
1854 c = ESC;
1855 return c;
1856}
1857#endif
1858
1859/*
1860 * Call vpeekc() without causing anything to be mapped.
1861 * Return TRUE if a character is available, FALSE otherwise.
1862 */
1863 int
1864char_avail()
1865{
1866 int retval;
1867
1868 ++no_mapping;
1869 retval = vpeekc();
1870 --no_mapping;
1871 return (retval != NUL);
1872}
1873
1874 void
1875vungetc(c) /* unget one character (can only be done once!) */
1876 int c;
1877{
1878 old_char = c;
1879 old_mod_mask = mod_mask;
1880}
1881
1882/*
1883 * get a character:
1884 * 1. from the stuffbuffer
1885 * This is used for abbreviated commands like "D" -> "d$".
1886 * Also used to redo a command for ".".
1887 * 2. from the typeahead buffer
1888 * Stores text obtained previously but not used yet.
1889 * Also stores the result of mappings.
1890 * Also used for the ":normal" command.
1891 * 3. from the user
1892 * This may do a blocking wait if "advance" is TRUE.
1893 *
1894 * if "advance" is TRUE (vgetc()):
1895 * really get the character.
1896 * KeyTyped is set to TRUE in the case the user typed the key.
1897 * KeyStuffed is TRUE if the character comes from the stuff buffer.
1898 * if "advance" is FALSE (vpeekc()):
1899 * just look whether there is a character available.
1900 *
1901 * When "no_mapping" is zero, checks for mappings in the current mode.
1902 * Only returns one byte (of a multi-byte character).
1903 * K_SPECIAL and CSI may be escaped, need to get two more bytes then.
1904 */
1905 static int
1906vgetorpeek(advance)
1907 int advance;
1908{
1909 int c, c1;
1910 int keylen;
1911 char_u *s;
1912 mapblock_T *mp;
1913#ifdef FEAT_LOCALMAP
1914 mapblock_T *mp2;
1915#endif
1916 mapblock_T *mp_match;
1917 int mp_match_len = 0;
1918 int timedout = FALSE; /* waited for more than 1 second
1919 for mapping to complete */
1920 int mapdepth = 0; /* check for recursive mapping */
1921 int mode_deleted = FALSE; /* set when mode has been deleted */
1922 int local_State;
1923 int mlen;
1924 int max_mlen;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001925 int i;
Bram Moolenaar4e427192006-03-10 21:34:27 +00001926#ifdef FEAT_CMDL_INFO
Bram Moolenaar071d4272004-06-13 20:20:40 +00001927 int new_wcol, new_wrow;
1928#endif
1929#ifdef FEAT_GUI
1930# ifdef FEAT_MENU
1931 int idx;
1932# endif
1933 int shape_changed = FALSE; /* adjusted cursor shape */
1934#endif
1935 int n;
1936#ifdef FEAT_LANGMAP
1937 int nolmaplen;
1938#endif
1939 int old_wcol, old_wrow;
Bram Moolenaar28a37ff2005-03-15 22:28:00 +00001940 int wait_tb_len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001941
1942 /*
1943 * This function doesn't work very well when called recursively. This may
1944 * happen though, because of:
1945 * 1. The call to add_to_showcmd(). char_avail() is then used to check if
1946 * there is a character available, which calls this function. In that
1947 * case we must return NUL, to indicate no character is available.
1948 * 2. A GUI callback function writes to the screen, causing a
1949 * wait_return().
1950 * Using ":normal" can also do this, but it saves the typeahead buffer,
1951 * thus it should be OK. But don't get a key from the user then.
1952 */
Bram Moolenaar5555acc2006-04-07 21:33:12 +00001953 if (vgetc_busy > 0
Bram Moolenaar071d4272004-06-13 20:20:40 +00001954#ifdef FEAT_EX_EXTRA
1955 && ex_normal_busy == 0
1956#endif
1957 )
1958 return NUL;
1959
1960 local_State = get_real_state();
1961
Bram Moolenaar5555acc2006-04-07 21:33:12 +00001962 ++vgetc_busy;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001963
1964 if (advance)
1965 KeyStuffed = FALSE;
1966
1967 init_typebuf();
1968 start_stuff();
1969 if (advance && typebuf.tb_maplen == 0)
1970 Exec_reg = FALSE;
1971 do
1972 {
1973/*
1974 * get a character: 1. from the stuffbuffer
1975 */
1976 if (typeahead_char != 0)
1977 {
1978 c = typeahead_char;
1979 if (advance)
1980 typeahead_char = 0;
1981 }
1982 else
1983 c = read_stuff(advance);
1984 if (c != NUL && !got_int)
1985 {
1986 if (advance)
1987 {
1988 /* KeyTyped = FALSE; When the command that stuffed something
1989 * was typed, behave like the stuffed command was typed.
1990 * needed for CTRL-W CTRl-] to open a fold, for example. */
1991 KeyStuffed = TRUE;
1992 }
1993 if (typebuf.tb_no_abbr_cnt == 0)
1994 typebuf.tb_no_abbr_cnt = 1; /* no abbreviations now */
1995 }
1996 else
1997 {
1998 /*
1999 * Loop until we either find a matching mapped key, or we
2000 * are sure that it is not a mapped key.
2001 * If a mapped key sequence is found we go back to the start to
2002 * try re-mapping.
2003 */
2004 for (;;)
2005 {
2006 /*
2007 * ui_breakcheck() is slow, don't use it too often when
2008 * inside a mapping. But call it each time for typed
2009 * characters.
2010 */
2011 if (typebuf.tb_maplen)
2012 line_breakcheck();
2013 else
2014 ui_breakcheck(); /* check for CTRL-C */
2015 keylen = 0;
2016 if (got_int)
2017 {
2018 /* flush all input */
2019 c = inchar(typebuf.tb_buf, typebuf.tb_buflen - 1, 0L,
2020 typebuf.tb_change_cnt);
2021 /*
2022 * If inchar() returns TRUE (script file was active) or we
2023 * are inside a mapping, get out of insert mode.
2024 * Otherwise we behave like having gotten a CTRL-C.
2025 * As a result typing CTRL-C in insert mode will
2026 * really insert a CTRL-C.
2027 */
2028 if ((c || typebuf.tb_maplen)
2029 && (State & (INSERT + CMDLINE)))
2030 c = ESC;
2031 else
2032 c = Ctrl_C;
2033 flush_buffers(TRUE); /* flush all typeahead */
2034
Bram Moolenaard9dfd572006-10-03 13:36:13 +00002035 if (advance)
2036 {
2037 /* Also record this character, it might be needed to
2038 * get out of Insert mode. */
2039 *typebuf.tb_buf = c;
2040 gotchars(typebuf.tb_buf, 1);
2041 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002042 cmd_silent = FALSE;
2043
2044 break;
2045 }
2046 else if (typebuf.tb_len > 0)
2047 {
2048 /*
2049 * Check for a mappable key sequence.
2050 * Walk through one maphash[] list until we find an
2051 * entry that matches.
2052 *
2053 * Don't look for mappings if:
2054 * - no_mapping set: mapping disabled (e.g. for CTRL-V)
2055 * - maphash_valid not set: no mappings present.
2056 * - typebuf.tb_buf[typebuf.tb_off] should not be remapped
2057 * - in insert or cmdline mode and 'paste' option set
2058 * - waiting for "hit return to continue" and CR or SPACE
2059 * typed
2060 * - waiting for a char with --more--
2061 * - in Ctrl-X mode, and we get a valid char for that mode
2062 */
2063 mp = NULL;
2064 max_mlen = 0;
2065 c1 = typebuf.tb_buf[typebuf.tb_off];
2066 if (no_mapping == 0 && maphash_valid
2067 && (no_zero_mapping == 0 || c1 != '0')
2068 && (typebuf.tb_maplen == 0
2069 || (p_remap
Bram Moolenaarf4b8e572004-06-24 15:53:16 +00002070 && (typebuf.tb_noremap[typebuf.tb_off]
2071 & (RM_NONE|RM_ABBR)) == 0))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002072 && !(p_paste && (State & (INSERT + CMDLINE)))
2073 && !(State == HITRETURN && (c1 == CAR || c1 == ' '))
2074 && State != ASKMORE
2075 && State != CONFIRM
2076#ifdef FEAT_INS_EXPAND
2077 && !((ctrl_x_mode != 0 && vim_is_ctrl_x_key(c1))
Bram Moolenaar4be06f92005-07-29 22:36:03 +00002078 || ((compl_cont_status & CONT_LOCAL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002079 && (c1 == Ctrl_N || c1 == Ctrl_P)))
2080#endif
2081 )
2082 {
2083#ifdef FEAT_LANGMAP
2084 if (c1 == K_SPECIAL)
2085 nolmaplen = 2;
2086 else
2087 {
2088 LANGMAP_ADJUST(c1, TRUE);
2089 nolmaplen = 0;
2090 }
2091#endif
2092#ifdef FEAT_LOCALMAP
2093 /* First try buffer-local mappings. */
2094 mp = curbuf->b_maphash[MAP_HASH(local_State, c1)];
2095 mp2 = maphash[MAP_HASH(local_State, c1)];
2096 if (mp == NULL)
2097 {
2098 mp = mp2;
2099 mp2 = NULL;
2100 }
2101#else
2102 mp = maphash[MAP_HASH(local_State, c1)];
2103#endif
2104 /*
2105 * Loop until a partly matching mapping is found or
2106 * all (local) mappings have been checked.
2107 * The longest full match is remembered in "mp_match".
2108 * A full match is only accepted if there is no partly
2109 * match, so "aa" and "aaa" can both be mapped.
2110 */
2111 mp_match = NULL;
2112 mp_match_len = 0;
2113 for ( ; mp != NULL;
2114#ifdef FEAT_LOCALMAP
2115 mp->m_next == NULL ? (mp = mp2, mp2 = NULL) :
2116#endif
2117 (mp = mp->m_next))
2118 {
2119 /*
2120 * Only consider an entry if the first character
2121 * matches and it is for the current state.
2122 * Skip ":lmap" mappings if keys were mapped.
2123 */
2124 if (mp->m_keys[0] == c1
2125 && (mp->m_mode & local_State)
2126 && ((mp->m_mode & LANGMAP) == 0
2127 || typebuf.tb_maplen == 0))
2128 {
2129#ifdef FEAT_LANGMAP
2130 int nomap = nolmaplen;
2131 int c2;
2132#endif
2133 /* find the match length of this mapping */
2134 for (mlen = 1; mlen < typebuf.tb_len; ++mlen)
2135 {
2136#ifdef FEAT_LANGMAP
2137 c2 = typebuf.tb_buf[typebuf.tb_off + mlen];
2138 if (nomap > 0)
2139 --nomap;
2140 else if (c2 == K_SPECIAL)
2141 nomap = 2;
2142 else
2143 LANGMAP_ADJUST(c2, TRUE);
2144 if (mp->m_keys[mlen] != c2)
2145#else
2146 if (mp->m_keys[mlen] !=
2147 typebuf.tb_buf[typebuf.tb_off + mlen])
2148#endif
2149 break;
2150 }
2151
2152#ifdef FEAT_MBYTE
2153 /* Don't allow mapping the first byte(s) of a
2154 * multi-byte char. Happens when mapping
2155 * <M-a> and then changing 'encoding'. */
2156 if (has_mbyte && MB_BYTE2LEN(c1)
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00002157 > (*mb_ptr2len)(mp->m_keys))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002158 mlen = 0;
2159#endif
2160 /*
2161 * Check an entry whether it matches.
2162 * - Full match: mlen == keylen
2163 * - Partly match: mlen == typebuf.tb_len
2164 */
2165 keylen = mp->m_keylen;
2166 if (mlen == keylen
2167 || (mlen == typebuf.tb_len
2168 && typebuf.tb_len < keylen))
2169 {
2170 /*
2171 * If only script-local mappings are
2172 * allowed, check if the mapping starts
2173 * with K_SNR.
2174 */
2175 s = typebuf.tb_noremap + typebuf.tb_off;
2176 if (*s == RM_SCRIPT
2177 && (mp->m_keys[0] != K_SPECIAL
2178 || mp->m_keys[1] != KS_EXTRA
2179 || mp->m_keys[2]
2180 != (int)KE_SNR))
2181 continue;
2182 /*
2183 * If one of the typed keys cannot be
2184 * remapped, skip the entry.
2185 */
2186 for (n = mlen; --n >= 0; )
Bram Moolenaarf4b8e572004-06-24 15:53:16 +00002187 if (*s++ & (RM_NONE|RM_ABBR))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002188 break;
2189 if (n >= 0)
2190 continue;
2191
2192 if (keylen > typebuf.tb_len)
2193 {
2194 if (!timedout)
2195 {
2196 /* break at a partly match */
Bram Moolenaar946ffd42010-12-30 12:30:31 +01002197 keylen = KEYLEN_PART_MAP;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002198 break;
2199 }
2200 }
2201 else if (keylen > mp_match_len)
2202 {
2203 /* found a longer match */
2204 mp_match = mp;
2205 mp_match_len = keylen;
2206 }
2207 }
2208 else
2209 /* No match; may have to check for
2210 * termcode at next character. */
2211 if (max_mlen < mlen)
2212 max_mlen = mlen;
2213 }
2214 }
2215
2216 /* If no partly match found, use the longest full
2217 * match. */
Bram Moolenaar946ffd42010-12-30 12:30:31 +01002218 if (keylen != KEYLEN_PART_MAP)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002219 {
2220 mp = mp_match;
2221 keylen = mp_match_len;
2222 }
2223 }
2224
2225 /* Check for match with 'pastetoggle' */
2226 if (*p_pt != NUL && mp == NULL && (State & (INSERT|NORMAL)))
2227 {
2228 for (mlen = 0; mlen < typebuf.tb_len && p_pt[mlen];
2229 ++mlen)
2230 if (p_pt[mlen] != typebuf.tb_buf[typebuf.tb_off
2231 + mlen])
2232 break;
2233 if (p_pt[mlen] == NUL) /* match */
2234 {
2235 /* write chars to script file(s) */
2236 if (mlen > typebuf.tb_maplen)
2237 gotchars(typebuf.tb_buf + typebuf.tb_off
2238 + typebuf.tb_maplen,
2239 mlen - typebuf.tb_maplen);
2240
2241 del_typebuf(mlen, 0); /* remove the chars */
2242 set_option_value((char_u *)"paste",
2243 (long)!p_paste, NULL, 0);
2244 if (!(State & INSERT))
2245 {
2246 msg_col = 0;
2247 msg_row = Rows - 1;
2248 msg_clr_eos(); /* clear ruler */
2249 }
2250 showmode();
2251 setcursor();
2252 continue;
2253 }
2254 /* Need more chars for partly match. */
2255 if (mlen == typebuf.tb_len)
Bram Moolenaar946ffd42010-12-30 12:30:31 +01002256 keylen = KEYLEN_PART_KEY;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002257 else if (max_mlen < mlen)
2258 /* no match, may have to check for termcode at
2259 * next character */
2260 max_mlen = mlen + 1;
2261 }
2262
2263 if ((mp == NULL || max_mlen >= mp_match_len)
Bram Moolenaar946ffd42010-12-30 12:30:31 +01002264 && keylen != KEYLEN_PART_MAP)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002265 {
Bram Moolenaarf2330482008-06-24 20:19:36 +00002266 int save_keylen = keylen;
2267
Bram Moolenaar071d4272004-06-13 20:20:40 +00002268 /*
2269 * When no matching mapping found or found a
2270 * non-matching mapping that matches at least what the
2271 * matching mapping matched:
2272 * Check if we have a terminal code, when:
2273 * mapping is allowed,
2274 * keys have not been mapped,
2275 * and not an ESC sequence, not in insert mode or
2276 * p_ek is on,
2277 * and when not timed out,
2278 */
2279 if ((no_mapping == 0 || allow_keys != 0)
2280 && (typebuf.tb_maplen == 0
2281 || (p_remap && typebuf.tb_noremap[
2282 typebuf.tb_off] == RM_YES))
2283 && !timedout)
2284 {
Bram Moolenaara8c8a682012-02-05 22:05:48 +01002285 keylen = check_termcode(max_mlen + 1,
2286 NULL, 0, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002287
Bram Moolenaarf2330482008-06-24 20:19:36 +00002288 /* If no termcode matched but 'pastetoggle'
2289 * matched partially it's like an incomplete key
2290 * sequence. */
Bram Moolenaar946ffd42010-12-30 12:30:31 +01002291 if (keylen == 0 && save_keylen == KEYLEN_PART_KEY)
2292 keylen = KEYLEN_PART_KEY;
Bram Moolenaarf2330482008-06-24 20:19:36 +00002293
Bram Moolenaar071d4272004-06-13 20:20:40 +00002294 /*
2295 * When getting a partial match, but the last
2296 * characters were not typed, don't wait for a
2297 * typed character to complete the termcode.
2298 * This helps a lot when a ":normal" command ends
2299 * in an ESC.
2300 */
2301 if (keylen < 0
2302 && typebuf.tb_len == typebuf.tb_maplen)
2303 keylen = 0;
2304 }
2305 else
2306 keylen = 0;
2307 if (keylen == 0) /* no matching terminal code */
2308 {
2309#ifdef AMIGA /* check for window bounds report */
2310 if (typebuf.tb_maplen == 0 && (typebuf.tb_buf[
2311 typebuf.tb_off] & 0xff) == CSI)
2312 {
2313 for (s = typebuf.tb_buf + typebuf.tb_off + 1;
2314 s < typebuf.tb_buf + typebuf.tb_off
2315 + typebuf.tb_len
2316 && (VIM_ISDIGIT(*s) || *s == ';'
2317 || *s == ' ');
2318 ++s)
2319 ;
2320 if (*s == 'r' || *s == '|') /* found one */
2321 {
2322 del_typebuf((int)(s + 1 -
2323 (typebuf.tb_buf + typebuf.tb_off)), 0);
2324 /* get size and redraw screen */
2325 shell_resized();
2326 continue;
2327 }
2328 if (*s == NUL) /* need more characters */
Bram Moolenaar946ffd42010-12-30 12:30:31 +01002329 keylen = KEYLEN_PART_KEY;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002330 }
2331 if (keylen >= 0)
2332#endif
2333 /* When there was a matching mapping and no
2334 * termcode could be replaced after another one,
Bram Moolenaarf2330482008-06-24 20:19:36 +00002335 * use that mapping (loop around). If there was
2336 * no mapping use the character from the
2337 * typeahead buffer right here. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002338 if (mp == NULL)
2339 {
2340/*
2341 * get a character: 2. from the typeahead buffer
2342 */
2343 c = typebuf.tb_buf[typebuf.tb_off] & 255;
2344 if (advance) /* remove chars from tb_buf */
2345 {
2346 cmd_silent = (typebuf.tb_silent > 0);
2347 if (typebuf.tb_maplen > 0)
2348 KeyTyped = FALSE;
2349 else
2350 {
2351 KeyTyped = TRUE;
2352 /* write char to script file(s) */
2353 gotchars(typebuf.tb_buf
2354 + typebuf.tb_off, 1);
2355 }
Bram Moolenaarcf8e7d12006-12-05 20:43:17 +00002356 KeyNoremap = typebuf.tb_noremap[
2357 typebuf.tb_off];
Bram Moolenaar071d4272004-06-13 20:20:40 +00002358 del_typebuf(1, 0);
2359 }
2360 break; /* got character, break for loop */
2361 }
2362 }
2363 if (keylen > 0) /* full matching terminal code */
2364 {
2365#if defined(FEAT_GUI) && defined(FEAT_MENU)
Bram Moolenaar946ffd42010-12-30 12:30:31 +01002366 if (typebuf.tb_len >= 2
2367 && typebuf.tb_buf[typebuf.tb_off] == K_SPECIAL
Bram Moolenaar071d4272004-06-13 20:20:40 +00002368 && typebuf.tb_buf[typebuf.tb_off + 1]
2369 == KS_MENU)
2370 {
2371 /*
2372 * Using a menu may cause a break in undo!
2373 * It's like using gotchars(), but without
2374 * recording or writing to a script file.
2375 */
2376 may_sync_undo();
2377 del_typebuf(3, 0);
2378 idx = get_menu_index(current_menu, local_State);
2379 if (idx != MENU_INDEX_INVALID)
2380 {
2381# ifdef FEAT_VISUAL
2382 /*
Bram Moolenaar371d5402006-03-20 21:47:49 +00002383 * In Select mode and a Visual mode menu
2384 * is used: Switch to Visual mode
Bram Moolenaar071d4272004-06-13 20:20:40 +00002385 * temporarily. Append K_SELECT to switch
2386 * back to Select mode.
2387 */
Bram Moolenaar371d5402006-03-20 21:47:49 +00002388 if (VIsual_active && VIsual_select
2389 && (current_menu->modes & VISUAL))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002390 {
2391 VIsual_select = FALSE;
2392 (void)ins_typebuf(K_SELECT_STRING,
2393 REMAP_NONE, 0, TRUE, FALSE);
2394 }
2395# endif
2396 ins_typebuf(current_menu->strings[idx],
2397 current_menu->noremap[idx],
2398 0, TRUE,
2399 current_menu->silent[idx]);
2400 }
2401 }
Bram Moolenaaree3f7a52008-01-01 13:17:56 +00002402#endif /* FEAT_GUI && FEAT_MENU */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002403 continue; /* try mapping again */
2404 }
2405
2406 /* Partial match: get some more characters. When a
2407 * matching mapping was found use that one. */
2408 if (mp == NULL || keylen < 0)
Bram Moolenaar946ffd42010-12-30 12:30:31 +01002409 keylen = KEYLEN_PART_KEY;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002410 else
2411 keylen = mp_match_len;
2412 }
2413
2414 /* complete match */
2415 if (keylen >= 0 && keylen <= typebuf.tb_len)
2416 {
Bram Moolenaar0dbf7202010-01-27 17:31:43 +01002417#ifdef FEAT_EVAL
2418 int save_m_expr;
2419 int save_m_noremap;
2420 int save_m_silent;
2421 char_u *save_m_keys;
2422 char_u *save_m_str;
2423#else
2424# define save_m_noremap mp->m_noremap
2425# define save_m_silent mp->m_silent
2426#endif
2427
Bram Moolenaar071d4272004-06-13 20:20:40 +00002428 /* write chars to script file(s) */
2429 if (keylen > typebuf.tb_maplen)
2430 gotchars(typebuf.tb_buf + typebuf.tb_off
2431 + typebuf.tb_maplen,
2432 keylen - typebuf.tb_maplen);
2433
2434 cmd_silent = (typebuf.tb_silent > 0);
2435 del_typebuf(keylen, 0); /* remove the mapped keys */
2436
2437 /*
2438 * Put the replacement string in front of mapstr.
2439 * The depth check catches ":map x y" and ":map y x".
2440 */
2441 if (++mapdepth >= p_mmd)
2442 {
2443 EMSG(_("E223: recursive mapping"));
2444 if (State & CMDLINE)
2445 redrawcmdline();
2446 else
2447 setcursor();
2448 flush_buffers(FALSE);
2449 mapdepth = 0; /* for next one */
2450 c = -1;
2451 break;
2452 }
2453
2454#ifdef FEAT_VISUAL
2455 /*
Bram Moolenaar371d5402006-03-20 21:47:49 +00002456 * In Select mode and a Visual mode mapping is used:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002457 * Switch to Visual mode temporarily. Append K_SELECT
2458 * to switch back to Select mode.
2459 */
Bram Moolenaar371d5402006-03-20 21:47:49 +00002460 if (VIsual_active && VIsual_select
2461 && (mp->m_mode & VISUAL))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002462 {
2463 VIsual_select = FALSE;
2464 (void)ins_typebuf(K_SELECT_STRING, REMAP_NONE,
2465 0, TRUE, FALSE);
2466 }
2467#endif
2468
Bram Moolenaar4e427192006-03-10 21:34:27 +00002469#ifdef FEAT_EVAL
Bram Moolenaar0dbf7202010-01-27 17:31:43 +01002470 /* Copy the values from *mp that are used, because
2471 * evaluating the expression may invoke a function
2472 * that redefines the mapping, thereby making *mp
2473 * invalid. */
2474 save_m_expr = mp->m_expr;
2475 save_m_noremap = mp->m_noremap;
2476 save_m_silent = mp->m_silent;
2477 save_m_keys = NULL; /* only saved when needed */
2478 save_m_str = NULL; /* only saved when needed */
2479
Bram Moolenaar4e427192006-03-10 21:34:27 +00002480 /*
2481 * Handle ":map <expr>": evaluate the {rhs} as an
Bram Moolenaarb3479bd2011-10-12 22:02:14 +02002482 * expression. Also save and restore the command line
2483 * for "normal :".
Bram Moolenaar4e427192006-03-10 21:34:27 +00002484 */
2485 if (mp->m_expr)
Bram Moolenaar5555acc2006-04-07 21:33:12 +00002486 {
Bram Moolenaar5555acc2006-04-07 21:33:12 +00002487 int save_vgetc_busy = vgetc_busy;
2488
Bram Moolenaarb3479bd2011-10-12 22:02:14 +02002489 vgetc_busy = 0;
2490 save_m_keys = vim_strsave(mp->m_keys);
2491 save_m_str = vim_strsave(mp->m_str);
2492 s = eval_map_expr(save_m_str, NUL);
2493 vgetc_busy = save_vgetc_busy;
Bram Moolenaar5555acc2006-04-07 21:33:12 +00002494 }
Bram Moolenaar4e427192006-03-10 21:34:27 +00002495 else
2496#endif
2497 s = mp->m_str;
2498
Bram Moolenaar071d4272004-06-13 20:20:40 +00002499 /*
2500 * Insert the 'to' part in the typebuf.tb_buf.
2501 * If 'from' field is the same as the start of the
Bram Moolenaarf4b8e572004-06-24 15:53:16 +00002502 * 'to' field, don't remap the first character (but do
2503 * allow abbreviations).
Bram Moolenaar071d4272004-06-13 20:20:40 +00002504 * If m_noremap is set, don't remap the whole 'to'
2505 * part.
2506 */
Bram Moolenaar4e427192006-03-10 21:34:27 +00002507 if (s == NULL)
2508 i = FAIL;
2509 else
2510 {
Bram Moolenaard21d9a62010-01-28 22:58:16 +01002511 int noremap;
2512
2513 if (save_m_noremap != REMAP_YES)
2514 noremap = save_m_noremap;
2515 else if (
Bram Moolenaar0dbf7202010-01-27 17:31:43 +01002516#ifdef FEAT_EVAL
Bram Moolenaard21d9a62010-01-28 22:58:16 +01002517 STRNCMP(s, save_m_keys != NULL
2518 ? save_m_keys : mp->m_keys,
2519 (size_t)keylen)
2520#else
2521 STRNCMP(s, mp->m_keys, (size_t)keylen)
Bram Moolenaar0dbf7202010-01-27 17:31:43 +01002522#endif
Bram Moolenaard21d9a62010-01-28 22:58:16 +01002523 != 0)
2524 noremap = REMAP_YES;
2525 else
2526 noremap = REMAP_SKIP;
2527 i = ins_typebuf(s, noremap,
2528 0, TRUE, cmd_silent || save_m_silent);
Bram Moolenaar4e427192006-03-10 21:34:27 +00002529#ifdef FEAT_EVAL
Bram Moolenaar0dbf7202010-01-27 17:31:43 +01002530 if (save_m_expr)
Bram Moolenaar4e427192006-03-10 21:34:27 +00002531 vim_free(s);
2532#endif
2533 }
Bram Moolenaar0dbf7202010-01-27 17:31:43 +01002534#ifdef FEAT_EVAL
2535 vim_free(save_m_keys);
2536 vim_free(save_m_str);
2537#endif
Bram Moolenaar4e427192006-03-10 21:34:27 +00002538 if (i == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002539 {
2540 c = -1;
2541 break;
2542 }
2543 continue;
2544 }
2545 }
2546
2547/*
2548 * get a character: 3. from the user - handle <Esc> in Insert mode
2549 */
2550 /*
2551 * special case: if we get an <ESC> in insert mode and there
2552 * are no more characters at once, we pretend to go out of
2553 * insert mode. This prevents the one second delay after
2554 * typing an <ESC>. If we get something after all, we may
2555 * have to redisplay the mode. That the cursor is in the wrong
2556 * place does not matter.
2557 */
2558 c = 0;
2559#ifdef FEAT_CMDL_INFO
2560 new_wcol = curwin->w_wcol;
2561 new_wrow = curwin->w_wrow;
2562#endif
2563 if ( advance
2564 && typebuf.tb_len == 1
2565 && typebuf.tb_buf[typebuf.tb_off] == ESC
2566 && !no_mapping
2567#ifdef FEAT_EX_EXTRA
2568 && ex_normal_busy == 0
2569#endif
2570 && typebuf.tb_maplen == 0
2571 && (State & INSERT)
Bram Moolenaar946ffd42010-12-30 12:30:31 +01002572 && (p_timeout
2573 || (keylen == KEYLEN_PART_KEY && p_ttimeout))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002574 && (c = inchar(typebuf.tb_buf + typebuf.tb_off
2575 + typebuf.tb_len, 3, 25L,
2576 typebuf.tb_change_cnt)) == 0)
2577 {
2578 colnr_T col = 0, vcol;
2579 char_u *ptr;
2580
Bram Moolenaar28c258f2006-01-25 22:02:51 +00002581 if (mode_displayed)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002582 {
2583 unshowmode(TRUE);
2584 mode_deleted = TRUE;
2585 }
2586#ifdef FEAT_GUI
2587 /* may show different cursor shape */
2588 if (gui.in_use)
2589 {
2590 int save_State;
2591
2592 save_State = State;
2593 State = NORMAL;
2594 gui_update_cursor(TRUE, FALSE);
2595 State = save_State;
2596 shape_changed = TRUE;
2597 }
2598#endif
2599 validate_cursor();
2600 old_wcol = curwin->w_wcol;
2601 old_wrow = curwin->w_wrow;
2602
2603 /* move cursor left, if possible */
2604 if (curwin->w_cursor.col != 0)
2605 {
2606 if (curwin->w_wcol > 0)
2607 {
2608 if (did_ai)
2609 {
2610 /*
2611 * We are expecting to truncate the trailing
2612 * white-space, so find the last non-white
2613 * character -- webb
2614 */
2615 col = vcol = curwin->w_wcol = 0;
2616 ptr = ml_get_curline();
2617 while (col < curwin->w_cursor.col)
2618 {
2619 if (!vim_iswhite(ptr[col]))
2620 curwin->w_wcol = vcol;
2621 vcol += lbr_chartabsize(ptr + col,
2622 (colnr_T)vcol);
2623#ifdef FEAT_MBYTE
2624 if (has_mbyte)
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00002625 col += (*mb_ptr2len)(ptr + col);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002626 else
2627#endif
2628 ++col;
2629 }
2630 curwin->w_wrow = curwin->w_cline_row
2631 + curwin->w_wcol / W_WIDTH(curwin);
2632 curwin->w_wcol %= W_WIDTH(curwin);
2633 curwin->w_wcol += curwin_col_off();
2634#ifdef FEAT_MBYTE
2635 col = 0; /* no correction needed */
2636#endif
2637 }
2638 else
2639 {
2640 --curwin->w_wcol;
2641#ifdef FEAT_MBYTE
2642 col = curwin->w_cursor.col - 1;
2643#endif
2644 }
2645 }
2646 else if (curwin->w_p_wrap && curwin->w_wrow)
2647 {
2648 --curwin->w_wrow;
2649 curwin->w_wcol = W_WIDTH(curwin) - 1;
2650#ifdef FEAT_MBYTE
2651 col = curwin->w_cursor.col - 1;
2652#endif
2653 }
2654#ifdef FEAT_MBYTE
2655 if (has_mbyte && col > 0 && curwin->w_wcol > 0)
2656 {
2657 /* Correct when the cursor is on the right halve
2658 * of a double-wide character. */
2659 ptr = ml_get_curline();
2660 col -= (*mb_head_off)(ptr, ptr + col);
2661 if ((*mb_ptr2cells)(ptr + col) > 1)
2662 --curwin->w_wcol;
2663 }
2664#endif
2665 }
2666 setcursor();
2667 out_flush();
2668#ifdef FEAT_CMDL_INFO
2669 new_wcol = curwin->w_wcol;
2670 new_wrow = curwin->w_wrow;
2671#endif
2672 curwin->w_wcol = old_wcol;
2673 curwin->w_wrow = old_wrow;
2674 }
2675 if (c < 0)
2676 continue; /* end of input script reached */
2677 typebuf.tb_len += c;
2678
2679 /* buffer full, don't map */
2680 if (typebuf.tb_len >= typebuf.tb_maplen + MAXMAPLEN)
2681 {
2682 timedout = TRUE;
2683 continue;
2684 }
2685
2686#ifdef FEAT_EX_EXTRA
2687 if (ex_normal_busy > 0)
2688 {
2689# ifdef FEAT_CMDWIN
2690 static int tc = 0;
2691# endif
2692
2693 /* No typeahead left and inside ":normal". Must return
2694 * something to avoid getting stuck. When an incomplete
2695 * mapping is present, behave like it timed out. */
2696 if (typebuf.tb_len > 0)
2697 {
2698 timedout = TRUE;
2699 continue;
2700 }
2701 /* When 'insertmode' is set, ESC just beeps in Insert
2702 * mode. Use CTRL-L to make edit() return.
2703 * For the command line only CTRL-C always breaks it.
2704 * For the cmdline window: Alternate between ESC and
2705 * CTRL-C: ESC for most situations and CTRL-C to close the
2706 * cmdline window. */
2707 if (p_im && (State & INSERT))
2708 c = Ctrl_L;
2709 else if ((State & CMDLINE)
2710# ifdef FEAT_CMDWIN
2711 || (cmdwin_type > 0 && tc == ESC)
2712# endif
2713 )
2714 c = Ctrl_C;
2715 else
2716 c = ESC;
2717# ifdef FEAT_CMDWIN
2718 tc = c;
2719# endif
2720 break;
2721 }
2722#endif
2723
2724/*
2725 * get a character: 3. from the user - update display
2726 */
2727 /* In insert mode a screen update is skipped when characters
2728 * are still available. But when those available characters
2729 * are part of a mapping, and we are going to do a blocking
2730 * wait here. Need to update the screen to display the
Bram Moolenaar6eb634e2011-03-03 15:04:08 +01002731 * changed text so far. Also for when 'lazyredraw' is set and
2732 * redrawing was postponed because there was something in the
2733 * input buffer (e.g., termresponse). */
Bram Moolenaarfd30cd42011-03-22 13:07:26 +01002734 if (((State & INSERT) != 0 || p_lz) && (State & CMDLINE) == 0
2735 && advance && must_redraw != 0 && !need_wait_return)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002736 {
2737 update_screen(0);
2738 setcursor(); /* put cursor back where it belongs */
2739 }
2740
2741 /*
2742 * If we have a partial match (and are going to wait for more
2743 * input from the user), show the partially matched characters
2744 * to the user with showcmd.
2745 */
2746#ifdef FEAT_CMDL_INFO
2747 i = 0;
2748#endif
2749 c1 = 0;
2750 if (typebuf.tb_len > 0 && advance && !exmode_active)
2751 {
2752 if (((State & (NORMAL | INSERT)) || State == LANGMAP)
2753 && State != HITRETURN)
2754 {
2755 /* this looks nice when typing a dead character map */
2756 if (State & INSERT
2757 && ptr2cells(typebuf.tb_buf + typebuf.tb_off
2758 + typebuf.tb_len - 1) == 1)
2759 {
2760 edit_putchar(typebuf.tb_buf[typebuf.tb_off
2761 + typebuf.tb_len - 1], FALSE);
2762 setcursor(); /* put cursor back where it belongs */
2763 c1 = 1;
2764 }
2765#ifdef FEAT_CMDL_INFO
2766 /* need to use the col and row from above here */
2767 old_wcol = curwin->w_wcol;
2768 old_wrow = curwin->w_wrow;
2769 curwin->w_wcol = new_wcol;
2770 curwin->w_wrow = new_wrow;
2771 push_showcmd();
2772 if (typebuf.tb_len > SHOWCMD_COLS)
2773 i = typebuf.tb_len - SHOWCMD_COLS;
2774 while (i < typebuf.tb_len)
2775 (void)add_to_showcmd(typebuf.tb_buf[typebuf.tb_off
2776 + i++]);
2777 curwin->w_wcol = old_wcol;
2778 curwin->w_wrow = old_wrow;
2779#endif
2780 }
2781
2782 /* this looks nice when typing a dead character map */
2783 if ((State & CMDLINE)
2784#if defined(FEAT_CRYPT) || defined(FEAT_EVAL)
2785 && cmdline_star == 0
2786#endif
2787 && ptr2cells(typebuf.tb_buf + typebuf.tb_off
2788 + typebuf.tb_len - 1) == 1)
2789 {
2790 putcmdline(typebuf.tb_buf[typebuf.tb_off
2791 + typebuf.tb_len - 1], FALSE);
2792 c1 = 1;
2793 }
2794 }
2795
2796/*
2797 * get a character: 3. from the user - get it
2798 */
Bram Moolenaar28a37ff2005-03-15 22:28:00 +00002799 wait_tb_len = typebuf.tb_len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002800 c = inchar(typebuf.tb_buf + typebuf.tb_off + typebuf.tb_len,
2801 typebuf.tb_buflen - typebuf.tb_off - typebuf.tb_len - 1,
2802 !advance
2803 ? 0
2804 : ((typebuf.tb_len == 0
2805 || !(p_timeout || (p_ttimeout
Bram Moolenaar946ffd42010-12-30 12:30:31 +01002806 && keylen == KEYLEN_PART_KEY)))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002807 ? -1L
Bram Moolenaar946ffd42010-12-30 12:30:31 +01002808 : ((keylen == KEYLEN_PART_KEY && p_ttm >= 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002809 ? p_ttm
2810 : p_tm)), typebuf.tb_change_cnt);
2811
2812#ifdef FEAT_CMDL_INFO
2813 if (i != 0)
2814 pop_showcmd();
2815#endif
2816 if (c1 == 1)
2817 {
2818 if (State & INSERT)
2819 edit_unputchar();
2820 if (State & CMDLINE)
2821 unputcmdline();
Bram Moolenaarbc256d92012-06-06 12:06:15 +02002822 else
2823 setcursor(); /* put cursor back where it belongs */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002824 }
2825
2826 if (c < 0)
2827 continue; /* end of input script reached */
2828 if (c == NUL) /* no character available */
2829 {
2830 if (!advance)
2831 break;
Bram Moolenaar28a37ff2005-03-15 22:28:00 +00002832 if (wait_tb_len > 0) /* timed out */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002833 {
2834 timedout = TRUE;
2835 continue;
2836 }
2837 }
2838 else
2839 { /* allow mapping for just typed characters */
2840 while (typebuf.tb_buf[typebuf.tb_off
2841 + typebuf.tb_len] != NUL)
2842 typebuf.tb_noremap[typebuf.tb_off
2843 + typebuf.tb_len++] = RM_YES;
2844#ifdef USE_IM_CONTROL
2845 /* Get IM status right after getting keys, not after the
2846 * timeout for a mapping (focus may be lost by then). */
2847 vgetc_im_active = im_get_status();
2848#endif
2849 }
2850 } /* for (;;) */
2851 } /* if (!character from stuffbuf) */
2852
2853 /* if advance is FALSE don't loop on NULs */
2854 } while (c < 0 || (advance && c == NUL));
2855
2856 /*
2857 * The "INSERT" message is taken care of here:
2858 * if we return an ESC to exit insert mode, the message is deleted
2859 * if we don't return an ESC but deleted the message before, redisplay it
2860 */
Bram Moolenaar09df3122006-01-23 22:23:09 +00002861 if (advance && p_smd && msg_silent == 0 && (State & INSERT))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002862 {
Bram Moolenaar28c258f2006-01-25 22:02:51 +00002863 if (c == ESC && !mode_deleted && !no_mapping && mode_displayed)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002864 {
2865 if (typebuf.tb_len && !KeyTyped)
2866 redraw_cmdline = TRUE; /* delete mode later */
2867 else
2868 unshowmode(FALSE);
2869 }
2870 else if (c != ESC && mode_deleted)
2871 {
2872 if (typebuf.tb_len && !KeyTyped)
2873 redraw_cmdline = TRUE; /* show mode later */
2874 else
2875 showmode();
2876 }
2877 }
2878#ifdef FEAT_GUI
2879 /* may unshow different cursor shape */
2880 if (gui.in_use && shape_changed)
2881 gui_update_cursor(TRUE, FALSE);
2882#endif
2883
Bram Moolenaar5555acc2006-04-07 21:33:12 +00002884 --vgetc_busy;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002885
2886 return c;
2887}
2888
2889/*
2890 * inchar() - get one character from
2891 * 1. a scriptfile
2892 * 2. the keyboard
2893 *
2894 * As much characters as we can get (upto 'maxlen') are put in "buf" and
2895 * NUL terminated (buffer length must be 'maxlen' + 1).
2896 * Minimum for "maxlen" is 3!!!!
2897 *
2898 * "tb_change_cnt" is the value of typebuf.tb_change_cnt if "buf" points into
2899 * it. When typebuf.tb_change_cnt changes (e.g., when a message is received
2900 * from a remote client) "buf" can no longer be used. "tb_change_cnt" is 0
2901 * otherwise.
2902 *
2903 * If we got an interrupt all input is read until none is available.
2904 *
2905 * If wait_time == 0 there is no waiting for the char.
2906 * If wait_time == n we wait for n msec for a character to arrive.
2907 * If wait_time == -1 we wait forever for a character to arrive.
2908 *
2909 * Return the number of obtained characters.
2910 * Return -1 when end of input script reached.
2911 */
2912 int
2913inchar(buf, maxlen, wait_time, tb_change_cnt)
2914 char_u *buf;
2915 int maxlen;
2916 long wait_time; /* milli seconds */
2917 int tb_change_cnt;
2918{
2919 int len = 0; /* init for GCC */
2920 int retesc = FALSE; /* return ESC with gotint */
2921 int script_char;
2922
2923 if (wait_time == -1L || wait_time > 100L) /* flush output before waiting */
2924 {
2925 cursor_on();
2926 out_flush();
2927#ifdef FEAT_GUI
2928 if (gui.in_use)
2929 {
2930 gui_update_cursor(FALSE, FALSE);
2931# ifdef FEAT_MOUSESHAPE
2932 if (postponed_mouseshape)
2933 update_mouseshape(-1);
2934# endif
2935 }
2936#endif
2937 }
2938
2939 /*
2940 * Don't reset these when at the hit-return prompt, otherwise a endless
2941 * recursive loop may result (write error in swapfile, hit-return, timeout
2942 * on char wait, flush swapfile, write error....).
2943 */
2944 if (State != HITRETURN)
2945 {
2946 did_outofmem_msg = FALSE; /* display out of memory message (again) */
2947 did_swapwrite_msg = FALSE; /* display swap file write error again */
2948 }
2949 undo_off = FALSE; /* restart undo now */
2950
2951 /*
Bram Moolenaaree3f7a52008-01-01 13:17:56 +00002952 * Get a character from a script file if there is one.
2953 * If interrupted: Stop reading script files, close them all.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002954 */
2955 script_char = -1;
Bram Moolenaaree3f7a52008-01-01 13:17:56 +00002956 while (scriptin[curscript] != NULL && script_char < 0
2957#ifdef FEAT_EVAL
2958 && !ignore_script
2959#endif
2960 )
Bram Moolenaar071d4272004-06-13 20:20:40 +00002961 {
Bram Moolenaarf2330482008-06-24 20:19:36 +00002962
2963#if defined(FEAT_NETBEANS_INTG)
2964 /* Process the queued netbeans messages. */
Bram Moolenaarcc448b32010-07-14 16:52:17 +02002965 netbeans_parse_messages();
Bram Moolenaarf2330482008-06-24 20:19:36 +00002966#endif
2967
Bram Moolenaar071d4272004-06-13 20:20:40 +00002968 if (got_int || (script_char = getc(scriptin[curscript])) < 0)
2969 {
2970 /* Reached EOF.
2971 * Careful: closescript() frees typebuf.tb_buf[] and buf[] may
2972 * point inside typebuf.tb_buf[]. Don't use buf[] after this! */
2973 closescript();
2974 /*
2975 * When reading script file is interrupted, return an ESC to get
2976 * back to normal mode.
2977 * Otherwise return -1, because typebuf.tb_buf[] has changed.
2978 */
2979 if (got_int)
2980 retesc = TRUE;
2981 else
2982 return -1;
2983 }
2984 else
2985 {
2986 buf[0] = script_char;
2987 len = 1;
2988 }
2989 }
2990
2991 if (script_char < 0) /* did not get a character from script */
2992 {
2993 /*
2994 * If we got an interrupt, skip all previously typed characters and
2995 * return TRUE if quit reading script file.
2996 * Stop reading typeahead when a single CTRL-C was read,
2997 * fill_input_buf() returns this when not able to read from stdin.
2998 * Don't use buf[] here, closescript() may have freed typebuf.tb_buf[]
2999 * and buf may be pointing inside typebuf.tb_buf[].
3000 */
3001 if (got_int)
3002 {
3003#define DUM_LEN MAXMAPLEN * 3 + 3
3004 char_u dum[DUM_LEN + 1];
3005
3006 for (;;)
3007 {
3008 len = ui_inchar(dum, DUM_LEN, 0L, 0);
3009 if (len == 0 || (len == 1 && dum[0] == 3))
3010 break;
3011 }
3012 return retesc;
3013 }
3014
3015 /*
3016 * Always flush the output characters when getting input characters
3017 * from the user.
3018 */
3019 out_flush();
3020
3021 /*
3022 * Fill up to a third of the buffer, because each character may be
3023 * tripled below.
3024 */
3025 len = ui_inchar(buf, maxlen / 3, wait_time, tb_change_cnt);
3026 }
3027
3028 if (typebuf_changed(tb_change_cnt))
3029 return 0;
3030
3031 return fix_input_buffer(buf, len, script_char >= 0);
3032}
3033
3034/*
3035 * Fix typed characters for use by vgetc() and check_termcode().
3036 * buf[] must have room to triple the number of bytes!
3037 * Returns the new length.
3038 */
3039 int
3040fix_input_buffer(buf, len, script)
3041 char_u *buf;
3042 int len;
3043 int script; /* TRUE when reading from a script */
3044{
3045 int i;
3046 char_u *p = buf;
3047
3048 /*
3049 * Two characters are special: NUL and K_SPECIAL.
3050 * When compiled With the GUI CSI is also special.
3051 * Replace NUL by K_SPECIAL KS_ZERO KE_FILLER
3052 * Replace K_SPECIAL by K_SPECIAL KS_SPECIAL KE_FILLER
3053 * Replace CSI by K_SPECIAL KS_EXTRA KE_CSI
3054 * Don't replace K_SPECIAL when reading a script file.
3055 */
3056 for (i = len; --i >= 0; ++p)
3057 {
3058#ifdef FEAT_GUI
3059 /* When the GUI is used any character can come after a CSI, don't
3060 * escape it. */
3061 if (gui.in_use && p[0] == CSI && i >= 2)
3062 {
3063 p += 2;
3064 i -= 2;
3065 }
3066 /* When the GUI is not used CSI needs to be escaped. */
3067 else if (!gui.in_use && p[0] == CSI)
3068 {
3069 mch_memmove(p + 3, p + 1, (size_t)i);
3070 *p++ = K_SPECIAL;
3071 *p++ = KS_EXTRA;
3072 *p = (int)KE_CSI;
3073 len += 2;
3074 }
3075 else
3076#endif
3077 if (p[0] == NUL || (p[0] == K_SPECIAL && !script
Bram Moolenaar28a37ff2005-03-15 22:28:00 +00003078#ifdef FEAT_AUTOCMD
3079 /* timeout may generate K_CURSORHOLD */
3080 && (i < 2 || p[1] != KS_EXTRA || p[2] != (int)KE_CURSORHOLD)
3081#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003082#if defined(WIN3264) && !defined(FEAT_GUI)
3083 /* Win32 console passes modifiers */
3084 && (i < 2 || p[1] != KS_MODIFIER)
3085#endif
3086 ))
3087 {
3088 mch_memmove(p + 3, p + 1, (size_t)i);
3089 p[2] = K_THIRD(p[0]);
3090 p[1] = K_SECOND(p[0]);
3091 p[0] = K_SPECIAL;
3092 p += 2;
3093 len += 2;
3094 }
3095 }
3096 *p = NUL; /* add trailing NUL */
3097 return len;
3098}
3099
3100#if defined(USE_INPUT_BUF) || defined(PROTO)
3101/*
3102 * Return TRUE when bytes are in the input buffer or in the typeahead buffer.
3103 * Normally the input buffer would be sufficient, but the server_to_input_buf()
Bram Moolenaarf9393ef2006-04-24 19:47:27 +00003104 * or feedkeys() may insert characters in the typeahead buffer while we are
Bram Moolenaar4a85b412006-04-23 22:40:29 +00003105 * waiting for input to arrive.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003106 */
3107 int
3108input_available()
3109{
3110 return (!vim_is_input_buf_empty()
Bram Moolenaar4a85b412006-04-23 22:40:29 +00003111# if defined(FEAT_CLIENTSERVER) || defined(FEAT_EVAL)
3112 || typebuf_was_filled
Bram Moolenaar071d4272004-06-13 20:20:40 +00003113# endif
3114 );
3115}
3116#endif
3117
3118/*
3119 * map[!] : show all key mappings
3120 * map[!] {lhs} : show key mapping for {lhs}
3121 * map[!] {lhs} {rhs} : set key mapping for {lhs} to {rhs}
3122 * noremap[!] {lhs} {rhs} : same, but no remapping for {rhs}
3123 * unmap[!] {lhs} : remove key mapping for {lhs}
3124 * abbr : show all abbreviations
3125 * abbr {lhs} : show abbreviations for {lhs}
3126 * abbr {lhs} {rhs} : set abbreviation for {lhs} to {rhs}
3127 * noreabbr {lhs} {rhs} : same, but no remapping for {rhs}
3128 * unabbr {lhs} : remove abbreviation for {lhs}
3129 *
3130 * maptype: 0 for :map, 1 for :unmap, 2 for noremap.
3131 *
3132 * arg is pointer to any arguments. Note: arg cannot be a read-only string,
3133 * it will be modified.
3134 *
Bram Moolenaar371d5402006-03-20 21:47:49 +00003135 * for :map mode is NORMAL + VISUAL + SELECTMODE + OP_PENDING
Bram Moolenaar071d4272004-06-13 20:20:40 +00003136 * for :map! mode is INSERT + CMDLINE
3137 * for :cmap mode is CMDLINE
3138 * for :imap mode is INSERT
3139 * for :lmap mode is LANGMAP
3140 * for :nmap mode is NORMAL
Bram Moolenaar371d5402006-03-20 21:47:49 +00003141 * for :vmap mode is VISUAL + SELECTMODE
3142 * for :xmap mode is VISUAL
3143 * for :smap mode is SELECTMODE
Bram Moolenaar071d4272004-06-13 20:20:40 +00003144 * for :omap mode is OP_PENDING
3145 *
3146 * for :abbr mode is INSERT + CMDLINE
3147 * for :iabbr mode is INSERT
3148 * for :cabbr mode is CMDLINE
3149 *
3150 * Return 0 for success
3151 * 1 for invalid arguments
3152 * 2 for no match
3153 * 4 for out of mem
3154 * 5 for entry not unique
3155 */
3156 int
3157do_map(maptype, arg, mode, abbrev)
3158 int maptype;
3159 char_u *arg;
3160 int mode;
3161 int abbrev; /* not a mapping but an abbreviation */
3162{
3163 char_u *keys;
3164 mapblock_T *mp, **mpp;
3165 char_u *rhs;
3166 char_u *p;
3167 int n;
3168 int len = 0; /* init for GCC */
3169 char_u *newstr;
3170 int hasarg;
3171 int haskey;
3172 int did_it = FALSE;
3173#ifdef FEAT_LOCALMAP
3174 int did_local = FALSE;
3175#endif
3176 int round;
3177 char_u *keys_buf = NULL;
3178 char_u *arg_buf = NULL;
3179 int retval = 0;
3180 int do_backslash;
3181 int hash;
3182 int new_hash;
3183 mapblock_T **abbr_table;
3184 mapblock_T **map_table;
3185 int unique = FALSE;
3186 int silent = FALSE;
Bram Moolenaar9c102382006-05-03 21:26:49 +00003187 int special = FALSE;
Bram Moolenaar4e427192006-03-10 21:34:27 +00003188#ifdef FEAT_EVAL
3189 int expr = FALSE;
3190#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003191 int noremap;
Bram Moolenaarbd743252010-10-20 21:23:33 +02003192 char_u *orig_rhs;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003193
3194 keys = arg;
3195 map_table = maphash;
3196 abbr_table = &first_abbr;
3197
3198 /* For ":noremap" don't remap, otherwise do remap. */
3199 if (maptype == 2)
3200 noremap = REMAP_NONE;
3201 else
3202 noremap = REMAP_YES;
3203
Bram Moolenaar4e427192006-03-10 21:34:27 +00003204 /* Accept <buffer>, <silent>, <expr> <script> and <unique> in any order. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003205 for (;;)
3206 {
3207#ifdef FEAT_LOCALMAP
3208 /*
3209 * Check for "<buffer>": mapping local to buffer.
3210 */
3211 if (STRNCMP(keys, "<buffer>", 8) == 0)
3212 {
3213 keys = skipwhite(keys + 8);
3214 map_table = curbuf->b_maphash;
3215 abbr_table = &curbuf->b_first_abbr;
3216 continue;
3217 }
3218#endif
3219
3220 /*
3221 * Check for "<silent>": don't echo commands.
3222 */
3223 if (STRNCMP(keys, "<silent>", 8) == 0)
3224 {
3225 keys = skipwhite(keys + 8);
3226 silent = TRUE;
3227 continue;
3228 }
3229
Bram Moolenaar9c102382006-05-03 21:26:49 +00003230 /*
3231 * Check for "<special>": accept special keys in <>
3232 */
3233 if (STRNCMP(keys, "<special>", 9) == 0)
3234 {
3235 keys = skipwhite(keys + 9);
3236 special = TRUE;
3237 continue;
3238 }
3239
Bram Moolenaar071d4272004-06-13 20:20:40 +00003240#ifdef FEAT_EVAL
3241 /*
3242 * Check for "<script>": remap script-local mappings only
3243 */
3244 if (STRNCMP(keys, "<script>", 8) == 0)
3245 {
3246 keys = skipwhite(keys + 8);
3247 noremap = REMAP_SCRIPT;
3248 continue;
3249 }
Bram Moolenaar4e427192006-03-10 21:34:27 +00003250
3251 /*
3252 * Check for "<expr>": {rhs} is an expression.
3253 */
3254 if (STRNCMP(keys, "<expr>", 6) == 0)
3255 {
3256 keys = skipwhite(keys + 6);
3257 expr = TRUE;
3258 continue;
3259 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003260#endif
3261 /*
3262 * Check for "<unique>": don't overwrite an existing mapping.
3263 */
3264 if (STRNCMP(keys, "<unique>", 8) == 0)
3265 {
3266 keys = skipwhite(keys + 8);
3267 unique = TRUE;
3268 continue;
3269 }
3270 break;
3271 }
3272
3273 validate_maphash();
3274
3275 /*
Bram Moolenaarf6f4a012011-08-17 17:18:20 +02003276 * Find end of keys and skip CTRL-Vs (and backslashes) in it.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003277 * Accept backslash like CTRL-V when 'cpoptions' does not contain 'B'.
Bram Moolenaarf6f4a012011-08-17 17:18:20 +02003278 * with :unmap white space is included in the keys, no argument possible.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003279 */
3280 p = keys;
3281 do_backslash = (vim_strchr(p_cpo, CPO_BSLASH) == NULL);
3282 while (*p && (maptype == 1 || !vim_iswhite(*p)))
3283 {
3284 if ((p[0] == Ctrl_V || (do_backslash && p[0] == '\\')) &&
3285 p[1] != NUL)
3286 ++p; /* skip CTRL-V or backslash */
3287 ++p;
3288 }
3289 if (*p != NUL)
3290 *p++ = NUL;
Bram Moolenaarbd743252010-10-20 21:23:33 +02003291
Bram Moolenaar071d4272004-06-13 20:20:40 +00003292 p = skipwhite(p);
3293 rhs = p;
3294 hasarg = (*rhs != NUL);
3295 haskey = (*keys != NUL);
3296
3297 /* check for :unmap without argument */
3298 if (maptype == 1 && !haskey)
3299 {
3300 retval = 1;
3301 goto theend;
3302 }
3303
3304 /*
3305 * If mapping has been given as ^V<C_UP> say, then replace the term codes
3306 * with the appropriate two bytes. If it is a shifted special key, unshift
3307 * it too, giving another two bytes.
3308 * replace_termcodes() may move the result to allocated memory, which
3309 * needs to be freed later (*keys_buf and *arg_buf).
3310 * replace_termcodes() also removes CTRL-Vs and sometimes backslashes.
3311 */
3312 if (haskey)
Bram Moolenaar9c102382006-05-03 21:26:49 +00003313 keys = replace_termcodes(keys, &keys_buf, TRUE, TRUE, special);
Bram Moolenaarb3ae56c2010-10-27 17:39:05 +02003314 orig_rhs = rhs;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003315 if (hasarg)
3316 {
3317 if (STRICMP(rhs, "<nop>") == 0) /* "<Nop>" means nothing */
3318 rhs = (char_u *)"";
3319 else
Bram Moolenaar9c102382006-05-03 21:26:49 +00003320 rhs = replace_termcodes(rhs, &arg_buf, FALSE, TRUE, special);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003321 }
3322
3323#ifdef FEAT_FKMAP
3324 /*
Bram Moolenaarbd743252010-10-20 21:23:33 +02003325 * When in right-to-left mode and alternate keymap option set,
Bram Moolenaar071d4272004-06-13 20:20:40 +00003326 * reverse the character flow in the rhs in Farsi.
3327 */
3328 if (p_altkeymap && curwin->w_p_rl)
3329 lrswap(rhs);
3330#endif
3331
3332 /*
3333 * check arguments and translate function keys
3334 */
3335 if (haskey)
3336 {
3337 len = (int)STRLEN(keys);
3338 if (len > MAXMAPLEN) /* maximum length of MAXMAPLEN chars */
3339 {
3340 retval = 1;
3341 goto theend;
3342 }
3343
3344 if (abbrev && maptype != 1)
3345 {
3346 /*
3347 * If an abbreviation ends in a keyword character, the
3348 * rest must be all keyword-char or all non-keyword-char.
3349 * Otherwise we won't be able to find the start of it in a
3350 * vi-compatible way.
3351 */
3352#ifdef FEAT_MBYTE
3353 if (has_mbyte)
3354 {
3355 int first, last;
3356 int same = -1;
3357
3358 first = vim_iswordp(keys);
3359 last = first;
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00003360 p = keys + (*mb_ptr2len)(keys);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003361 n = 1;
3362 while (p < keys + len)
3363 {
3364 ++n; /* nr of (multi-byte) chars */
3365 last = vim_iswordp(p); /* type of last char */
3366 if (same == -1 && last != first)
3367 same = n - 1; /* count of same char type */
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00003368 p += (*mb_ptr2len)(p);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003369 }
3370 if (last && n > 2 && same >= 0 && same < n - 1)
3371 {
3372 retval = 1;
3373 goto theend;
3374 }
3375 }
3376 else
3377#endif
3378 if (vim_iswordc(keys[len - 1])) /* ends in keyword char */
3379 for (n = 0; n < len - 2; ++n)
3380 if (vim_iswordc(keys[n]) != vim_iswordc(keys[len - 2]))
3381 {
3382 retval = 1;
3383 goto theend;
3384 }
Bram Moolenaarf6f95d92009-11-11 15:23:37 +00003385 /* An abbreviation cannot contain white space. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003386 for (n = 0; n < len; ++n)
3387 if (vim_iswhite(keys[n]))
3388 {
3389 retval = 1;
3390 goto theend;
3391 }
3392 }
3393 }
3394
3395 if (haskey && hasarg && abbrev) /* if we will add an abbreviation */
3396 no_abbr = FALSE; /* reset flag that indicates there are
3397 no abbreviations */
3398
3399 if (!haskey || (maptype != 1 && !hasarg))
3400 msg_start();
3401
3402#ifdef FEAT_LOCALMAP
3403 /*
3404 * Check if a new local mapping wasn't already defined globally.
3405 */
3406 if (map_table == curbuf->b_maphash && haskey && hasarg && maptype != 1)
3407 {
3408 /* need to loop over all global hash lists */
3409 for (hash = 0; hash < 256 && !got_int; ++hash)
3410 {
3411 if (abbrev)
3412 {
3413 if (hash != 0) /* there is only one abbreviation list */
3414 break;
3415 mp = first_abbr;
3416 }
3417 else
3418 mp = maphash[hash];
3419 for ( ; mp != NULL && !got_int; mp = mp->m_next)
3420 {
3421 /* check entries with the same mode */
3422 if ((mp->m_mode & mode) != 0
3423 && mp->m_keylen == len
3424 && unique
3425 && STRNCMP(mp->m_keys, keys, (size_t)len) == 0)
3426 {
3427 if (abbrev)
3428 EMSG2(_("E224: global abbreviation already exists for %s"),
3429 mp->m_keys);
3430 else
3431 EMSG2(_("E225: global mapping already exists for %s"),
3432 mp->m_keys);
3433 retval = 5;
3434 goto theend;
3435 }
3436 }
3437 }
3438 }
3439
3440 /*
3441 * When listing global mappings, also list buffer-local ones here.
3442 */
3443 if (map_table != curbuf->b_maphash && !hasarg && maptype != 1)
3444 {
3445 /* need to loop over all global hash lists */
3446 for (hash = 0; hash < 256 && !got_int; ++hash)
3447 {
3448 if (abbrev)
3449 {
3450 if (hash != 0) /* there is only one abbreviation list */
3451 break;
3452 mp = curbuf->b_first_abbr;
3453 }
3454 else
3455 mp = curbuf->b_maphash[hash];
3456 for ( ; mp != NULL && !got_int; mp = mp->m_next)
3457 {
3458 /* check entries with the same mode */
3459 if ((mp->m_mode & mode) != 0)
3460 {
3461 if (!haskey) /* show all entries */
3462 {
3463 showmap(mp, TRUE);
3464 did_local = TRUE;
3465 }
3466 else
3467 {
3468 n = mp->m_keylen;
3469 if (STRNCMP(mp->m_keys, keys,
3470 (size_t)(n < len ? n : len)) == 0)
3471 {
3472 showmap(mp, TRUE);
3473 did_local = TRUE;
3474 }
3475 }
3476 }
3477 }
3478 }
3479 }
3480#endif
3481
3482 /*
3483 * Find an entry in the maphash[] list that matches.
3484 * For :unmap we may loop two times: once to try to unmap an entry with a
3485 * matching 'from' part, a second time, if the first fails, to unmap an
3486 * entry with a matching 'to' part. This was done to allow ":ab foo bar"
3487 * to be unmapped by typing ":unab foo", where "foo" will be replaced by
3488 * "bar" because of the abbreviation.
3489 */
3490 for (round = 0; (round == 0 || maptype == 1) && round <= 1
3491 && !did_it && !got_int; ++round)
3492 {
3493 /* need to loop over all hash lists */
3494 for (hash = 0; hash < 256 && !got_int; ++hash)
3495 {
3496 if (abbrev)
3497 {
Bram Moolenaarbe4d5062006-03-18 21:30:13 +00003498 if (hash > 0) /* there is only one abbreviation list */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003499 break;
3500 mpp = abbr_table;
3501 }
3502 else
3503 mpp = &(map_table[hash]);
3504 for (mp = *mpp; mp != NULL && !got_int; mp = *mpp)
3505 {
3506
3507 if (!(mp->m_mode & mode)) /* skip entries with wrong mode */
3508 {
3509 mpp = &(mp->m_next);
3510 continue;
3511 }
3512 if (!haskey) /* show all entries */
3513 {
3514 showmap(mp, map_table != maphash);
3515 did_it = TRUE;
3516 }
3517 else /* do we have a match? */
3518 {
3519 if (round) /* second round: Try unmap "rhs" string */
3520 {
3521 n = (int)STRLEN(mp->m_str);
3522 p = mp->m_str;
3523 }
3524 else
3525 {
3526 n = mp->m_keylen;
3527 p = mp->m_keys;
3528 }
3529 if (STRNCMP(p, keys, (size_t)(n < len ? n : len)) == 0)
3530 {
3531 if (maptype == 1) /* delete entry */
3532 {
3533 /* Only accept a full match. For abbreviations we
3534 * ignore trailing space when matching with the
3535 * "lhs", since an abbreviation can't have
3536 * trailing space. */
3537 if (n != len && (!abbrev || round || n > len
3538 || *skipwhite(keys + n) != NUL))
3539 {
3540 mpp = &(mp->m_next);
3541 continue;
3542 }
3543 /*
3544 * We reset the indicated mode bits. If nothing is
3545 * left the entry is deleted below.
3546 */
3547 mp->m_mode &= ~mode;
3548 did_it = TRUE; /* remember we did something */
3549 }
3550 else if (!hasarg) /* show matching entry */
3551 {
3552 showmap(mp, map_table != maphash);
3553 did_it = TRUE;
3554 }
Bram Moolenaarb6799ac2007-05-10 16:44:05 +00003555 else if (n != len) /* new entry is ambiguous */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003556 {
3557 mpp = &(mp->m_next);
3558 continue;
3559 }
3560 else if (unique)
3561 {
3562 if (abbrev)
3563 EMSG2(_("E226: abbreviation already exists for %s"),
3564 p);
3565 else
3566 EMSG2(_("E227: mapping already exists for %s"), p);
3567 retval = 5;
3568 goto theend;
3569 }
3570 else /* new rhs for existing entry */
3571 {
3572 mp->m_mode &= ~mode; /* remove mode bits */
3573 if (mp->m_mode == 0 && !did_it) /* reuse entry */
3574 {
3575 newstr = vim_strsave(rhs);
3576 if (newstr == NULL)
3577 {
3578 retval = 4; /* no mem */
3579 goto theend;
3580 }
3581 vim_free(mp->m_str);
3582 mp->m_str = newstr;
Bram Moolenaarbd743252010-10-20 21:23:33 +02003583 vim_free(mp->m_orig_str);
3584 mp->m_orig_str = vim_strsave(orig_rhs);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003585 mp->m_noremap = noremap;
3586 mp->m_silent = silent;
3587 mp->m_mode = mode;
Bram Moolenaarae5bce12005-08-15 21:41:48 +00003588#ifdef FEAT_EVAL
Bram Moolenaar4e427192006-03-10 21:34:27 +00003589 mp->m_expr = expr;
Bram Moolenaarae5bce12005-08-15 21:41:48 +00003590 mp->m_script_ID = current_SID;
3591#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003592 did_it = TRUE;
3593 }
3594 }
3595 if (mp->m_mode == 0) /* entry can be deleted */
3596 {
3597 map_free(mpp);
3598 continue; /* continue with *mpp */
3599 }
3600
3601 /*
3602 * May need to put this entry into another hash list.
3603 */
3604 new_hash = MAP_HASH(mp->m_mode, mp->m_keys[0]);
3605 if (!abbrev && new_hash != hash)
3606 {
3607 *mpp = mp->m_next;
3608 mp->m_next = map_table[new_hash];
3609 map_table[new_hash] = mp;
3610
3611 continue; /* continue with *mpp */
3612 }
3613 }
3614 }
3615 mpp = &(mp->m_next);
3616 }
3617 }
3618 }
3619
3620 if (maptype == 1) /* delete entry */
3621 {
3622 if (!did_it)
3623 retval = 2; /* no match */
3624 goto theend;
3625 }
3626
3627 if (!haskey || !hasarg) /* print entries */
3628 {
3629 if (!did_it
3630#ifdef FEAT_LOCALMAP
3631 && !did_local
3632#endif
3633 )
3634 {
3635 if (abbrev)
3636 MSG(_("No abbreviation found"));
3637 else
3638 MSG(_("No mapping found"));
3639 }
3640 goto theend; /* listing finished */
3641 }
3642
3643 if (did_it) /* have added the new entry already */
3644 goto theend;
3645
3646 /*
3647 * Get here when adding a new entry to the maphash[] list or abbrlist.
3648 */
3649 mp = (mapblock_T *)alloc((unsigned)sizeof(mapblock_T));
3650 if (mp == NULL)
3651 {
3652 retval = 4; /* no mem */
3653 goto theend;
3654 }
3655
3656 /* If CTRL-C has been mapped, don't always use it for Interrupting */
3657 if (*keys == Ctrl_C)
3658 mapped_ctrl_c = TRUE;
3659
3660 mp->m_keys = vim_strsave(keys);
3661 mp->m_str = vim_strsave(rhs);
Bram Moolenaarbd743252010-10-20 21:23:33 +02003662 mp->m_orig_str = vim_strsave(orig_rhs);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003663 if (mp->m_keys == NULL || mp->m_str == NULL)
3664 {
3665 vim_free(mp->m_keys);
3666 vim_free(mp->m_str);
Bram Moolenaarbd743252010-10-20 21:23:33 +02003667 vim_free(mp->m_orig_str);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003668 vim_free(mp);
3669 retval = 4; /* no mem */
3670 goto theend;
3671 }
3672 mp->m_keylen = (int)STRLEN(mp->m_keys);
3673 mp->m_noremap = noremap;
3674 mp->m_silent = silent;
3675 mp->m_mode = mode;
Bram Moolenaarae5bce12005-08-15 21:41:48 +00003676#ifdef FEAT_EVAL
Bram Moolenaar4e427192006-03-10 21:34:27 +00003677 mp->m_expr = expr;
Bram Moolenaarae5bce12005-08-15 21:41:48 +00003678 mp->m_script_ID = current_SID;
3679#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003680
3681 /* add the new entry in front of the abbrlist or maphash[] list */
3682 if (abbrev)
3683 {
3684 mp->m_next = *abbr_table;
3685 *abbr_table = mp;
3686 }
3687 else
3688 {
3689 n = MAP_HASH(mp->m_mode, mp->m_keys[0]);
3690 mp->m_next = map_table[n];
3691 map_table[n] = mp;
3692 }
3693
3694theend:
3695 vim_free(keys_buf);
3696 vim_free(arg_buf);
3697 return retval;
3698}
3699
3700/*
3701 * Delete one entry from the abbrlist or maphash[].
3702 * "mpp" is a pointer to the m_next field of the PREVIOUS entry!
3703 */
3704 static void
3705map_free(mpp)
3706 mapblock_T **mpp;
3707{
3708 mapblock_T *mp;
3709
3710 mp = *mpp;
3711 vim_free(mp->m_keys);
3712 vim_free(mp->m_str);
Bram Moolenaarbd743252010-10-20 21:23:33 +02003713 vim_free(mp->m_orig_str);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003714 *mpp = mp->m_next;
3715 vim_free(mp);
3716}
3717
3718/*
3719 * Initialize maphash[] for first use.
3720 */
3721 static void
3722validate_maphash()
3723{
3724 if (!maphash_valid)
3725 {
3726 vim_memset(maphash, 0, sizeof(maphash));
3727 maphash_valid = TRUE;
3728 }
3729}
3730
3731/*
3732 * Get the mapping mode from the command name.
3733 */
3734 int
3735get_map_mode(cmdp, forceit)
3736 char_u **cmdp;
3737 int forceit;
3738{
3739 char_u *p;
3740 int modec;
3741 int mode;
3742
3743 p = *cmdp;
3744 modec = *p++;
3745 if (modec == 'i')
3746 mode = INSERT; /* :imap */
3747 else if (modec == 'l')
3748 mode = LANGMAP; /* :lmap */
3749 else if (modec == 'c')
3750 mode = CMDLINE; /* :cmap */
3751 else if (modec == 'n' && *p != 'o') /* avoid :noremap */
3752 mode = NORMAL; /* :nmap */
3753 else if (modec == 'v')
Bram Moolenaar371d5402006-03-20 21:47:49 +00003754 mode = VISUAL + SELECTMODE; /* :vmap */
3755 else if (modec == 'x')
3756 mode = VISUAL; /* :xmap */
3757 else if (modec == 's')
3758 mode = SELECTMODE; /* :smap */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003759 else if (modec == 'o')
3760 mode = OP_PENDING; /* :omap */
3761 else
3762 {
3763 --p;
3764 if (forceit)
3765 mode = INSERT + CMDLINE; /* :map ! */
3766 else
Bram Moolenaar371d5402006-03-20 21:47:49 +00003767 mode = VISUAL + SELECTMODE + NORMAL + OP_PENDING;/* :map */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003768 }
3769
3770 *cmdp = p;
3771 return mode;
3772}
3773
3774/*
3775 * Clear all mappings or abbreviations.
3776 * 'abbr' should be FALSE for mappings, TRUE for abbreviations.
3777 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003778 void
3779map_clear(cmdp, arg, forceit, abbr)
3780 char_u *cmdp;
Bram Moolenaard31aca22009-07-14 11:44:30 +00003781 char_u *arg UNUSED;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003782 int forceit;
3783 int abbr;
3784{
3785 int mode;
3786#ifdef FEAT_LOCALMAP
3787 int local;
3788
3789 local = (STRCMP(arg, "<buffer>") == 0);
3790 if (!local && *arg != NUL)
3791 {
3792 EMSG(_(e_invarg));
3793 return;
3794 }
3795#endif
3796
3797 mode = get_map_mode(&cmdp, forceit);
3798 map_clear_int(curbuf, mode,
3799#ifdef FEAT_LOCALMAP
3800 local,
3801#else
3802 FALSE,
3803#endif
3804 abbr);
3805}
3806
3807/*
3808 * Clear all mappings in "mode".
3809 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003810 void
3811map_clear_int(buf, mode, local, abbr)
Bram Moolenaard31aca22009-07-14 11:44:30 +00003812 buf_T *buf UNUSED; /* buffer for local mappings */
3813 int mode; /* mode in which to delete */
3814 int local UNUSED; /* TRUE for buffer-local mappings */
3815 int abbr; /* TRUE for abbreviations */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003816{
3817 mapblock_T *mp, **mpp;
3818 int hash;
3819 int new_hash;
3820
3821 validate_maphash();
3822
3823 for (hash = 0; hash < 256; ++hash)
3824 {
3825 if (abbr)
3826 {
Bram Moolenaarbe4d5062006-03-18 21:30:13 +00003827 if (hash > 0) /* there is only one abbrlist */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003828 break;
3829#ifdef FEAT_LOCALMAP
3830 if (local)
3831 mpp = &buf->b_first_abbr;
3832 else
3833#endif
3834 mpp = &first_abbr;
3835 }
3836 else
3837 {
3838#ifdef FEAT_LOCALMAP
3839 if (local)
3840 mpp = &buf->b_maphash[hash];
3841 else
3842#endif
3843 mpp = &maphash[hash];
3844 }
3845 while (*mpp != NULL)
3846 {
3847 mp = *mpp;
3848 if (mp->m_mode & mode)
3849 {
3850 mp->m_mode &= ~mode;
3851 if (mp->m_mode == 0) /* entry can be deleted */
3852 {
3853 map_free(mpp);
3854 continue;
3855 }
3856 /*
3857 * May need to put this entry into another hash list.
3858 */
3859 new_hash = MAP_HASH(mp->m_mode, mp->m_keys[0]);
3860 if (!abbr && new_hash != hash)
3861 {
3862 *mpp = mp->m_next;
3863#ifdef FEAT_LOCALMAP
3864 if (local)
3865 {
3866 mp->m_next = buf->b_maphash[new_hash];
3867 buf->b_maphash[new_hash] = mp;
3868 }
3869 else
3870#endif
3871 {
3872 mp->m_next = maphash[new_hash];
3873 maphash[new_hash] = mp;
3874 }
3875 continue; /* continue with *mpp */
3876 }
3877 }
3878 mpp = &(mp->m_next);
3879 }
3880 }
3881}
3882
Bram Moolenaarbd743252010-10-20 21:23:33 +02003883/*
3884 * Return characters to represent the map mode in an allocated string.
3885 * Returns NULL when out of memory.
3886 */
3887 char_u *
3888map_mode_to_chars(mode)
3889 int mode;
3890{
3891 garray_T mapmode;
3892
3893 ga_init2(&mapmode, 1, 7);
3894
3895 if ((mode & (INSERT + CMDLINE)) == INSERT + CMDLINE)
3896 ga_append(&mapmode, '!'); /* :map! */
3897 else if (mode & INSERT)
3898 ga_append(&mapmode, 'i'); /* :imap */
3899 else if (mode & LANGMAP)
3900 ga_append(&mapmode, 'l'); /* :lmap */
3901 else if (mode & CMDLINE)
3902 ga_append(&mapmode, 'c'); /* :cmap */
3903 else if ((mode & (NORMAL + VISUAL + SELECTMODE + OP_PENDING))
3904 == NORMAL + VISUAL + SELECTMODE + OP_PENDING)
3905 ga_append(&mapmode, ' '); /* :map */
3906 else
3907 {
3908 if (mode & NORMAL)
3909 ga_append(&mapmode, 'n'); /* :nmap */
3910 if (mode & OP_PENDING)
3911 ga_append(&mapmode, 'o'); /* :omap */
3912 if ((mode & (VISUAL + SELECTMODE)) == VISUAL + SELECTMODE)
3913 ga_append(&mapmode, 'v'); /* :vmap */
3914 else
3915 {
3916 if (mode & VISUAL)
3917 ga_append(&mapmode, 'x'); /* :xmap */
3918 if (mode & SELECTMODE)
3919 ga_append(&mapmode, 's'); /* :smap */
3920 }
3921 }
3922
3923 ga_append(&mapmode, NUL);
3924 return (char_u *)mapmode.ga_data;
3925}
3926
Bram Moolenaar071d4272004-06-13 20:20:40 +00003927 static void
3928showmap(mp, local)
3929 mapblock_T *mp;
3930 int local; /* TRUE for buffer-local map */
3931{
Bram Moolenaarbd743252010-10-20 21:23:33 +02003932 int len = 1;
3933 char_u *mapchars;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003934
3935 if (msg_didout || msg_silent != 0)
Bram Moolenaarfa47a922009-02-22 22:43:27 +00003936 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00003937 msg_putchar('\n');
Bram Moolenaarfa47a922009-02-22 22:43:27 +00003938 if (got_int) /* 'q' typed at MORE prompt */
3939 return;
3940 }
Bram Moolenaarbd743252010-10-20 21:23:33 +02003941
3942 mapchars = map_mode_to_chars(mp->m_mode);
3943 if (mapchars != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003944 {
Bram Moolenaarbd743252010-10-20 21:23:33 +02003945 msg_puts(mapchars);
Bram Moolenaar6b5ef062010-10-27 12:18:00 +02003946 len = (int)STRLEN(mapchars);
Bram Moolenaarbd743252010-10-20 21:23:33 +02003947 vim_free(mapchars);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003948 }
Bram Moolenaarbd743252010-10-20 21:23:33 +02003949
Bram Moolenaar071d4272004-06-13 20:20:40 +00003950 while (++len <= 3)
3951 msg_putchar(' ');
3952
Bram Moolenaarf2330482008-06-24 20:19:36 +00003953 /* Display the LHS. Get length of what we write. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003954 len = msg_outtrans_special(mp->m_keys, TRUE);
3955 do
3956 {
3957 msg_putchar(' '); /* padd with blanks */
3958 ++len;
3959 } while (len < 12);
3960
3961 if (mp->m_noremap == REMAP_NONE)
3962 msg_puts_attr((char_u *)"*", hl_attr(HLF_8));
3963 else if (mp->m_noremap == REMAP_SCRIPT)
3964 msg_puts_attr((char_u *)"&", hl_attr(HLF_8));
3965 else
3966 msg_putchar(' ');
3967
3968 if (local)
3969 msg_putchar('@');
3970 else
3971 msg_putchar(' ');
3972
3973 /* Use FALSE below if we only want things like <Up> to show up as such on
Bram Moolenaarbd743252010-10-20 21:23:33 +02003974 * the rhs, and not M-x etc, TRUE gets both -- webb */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003975 if (*mp->m_str == NUL)
3976 msg_puts_attr((char_u *)"<Nop>", hl_attr(HLF_8));
3977 else
Bram Moolenaarb8bf5412011-08-17 20:33:22 +02003978 {
3979 /* Remove escaping of CSI, because "m_str" is in a format to be used
3980 * as typeahead. */
3981 char_u *s = vim_strsave(mp->m_str);
3982 if (s != NULL)
3983 {
3984 vim_unescape_csi(s);
3985 msg_outtrans_special(s, FALSE);
3986 vim_free(s);
3987 }
3988 }
Bram Moolenaarae5bce12005-08-15 21:41:48 +00003989#ifdef FEAT_EVAL
3990 if (p_verbose > 0)
3991 last_set_msg(mp->m_script_ID);
3992#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003993 out_flush(); /* show one line at a time */
3994}
3995
3996#if defined(FEAT_EVAL) || defined(PROTO)
3997/*
3998 * Return TRUE if a map exists that has "str" in the rhs for mode "modechars".
3999 * Recognize termcap codes in "str".
4000 * Also checks mappings local to the current buffer.
4001 */
4002 int
Bram Moolenaarbe4d5062006-03-18 21:30:13 +00004003map_to_exists(str, modechars, abbr)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004004 char_u *str;
4005 char_u *modechars;
Bram Moolenaarbe4d5062006-03-18 21:30:13 +00004006 int abbr;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004007{
4008 int mode = 0;
4009 char_u *rhs;
4010 char_u *buf;
4011 int retval;
4012
Bram Moolenaar9c102382006-05-03 21:26:49 +00004013 rhs = replace_termcodes(str, &buf, FALSE, TRUE, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004014
4015 if (vim_strchr(modechars, 'n') != NULL)
4016 mode |= NORMAL;
4017 if (vim_strchr(modechars, 'v') != NULL)
Bram Moolenaar371d5402006-03-20 21:47:49 +00004018 mode |= VISUAL + SELECTMODE;
4019 if (vim_strchr(modechars, 'x') != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004020 mode |= VISUAL;
Bram Moolenaar371d5402006-03-20 21:47:49 +00004021 if (vim_strchr(modechars, 's') != NULL)
4022 mode |= SELECTMODE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004023 if (vim_strchr(modechars, 'o') != NULL)
4024 mode |= OP_PENDING;
4025 if (vim_strchr(modechars, 'i') != NULL)
4026 mode |= INSERT;
4027 if (vim_strchr(modechars, 'l') != NULL)
4028 mode |= LANGMAP;
4029 if (vim_strchr(modechars, 'c') != NULL)
4030 mode |= CMDLINE;
4031
Bram Moolenaarbe4d5062006-03-18 21:30:13 +00004032 retval = map_to_exists_mode(rhs, mode, abbr);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004033 vim_free(buf);
4034
4035 return retval;
4036}
4037#endif
4038
4039/*
4040 * Return TRUE if a map exists that has "str" in the rhs for mode "mode".
4041 * Also checks mappings local to the current buffer.
4042 */
4043 int
Bram Moolenaarbe4d5062006-03-18 21:30:13 +00004044map_to_exists_mode(rhs, mode, abbr)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004045 char_u *rhs;
4046 int mode;
Bram Moolenaarbe4d5062006-03-18 21:30:13 +00004047 int abbr;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004048{
4049 mapblock_T *mp;
4050 int hash;
4051# ifdef FEAT_LOCALMAP
4052 int expand_buffer = FALSE;
4053
4054 validate_maphash();
4055
4056 /* Do it twice: once for global maps and once for local maps. */
4057 for (;;)
4058 {
4059# endif
4060 for (hash = 0; hash < 256; ++hash)
4061 {
Bram Moolenaarbe4d5062006-03-18 21:30:13 +00004062 if (abbr)
4063 {
4064 if (hash > 0) /* there is only one abbr list */
4065 break;
4066#ifdef FEAT_LOCALMAP
4067 if (expand_buffer)
4068 mp = curbuf->b_first_abbr;
4069 else
4070#endif
4071 mp = first_abbr;
4072 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004073# ifdef FEAT_LOCALMAP
Bram Moolenaarbe4d5062006-03-18 21:30:13 +00004074 else if (expand_buffer)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004075 mp = curbuf->b_maphash[hash];
Bram Moolenaar071d4272004-06-13 20:20:40 +00004076# endif
Bram Moolenaarbe4d5062006-03-18 21:30:13 +00004077 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00004078 mp = maphash[hash];
4079 for (; mp; mp = mp->m_next)
4080 {
4081 if ((mp->m_mode & mode)
4082 && strstr((char *)mp->m_str, (char *)rhs) != NULL)
4083 return TRUE;
4084 }
4085 }
4086# ifdef FEAT_LOCALMAP
4087 if (expand_buffer)
4088 break;
4089 expand_buffer = TRUE;
4090 }
4091# endif
4092
4093 return FALSE;
4094}
4095
4096#if defined(FEAT_CMDL_COMPL) || defined(PROTO)
4097/*
4098 * Used below when expanding mapping/abbreviation names.
4099 */
4100static int expand_mapmodes = 0;
4101static int expand_isabbrev = 0;
4102#ifdef FEAT_LOCALMAP
4103static int expand_buffer = FALSE;
4104#endif
4105
4106/*
4107 * Work out what to complete when doing command line completion of mapping
4108 * or abbreviation names.
4109 */
4110 char_u *
4111set_context_in_map_cmd(xp, cmd, arg, forceit, isabbrev, isunmap, cmdidx)
4112 expand_T *xp;
4113 char_u *cmd;
4114 char_u *arg;
4115 int forceit; /* TRUE if '!' given */
4116 int isabbrev; /* TRUE if abbreviation */
4117 int isunmap; /* TRUE if unmap/unabbrev command */
4118 cmdidx_T cmdidx;
4119{
4120 if (forceit && cmdidx != CMD_map && cmdidx != CMD_unmap)
4121 xp->xp_context = EXPAND_NOTHING;
4122 else
4123 {
4124 if (isunmap)
4125 expand_mapmodes = get_map_mode(&cmd, forceit || isabbrev);
4126 else
4127 {
4128 expand_mapmodes = INSERT + CMDLINE;
4129 if (!isabbrev)
Bram Moolenaar371d5402006-03-20 21:47:49 +00004130 expand_mapmodes += VISUAL + SELECTMODE + NORMAL + OP_PENDING;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004131 }
4132 expand_isabbrev = isabbrev;
4133 xp->xp_context = EXPAND_MAPPINGS;
4134#ifdef FEAT_LOCALMAP
4135 expand_buffer = FALSE;
4136#endif
4137 for (;;)
4138 {
4139#ifdef FEAT_LOCALMAP
4140 if (STRNCMP(arg, "<buffer>", 8) == 0)
4141 {
4142 expand_buffer = TRUE;
4143 arg = skipwhite(arg + 8);
4144 continue;
4145 }
4146#endif
4147 if (STRNCMP(arg, "<unique>", 8) == 0)
4148 {
4149 arg = skipwhite(arg + 8);
4150 continue;
4151 }
4152 if (STRNCMP(arg, "<silent>", 8) == 0)
4153 {
4154 arg = skipwhite(arg + 8);
4155 continue;
4156 }
Bram Moolenaar4e427192006-03-10 21:34:27 +00004157#ifdef FEAT_EVAL
Bram Moolenaar071d4272004-06-13 20:20:40 +00004158 if (STRNCMP(arg, "<script>", 8) == 0)
4159 {
4160 arg = skipwhite(arg + 8);
4161 continue;
4162 }
Bram Moolenaar4e427192006-03-10 21:34:27 +00004163 if (STRNCMP(arg, "<expr>", 6) == 0)
4164 {
4165 arg = skipwhite(arg + 6);
4166 continue;
4167 }
4168#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004169 break;
4170 }
4171 xp->xp_pattern = arg;
4172 }
4173
4174 return NULL;
4175}
4176
4177/*
4178 * Find all mapping/abbreviation names that match regexp 'prog'.
4179 * For command line expansion of ":[un]map" and ":[un]abbrev" in all modes.
4180 * Return OK if matches found, FAIL otherwise.
4181 */
4182 int
4183ExpandMappings(regmatch, num_file, file)
4184 regmatch_T *regmatch;
4185 int *num_file;
4186 char_u ***file;
4187{
4188 mapblock_T *mp;
4189 int hash;
4190 int count;
4191 int round;
4192 char_u *p;
4193 int i;
4194
4195 validate_maphash();
4196
4197 *num_file = 0; /* return values in case of FAIL */
4198 *file = NULL;
4199
4200 /*
4201 * round == 1: Count the matches.
4202 * round == 2: Build the array to keep the matches.
4203 */
4204 for (round = 1; round <= 2; ++round)
4205 {
4206 count = 0;
4207
Bram Moolenaar4e427192006-03-10 21:34:27 +00004208 for (i = 0; i < 5; ++i)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004209 {
4210 if (i == 0)
4211 p = (char_u *)"<silent>";
4212 else if (i == 1)
4213 p = (char_u *)"<unique>";
4214#ifdef FEAT_EVAL
4215 else if (i == 2)
4216 p = (char_u *)"<script>";
Bram Moolenaar4e427192006-03-10 21:34:27 +00004217 else if (i == 3)
4218 p = (char_u *)"<expr>";
Bram Moolenaar071d4272004-06-13 20:20:40 +00004219#endif
4220#ifdef FEAT_LOCALMAP
Bram Moolenaar4e427192006-03-10 21:34:27 +00004221 else if (i == 4 && !expand_buffer)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004222 p = (char_u *)"<buffer>";
4223#endif
4224 else
4225 continue;
4226
4227 if (vim_regexec(regmatch, p, (colnr_T)0))
4228 {
4229 if (round == 1)
4230 ++count;
4231 else
4232 (*file)[count++] = vim_strsave(p);
4233 }
4234 }
4235
4236 for (hash = 0; hash < 256; ++hash)
4237 {
4238 if (expand_isabbrev)
4239 {
Bram Moolenaarbe4d5062006-03-18 21:30:13 +00004240 if (hash > 0) /* only one abbrev list */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004241 break; /* for (hash) */
4242 mp = first_abbr;
4243 }
4244#ifdef FEAT_LOCALMAP
4245 else if (expand_buffer)
4246 mp = curbuf->b_maphash[hash];
4247#endif
4248 else
4249 mp = maphash[hash];
4250 for (; mp; mp = mp->m_next)
4251 {
4252 if (mp->m_mode & expand_mapmodes)
4253 {
4254 p = translate_mapping(mp->m_keys, TRUE);
4255 if (p != NULL && vim_regexec(regmatch, p, (colnr_T)0))
4256 {
4257 if (round == 1)
4258 ++count;
4259 else
4260 {
4261 (*file)[count++] = p;
4262 p = NULL;
4263 }
4264 }
4265 vim_free(p);
4266 }
4267 } /* for (mp) */
4268 } /* for (hash) */
4269
4270 if (count == 0) /* no match found */
4271 break; /* for (round) */
4272
4273 if (round == 1)
4274 {
4275 *file = (char_u **)alloc((unsigned)(count * sizeof(char_u *)));
4276 if (*file == NULL)
4277 return FAIL;
4278 }
4279 } /* for (round) */
4280
Bram Moolenaareb3593b2006-04-22 22:33:57 +00004281 if (count > 1)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004282 {
Bram Moolenaareb3593b2006-04-22 22:33:57 +00004283 char_u **ptr1;
4284 char_u **ptr2;
4285 char_u **ptr3;
4286
4287 /* Sort the matches */
4288 sort_strings(*file, count);
4289
4290 /* Remove multiple entries */
4291 ptr1 = *file;
4292 ptr2 = ptr1 + 1;
4293 ptr3 = ptr1 + count;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004294
4295 while (ptr2 < ptr3)
4296 {
4297 if (STRCMP(*ptr1, *ptr2))
4298 *++ptr1 = *ptr2++;
4299 else
4300 {
4301 vim_free(*ptr2++);
4302 count--;
4303 }
4304 }
4305 }
4306
4307 *num_file = count;
4308 return (count == 0 ? FAIL : OK);
4309}
4310#endif /* FEAT_CMDL_COMPL */
4311
4312/*
4313 * Check for an abbreviation.
4314 * Cursor is at ptr[col]. When inserting, mincol is where insert started.
4315 * "c" is the character typed before check_abbr was called. It may have
4316 * ABBR_OFF added to avoid prepending a CTRL-V to it.
4317 *
4318 * Historic vi practice: The last character of an abbreviation must be an id
4319 * character ([a-zA-Z0-9_]). The characters in front of it must be all id
4320 * characters or all non-id characters. This allows for abbr. "#i" to
4321 * "#include".
4322 *
4323 * Vim addition: Allow for abbreviations that end in a non-keyword character.
4324 * Then there must be white space before the abbr.
4325 *
4326 * return TRUE if there is an abbreviation, FALSE if not
4327 */
4328 int
4329check_abbr(c, ptr, col, mincol)
4330 int c;
4331 char_u *ptr;
4332 int col;
4333 int mincol;
4334{
4335 int len;
4336 int scol; /* starting column of the abbr. */
4337 int j;
Bram Moolenaar4e427192006-03-10 21:34:27 +00004338 char_u *s;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004339 char_u tb[MB_MAXBYTES + 4];
Bram Moolenaar071d4272004-06-13 20:20:40 +00004340 mapblock_T *mp;
4341#ifdef FEAT_LOCALMAP
4342 mapblock_T *mp2;
4343#endif
4344#ifdef FEAT_MBYTE
4345 int clen = 0; /* length in characters */
4346#endif
4347 int is_id = TRUE;
4348 int vim_abbr;
4349
4350 if (typebuf.tb_no_abbr_cnt) /* abbrev. are not recursive */
4351 return FALSE;
Bram Moolenaare0ebfd72012-04-05 16:07:06 +02004352
4353 /* no remapping implies no abbreviation, except for CTRL-] */
4354 if ((KeyNoremap & (RM_NONE|RM_SCRIPT)) != 0 && c != Ctrl_RSB)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004355 return FALSE;
4356
4357 /*
4358 * Check for word before the cursor: If it ends in a keyword char all
Bram Moolenaarf6f95d92009-11-11 15:23:37 +00004359 * chars before it must be keyword chars or non-keyword chars, but not
Bram Moolenaar071d4272004-06-13 20:20:40 +00004360 * white space. If it ends in a non-keyword char we accept any characters
4361 * before it except white space.
4362 */
4363 if (col == 0) /* cannot be an abbr. */
4364 return FALSE;
4365
4366#ifdef FEAT_MBYTE
4367 if (has_mbyte)
4368 {
4369 char_u *p;
4370
4371 p = mb_prevptr(ptr, ptr + col);
4372 if (!vim_iswordp(p))
4373 vim_abbr = TRUE; /* Vim added abbr. */
4374 else
4375 {
4376 vim_abbr = FALSE; /* vi compatible abbr. */
4377 if (p > ptr)
4378 is_id = vim_iswordp(mb_prevptr(ptr, p));
4379 }
4380 clen = 1;
4381 while (p > ptr + mincol)
4382 {
4383 p = mb_prevptr(ptr, p);
4384 if (vim_isspace(*p) || (!vim_abbr && is_id != vim_iswordp(p)))
4385 {
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00004386 p += (*mb_ptr2len)(p);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004387 break;
4388 }
4389 ++clen;
4390 }
4391 scol = (int)(p - ptr);
4392 }
4393 else
4394#endif
4395 {
4396 if (!vim_iswordc(ptr[col - 1]))
4397 vim_abbr = TRUE; /* Vim added abbr. */
4398 else
4399 {
4400 vim_abbr = FALSE; /* vi compatible abbr. */
4401 if (col > 1)
4402 is_id = vim_iswordc(ptr[col - 2]);
4403 }
4404 for (scol = col - 1; scol > 0 && !vim_isspace(ptr[scol - 1])
4405 && (vim_abbr || is_id == vim_iswordc(ptr[scol - 1])); --scol)
4406 ;
4407 }
4408
4409 if (scol < mincol)
4410 scol = mincol;
4411 if (scol < col) /* there is a word in front of the cursor */
4412 {
4413 ptr += scol;
4414 len = col - scol;
4415#ifdef FEAT_LOCALMAP
4416 mp = curbuf->b_first_abbr;
4417 mp2 = first_abbr;
4418 if (mp == NULL)
4419 {
4420 mp = mp2;
4421 mp2 = NULL;
4422 }
4423#else
4424 mp = first_abbr;
4425#endif
4426 for ( ; mp;
4427#ifdef FEAT_LOCALMAP
4428 mp->m_next == NULL ? (mp = mp2, mp2 = NULL) :
4429#endif
4430 (mp = mp->m_next))
4431 {
4432 /* find entries with right mode and keys */
4433 if ( (mp->m_mode & State)
4434 && mp->m_keylen == len
4435 && !STRNCMP(mp->m_keys, ptr, (size_t)len))
4436 break;
4437 }
4438 if (mp != NULL)
4439 {
4440 /*
4441 * Found a match:
4442 * Insert the rest of the abbreviation in typebuf.tb_buf[].
4443 * This goes from end to start.
4444 *
4445 * Characters 0x000 - 0x100: normal chars, may need CTRL-V,
4446 * except K_SPECIAL: Becomes K_SPECIAL KS_SPECIAL KE_FILLER
4447 * Characters where IS_SPECIAL() == TRUE: key codes, need
4448 * K_SPECIAL. Other characters (with ABBR_OFF): don't use CTRL-V.
4449 *
4450 * Character CTRL-] is treated specially - it completes the
4451 * abbreviation, but is not inserted into the input stream.
4452 */
4453 j = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004454 if (c != Ctrl_RSB)
4455 {
Bram Moolenaarda9591e2009-09-30 13:17:02 +00004456 /* special key code, split up */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004457 if (IS_SPECIAL(c) || c == K_SPECIAL)
4458 {
4459 tb[j++] = K_SPECIAL;
4460 tb[j++] = K_SECOND(c);
4461 tb[j++] = K_THIRD(c);
4462 }
4463 else
4464 {
4465 if (c < ABBR_OFF && (c < ' ' || c > '~'))
4466 tb[j++] = Ctrl_V; /* special char needs CTRL-V */
4467#ifdef FEAT_MBYTE
4468 if (has_mbyte)
4469 {
4470 /* if ABBR_OFF has been added, remove it here */
4471 if (c >= ABBR_OFF)
4472 c -= ABBR_OFF;
4473 j += (*mb_char2bytes)(c, tb + j);
4474 }
4475 else
4476#endif
4477 tb[j++] = c;
4478 }
4479 tb[j] = NUL;
4480 /* insert the last typed char */
4481 (void)ins_typebuf(tb, 1, 0, TRUE, mp->m_silent);
4482 }
Bram Moolenaar4e427192006-03-10 21:34:27 +00004483#ifdef FEAT_EVAL
4484 if (mp->m_expr)
Bram Moolenaarda9591e2009-09-30 13:17:02 +00004485 s = eval_map_expr(mp->m_str, c);
Bram Moolenaar4e427192006-03-10 21:34:27 +00004486 else
4487#endif
4488 s = mp->m_str;
4489 if (s != NULL)
4490 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00004491 /* insert the to string */
Bram Moolenaar4e427192006-03-10 21:34:27 +00004492 (void)ins_typebuf(s, mp->m_noremap, 0, TRUE, mp->m_silent);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004493 /* no abbrev. for these chars */
Bram Moolenaar4e427192006-03-10 21:34:27 +00004494 typebuf.tb_no_abbr_cnt += (int)STRLEN(s) + j + 1;
4495#ifdef FEAT_EVAL
4496 if (mp->m_expr)
4497 vim_free(s);
4498#endif
4499 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004500
4501 tb[0] = Ctrl_H;
4502 tb[1] = NUL;
4503#ifdef FEAT_MBYTE
4504 if (has_mbyte)
4505 len = clen; /* Delete characters instead of bytes */
4506#endif
4507 while (len-- > 0) /* delete the from string */
4508 (void)ins_typebuf(tb, 1, 0, TRUE, mp->m_silent);
4509 return TRUE;
4510 }
4511 }
4512 return FALSE;
4513}
4514
Bram Moolenaarc1e37902006-04-18 21:55:01 +00004515#ifdef FEAT_EVAL
4516/*
4517 * Evaluate the RHS of a mapping or abbreviations and take care of escaping
4518 * special characters.
4519 */
4520 static char_u *
Bram Moolenaarda9591e2009-09-30 13:17:02 +00004521eval_map_expr(str, c)
Bram Moolenaarc1e37902006-04-18 21:55:01 +00004522 char_u *str;
Bram Moolenaarda9591e2009-09-30 13:17:02 +00004523 int c; /* NUL or typed character for abbreviation */
Bram Moolenaarc1e37902006-04-18 21:55:01 +00004524{
4525 char_u *res;
Bram Moolenaar8424a622006-04-19 21:23:36 +00004526 char_u *p;
Bram Moolenaarf6f4a012011-08-17 17:18:20 +02004527 char_u *expr;
Bram Moolenaarc1b52862006-04-28 22:32:28 +00004528 char_u *save_cmd;
Bram Moolenaarc9b4b052006-04-30 18:54:39 +00004529 pos_T save_cursor;
Bram Moolenaar63760642011-12-23 14:54:04 +01004530 int save_msg_col;
4531 int save_msg_row;
Bram Moolenaarc1e37902006-04-18 21:55:01 +00004532
Bram Moolenaarf6f4a012011-08-17 17:18:20 +02004533 /* Remove escaping of CSI, because "str" is in a format to be used as
4534 * typeahead. */
4535 expr = vim_strsave(str);
4536 if (expr == NULL)
4537 return NULL;
4538 vim_unescape_csi(expr);
4539
Bram Moolenaarc1b52862006-04-28 22:32:28 +00004540 save_cmd = save_cmdline_alloc();
4541 if (save_cmd == NULL)
Bram Moolenaarf6f4a012011-08-17 17:18:20 +02004542 {
4543 vim_free(expr);
Bram Moolenaarc1b52862006-04-28 22:32:28 +00004544 return NULL;
Bram Moolenaarf6f4a012011-08-17 17:18:20 +02004545 }
Bram Moolenaarc9b4b052006-04-30 18:54:39 +00004546
4547 /* Forbid changing text or using ":normal" to avoid most of the bad side
4548 * effects. Also restore the cursor position. */
4549 ++textlock;
4550#ifdef FEAT_EX_EXTRA
4551 ++ex_normal_lock;
4552#endif
Bram Moolenaarda9591e2009-09-30 13:17:02 +00004553 set_vim_var_char(c); /* set v:char to the typed character */
Bram Moolenaarc9b4b052006-04-30 18:54:39 +00004554 save_cursor = curwin->w_cursor;
Bram Moolenaar63760642011-12-23 14:54:04 +01004555 save_msg_col = msg_col;
4556 save_msg_row = msg_row;
Bram Moolenaarf6f4a012011-08-17 17:18:20 +02004557 p = eval_to_string(expr, NULL, FALSE);
Bram Moolenaarc9b4b052006-04-30 18:54:39 +00004558 --textlock;
4559#ifdef FEAT_EX_EXTRA
4560 --ex_normal_lock;
4561#endif
4562 curwin->w_cursor = save_cursor;
Bram Moolenaar63760642011-12-23 14:54:04 +01004563 msg_col = save_msg_col;
4564 msg_row = save_msg_row;
Bram Moolenaarc9b4b052006-04-30 18:54:39 +00004565
Bram Moolenaarc1b52862006-04-28 22:32:28 +00004566 restore_cmdline_alloc(save_cmd);
Bram Moolenaarf6f4a012011-08-17 17:18:20 +02004567 vim_free(expr);
4568
Bram Moolenaar8424a622006-04-19 21:23:36 +00004569 if (p == NULL)
Bram Moolenaarc1e37902006-04-18 21:55:01 +00004570 return NULL;
Bram Moolenaarf6f4a012011-08-17 17:18:20 +02004571 /* Escape CSI in the result to be able to use the string as typeahead. */
Bram Moolenaarf193fff2006-04-27 00:02:13 +00004572 res = vim_strsave_escape_csi(p);
4573 vim_free(p);
4574
4575 return res;
4576}
4577#endif
4578
Bram Moolenaarf193fff2006-04-27 00:02:13 +00004579/*
4580 * Copy "p" to allocated memory, escaping K_SPECIAL and CSI so that the result
4581 * can be put in the typeahead buffer.
4582 * Returns NULL when out of memory.
4583 */
4584 char_u *
4585vim_strsave_escape_csi(p)
4586 char_u *p;
4587{
4588 char_u *res;
4589 char_u *s, *d;
Bram Moolenaarc1e37902006-04-18 21:55:01 +00004590
4591 /* Need a buffer to hold up to three times as much. */
Bram Moolenaar8424a622006-04-19 21:23:36 +00004592 res = alloc((unsigned)(STRLEN(p) * 3) + 1);
Bram Moolenaarc1e37902006-04-18 21:55:01 +00004593 if (res != NULL)
4594 {
Bram Moolenaar8424a622006-04-19 21:23:36 +00004595 d = res;
4596 for (s = p; *s != NUL; )
4597 {
4598 if (s[0] == K_SPECIAL && s[1] != NUL && s[2] != NUL)
4599 {
4600 /* Copy special key unmodified. */
4601 *d++ = *s++;
4602 *d++ = *s++;
4603 *d++ = *s++;
4604 }
4605 else
4606 {
4607 /* Add character, possibly multi-byte to destination, escaping
4608 * CSI and K_SPECIAL. */
4609 d = add_char2buf(PTR2CHAR(s), d);
4610 mb_ptr_adv(s);
4611 }
4612 }
4613 *d = NUL;
Bram Moolenaarc1e37902006-04-18 21:55:01 +00004614 }
Bram Moolenaarc1e37902006-04-18 21:55:01 +00004615 return res;
4616}
Bram Moolenaarc1e37902006-04-18 21:55:01 +00004617
Bram Moolenaar071d4272004-06-13 20:20:40 +00004618/*
Bram Moolenaar81b85872007-03-04 20:22:01 +00004619 * Remove escaping from CSI and K_SPECIAL characters. Reverse of
4620 * vim_strsave_escape_csi(). Works in-place.
4621 */
4622 void
4623vim_unescape_csi(p)
4624 char_u *p;
4625{
4626 char_u *s = p, *d = p;
4627
4628 while (*s != NUL)
4629 {
4630 if (s[0] == K_SPECIAL && s[1] == KS_SPECIAL && s[2] == KE_FILLER)
4631 {
4632 *d++ = K_SPECIAL;
4633 s += 3;
4634 }
4635 else if ((s[0] == K_SPECIAL || s[0] == CSI)
4636 && s[1] == KS_EXTRA && s[2] == (int)KE_CSI)
4637 {
4638 *d++ = CSI;
4639 s += 3;
4640 }
4641 else
4642 *d++ = *s++;
4643 }
4644 *d = NUL;
4645}
4646
4647/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00004648 * Write map commands for the current mappings to an .exrc file.
4649 * Return FAIL on error, OK otherwise.
4650 */
4651 int
4652makemap(fd, buf)
4653 FILE *fd;
4654 buf_T *buf; /* buffer for local mappings or NULL */
4655{
4656 mapblock_T *mp;
Bram Moolenaar01b9a402008-07-22 16:58:47 +00004657 char_u c1, c2, c3;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004658 char_u *p;
4659 char *cmd;
4660 int abbr;
4661 int hash;
4662 int did_cpo = FALSE;
4663 int i;
4664
4665 validate_maphash();
4666
4667 /*
4668 * Do the loop twice: Once for mappings, once for abbreviations.
4669 * Then loop over all map hash lists.
4670 */
4671 for (abbr = 0; abbr < 2; ++abbr)
4672 for (hash = 0; hash < 256; ++hash)
4673 {
4674 if (abbr)
4675 {
Bram Moolenaarbe4d5062006-03-18 21:30:13 +00004676 if (hash > 0) /* there is only one abbr list */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004677 break;
4678#ifdef FEAT_LOCALMAP
4679 if (buf != NULL)
4680 mp = buf->b_first_abbr;
4681 else
4682#endif
4683 mp = first_abbr;
4684 }
4685 else
4686 {
4687#ifdef FEAT_LOCALMAP
4688 if (buf != NULL)
4689 mp = buf->b_maphash[hash];
4690 else
4691#endif
4692 mp = maphash[hash];
4693 }
4694
4695 for ( ; mp; mp = mp->m_next)
4696 {
4697 /* skip script-local mappings */
4698 if (mp->m_noremap == REMAP_SCRIPT)
4699 continue;
4700
4701 /* skip mappings that contain a <SNR> (script-local thing),
4702 * they probably don't work when loaded again */
4703 for (p = mp->m_str; *p != NUL; ++p)
4704 if (p[0] == K_SPECIAL && p[1] == KS_EXTRA
4705 && p[2] == (int)KE_SNR)
4706 break;
4707 if (*p != NUL)
4708 continue;
4709
Bram Moolenaar01b9a402008-07-22 16:58:47 +00004710 /* It's possible to create a mapping and then ":unmap" certain
4711 * modes. We recreate this here by mapping the individual
4712 * modes, which requires up to three of them. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004713 c1 = NUL;
4714 c2 = NUL;
Bram Moolenaar01b9a402008-07-22 16:58:47 +00004715 c3 = NUL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004716 if (abbr)
4717 cmd = "abbr";
4718 else
4719 cmd = "map";
4720 switch (mp->m_mode)
4721 {
Bram Moolenaar371d5402006-03-20 21:47:49 +00004722 case NORMAL + VISUAL + SELECTMODE + OP_PENDING:
Bram Moolenaar071d4272004-06-13 20:20:40 +00004723 break;
4724 case NORMAL:
4725 c1 = 'n';
4726 break;
Bram Moolenaar371d5402006-03-20 21:47:49 +00004727 case VISUAL:
4728 c1 = 'x';
4729 break;
4730 case SELECTMODE:
4731 c1 = 's';
4732 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004733 case OP_PENDING:
4734 c1 = 'o';
4735 break;
Bram Moolenaar01b9a402008-07-22 16:58:47 +00004736 case NORMAL + VISUAL:
4737 c1 = 'n';
4738 c2 = 'x';
4739 break;
4740 case NORMAL + SELECTMODE:
4741 c1 = 'n';
4742 c2 = 's';
4743 break;
4744 case NORMAL + OP_PENDING:
4745 c1 = 'n';
4746 c2 = 'o';
4747 break;
4748 case VISUAL + SELECTMODE:
4749 c1 = 'v';
4750 break;
4751 case VISUAL + OP_PENDING:
4752 c1 = 'x';
4753 c2 = 'o';
4754 break;
4755 case SELECTMODE + OP_PENDING:
4756 c1 = 's';
4757 c2 = 'o';
4758 break;
Bram Moolenaar371d5402006-03-20 21:47:49 +00004759 case NORMAL + VISUAL + SELECTMODE:
Bram Moolenaar071d4272004-06-13 20:20:40 +00004760 c1 = 'n';
4761 c2 = 'v';
4762 break;
Bram Moolenaar01b9a402008-07-22 16:58:47 +00004763 case NORMAL + VISUAL + OP_PENDING:
4764 c1 = 'n';
4765 c2 = 'x';
4766 c3 = 'o';
4767 break;
4768 case NORMAL + SELECTMODE + OP_PENDING:
4769 c1 = 'n';
4770 c2 = 's';
4771 c3 = 'o';
4772 break;
Bram Moolenaar371d5402006-03-20 21:47:49 +00004773 case VISUAL + SELECTMODE + OP_PENDING:
Bram Moolenaar071d4272004-06-13 20:20:40 +00004774 c1 = 'v';
4775 c2 = 'o';
4776 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004777 case CMDLINE + INSERT:
4778 if (!abbr)
4779 cmd = "map!";
4780 break;
4781 case CMDLINE:
4782 c1 = 'c';
4783 break;
4784 case INSERT:
4785 c1 = 'i';
4786 break;
4787 case LANGMAP:
4788 c1 = 'l';
4789 break;
4790 default:
4791 EMSG(_("E228: makemap: Illegal mode"));
4792 return FAIL;
4793 }
Bram Moolenaar01b9a402008-07-22 16:58:47 +00004794 do /* do this twice if c2 is set, 3 times with c3 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004795 {
4796 /* When outputting <> form, need to make sure that 'cpo'
4797 * is set to the Vim default. */
4798 if (!did_cpo)
4799 {
4800 if (*mp->m_str == NUL) /* will use <Nop> */
4801 did_cpo = TRUE;
4802 else
4803 for (i = 0; i < 2; ++i)
4804 for (p = (i ? mp->m_str : mp->m_keys); *p; ++p)
4805 if (*p == K_SPECIAL || *p == NL)
4806 did_cpo = TRUE;
4807 if (did_cpo)
4808 {
4809 if (fprintf(fd, "let s:cpo_save=&cpo") < 0
4810 || put_eol(fd) < 0
4811 || fprintf(fd, "set cpo&vim") < 0
4812 || put_eol(fd) < 0)
4813 return FAIL;
4814 }
4815 }
4816 if (c1 && putc(c1, fd) < 0)
4817 return FAIL;
4818 if (mp->m_noremap != REMAP_YES && fprintf(fd, "nore") < 0)
4819 return FAIL;
Bram Moolenaarfe86f2d2008-11-28 20:29:07 +00004820 if (fputs(cmd, fd) < 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004821 return FAIL;
4822 if (buf != NULL && fputs(" <buffer>", fd) < 0)
4823 return FAIL;
4824 if (mp->m_silent && fputs(" <silent>", fd) < 0)
4825 return FAIL;
Bram Moolenaar4e427192006-03-10 21:34:27 +00004826#ifdef FEAT_EVAL
4827 if (mp->m_noremap == REMAP_SCRIPT
4828 && fputs("<script>", fd) < 0)
4829 return FAIL;
4830 if (mp->m_expr && fputs(" <expr>", fd) < 0)
4831 return FAIL;
4832#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004833
4834 if ( putc(' ', fd) < 0
4835 || put_escstr(fd, mp->m_keys, 0) == FAIL
4836 || putc(' ', fd) < 0
4837 || put_escstr(fd, mp->m_str, 1) == FAIL
4838 || put_eol(fd) < 0)
4839 return FAIL;
4840 c1 = c2;
Bram Moolenaar01b9a402008-07-22 16:58:47 +00004841 c2 = c3;
4842 c3 = NUL;
4843 } while (c1 != NUL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004844 }
4845 }
4846
4847 if (did_cpo)
4848 if (fprintf(fd, "let &cpo=s:cpo_save") < 0
4849 || put_eol(fd) < 0
4850 || fprintf(fd, "unlet s:cpo_save") < 0
4851 || put_eol(fd) < 0)
4852 return FAIL;
4853 return OK;
4854}
4855
4856/*
4857 * write escape string to file
4858 * "what": 0 for :map lhs, 1 for :map rhs, 2 for :set
4859 *
4860 * return FAIL for failure, OK otherwise
4861 */
4862 int
4863put_escstr(fd, strstart, what)
4864 FILE *fd;
4865 char_u *strstart;
4866 int what;
4867{
4868 char_u *str = strstart;
4869 int c;
4870 int modifiers;
4871
4872 /* :map xx <Nop> */
4873 if (*str == NUL && what == 1)
4874 {
4875 if (fprintf(fd, "<Nop>") < 0)
4876 return FAIL;
4877 return OK;
4878 }
4879
4880 for ( ; *str != NUL; ++str)
4881 {
4882#ifdef FEAT_MBYTE
4883 char_u *p;
4884
4885 /* Check for a multi-byte character, which may contain escaped
4886 * K_SPECIAL and CSI bytes */
4887 p = mb_unescape(&str);
4888 if (p != NULL)
4889 {
4890 while (*p != NUL)
Bram Moolenaar51485f02005-06-04 21:55:20 +00004891 if (fputc(*p++, fd) < 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004892 return FAIL;
4893 --str;
4894 continue;
4895 }
4896#endif
4897
4898 c = *str;
4899 /*
4900 * Special key codes have to be translated to be able to make sense
4901 * when they are read back.
4902 */
4903 if (c == K_SPECIAL && what != 2)
4904 {
4905 modifiers = 0x0;
4906 if (str[1] == KS_MODIFIER)
4907 {
4908 modifiers = str[2];
4909 str += 3;
4910 c = *str;
4911 }
4912 if (c == K_SPECIAL)
4913 {
4914 c = TO_SPECIAL(str[1], str[2]);
4915 str += 2;
4916 }
4917 if (IS_SPECIAL(c) || modifiers) /* special key */
4918 {
Bram Moolenaarfe86f2d2008-11-28 20:29:07 +00004919 if (fputs((char *)get_special_key_name(c, modifiers), fd) < 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004920 return FAIL;
4921 continue;
4922 }
4923 }
4924
4925 /*
4926 * A '\n' in a map command should be written as <NL>.
4927 * A '\n' in a set command should be written as \^V^J.
4928 */
4929 if (c == NL)
4930 {
4931 if (what == 2)
4932 {
4933 if (fprintf(fd, IF_EB("\\\026\n", "\\" CTRL_V_STR "\n")) < 0)
4934 return FAIL;
4935 }
4936 else
4937 {
4938 if (fprintf(fd, "<NL>") < 0)
4939 return FAIL;
4940 }
4941 continue;
4942 }
4943
4944 /*
4945 * Some characters have to be escaped with CTRL-V to
4946 * prevent them from misinterpreted in DoOneCmd().
4947 * A space, Tab and '"' has to be escaped with a backslash to
4948 * prevent it to be misinterpreted in do_set().
4949 * A space has to be escaped with a CTRL-V when it's at the start of a
4950 * ":map" rhs.
4951 * A '<' has to be escaped with a CTRL-V to prevent it being
4952 * interpreted as the start of a special key name.
4953 * A space in the lhs of a :map needs a CTRL-V.
4954 */
4955 if (what == 2 && (vim_iswhite(c) || c == '"' || c == '\\'))
4956 {
4957 if (putc('\\', fd) < 0)
4958 return FAIL;
4959 }
4960 else if (c < ' ' || c > '~' || c == '|'
4961 || (what == 0 && c == ' ')
4962 || (what == 1 && str == strstart && c == ' ')
4963 || (what != 2 && c == '<'))
4964 {
4965 if (putc(Ctrl_V, fd) < 0)
4966 return FAIL;
4967 }
4968 if (putc(c, fd) < 0)
4969 return FAIL;
4970 }
4971 return OK;
4972}
4973
4974/*
4975 * Check all mappings for the presence of special key codes.
4976 * Used after ":set term=xxx".
4977 */
4978 void
4979check_map_keycodes()
4980{
4981 mapblock_T *mp;
4982 char_u *p;
4983 int i;
4984 char_u buf[3];
4985 char_u *save_name;
4986 int abbr;
4987 int hash;
4988#ifdef FEAT_LOCALMAP
4989 buf_T *bp;
4990#endif
4991
4992 validate_maphash();
4993 save_name = sourcing_name;
4994 sourcing_name = (char_u *)"mappings"; /* avoids giving error messages */
4995
4996#ifdef FEAT_LOCALMAP
4997 /* This this once for each buffer, and then once for global
4998 * mappings/abbreviations with bp == NULL */
4999 for (bp = firstbuf; ; bp = bp->b_next)
5000 {
5001#endif
5002 /*
5003 * Do the loop twice: Once for mappings, once for abbreviations.
5004 * Then loop over all map hash lists.
5005 */
5006 for (abbr = 0; abbr <= 1; ++abbr)
5007 for (hash = 0; hash < 256; ++hash)
5008 {
5009 if (abbr)
5010 {
5011 if (hash) /* there is only one abbr list */
5012 break;
5013#ifdef FEAT_LOCALMAP
5014 if (bp != NULL)
5015 mp = bp->b_first_abbr;
5016 else
5017#endif
5018 mp = first_abbr;
5019 }
5020 else
5021 {
5022#ifdef FEAT_LOCALMAP
5023 if (bp != NULL)
5024 mp = bp->b_maphash[hash];
5025 else
5026#endif
5027 mp = maphash[hash];
5028 }
5029 for ( ; mp != NULL; mp = mp->m_next)
5030 {
5031 for (i = 0; i <= 1; ++i) /* do this twice */
5032 {
5033 if (i == 0)
5034 p = mp->m_keys; /* once for the "from" part */
5035 else
5036 p = mp->m_str; /* and once for the "to" part */
5037 while (*p)
5038 {
5039 if (*p == K_SPECIAL)
5040 {
5041 ++p;
5042 if (*p < 128) /* for "normal" tcap entries */
5043 {
5044 buf[0] = p[0];
5045 buf[1] = p[1];
5046 buf[2] = NUL;
5047 (void)add_termcap_entry(buf, FALSE);
5048 }
5049 ++p;
5050 }
5051 ++p;
5052 }
5053 }
5054 }
5055 }
5056#ifdef FEAT_LOCALMAP
5057 if (bp == NULL)
5058 break;
5059 }
5060#endif
5061 sourcing_name = save_name;
5062}
5063
Bram Moolenaarbd743252010-10-20 21:23:33 +02005064#if defined(FEAT_EVAL) || defined(PROTO)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005065/*
Bram Moolenaarbd743252010-10-20 21:23:33 +02005066 * Check the string "keys" against the lhs of all mappings.
5067 * Return pointer to rhs of mapping (mapblock->m_str).
5068 * NULL when no mapping found.
Bram Moolenaar071d4272004-06-13 20:20:40 +00005069 */
5070 char_u *
Bram Moolenaarbd743252010-10-20 21:23:33 +02005071check_map(keys, mode, exact, ign_mod, abbr, mp_ptr, local_ptr)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005072 char_u *keys;
5073 int mode;
5074 int exact; /* require exact match */
Bram Moolenaar686f51e2005-05-20 21:19:57 +00005075 int ign_mod; /* ignore preceding modifier */
Bram Moolenaarbe4d5062006-03-18 21:30:13 +00005076 int abbr; /* do abbreviations */
Bram Moolenaarbd743252010-10-20 21:23:33 +02005077 mapblock_T **mp_ptr; /* return: pointer to mapblock or NULL */
5078 int *local_ptr; /* return: buffer-local mapping or NULL */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005079{
5080 int hash;
5081 int len, minlen;
5082 mapblock_T *mp;
Bram Moolenaar686f51e2005-05-20 21:19:57 +00005083 char_u *s;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005084#ifdef FEAT_LOCALMAP
5085 int local;
5086#endif
5087
5088 validate_maphash();
5089
5090 len = (int)STRLEN(keys);
5091#ifdef FEAT_LOCALMAP
5092 for (local = 1; local >= 0; --local)
5093#endif
5094 /* loop over all hash lists */
5095 for (hash = 0; hash < 256; ++hash)
5096 {
Bram Moolenaarbe4d5062006-03-18 21:30:13 +00005097 if (abbr)
5098 {
5099 if (hash > 0) /* there is only one list. */
5100 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005101#ifdef FEAT_LOCALMAP
Bram Moolenaarbe4d5062006-03-18 21:30:13 +00005102 if (local)
5103 mp = curbuf->b_first_abbr;
5104 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00005105#endif
Bram Moolenaarbe4d5062006-03-18 21:30:13 +00005106 mp = first_abbr;
5107 }
5108#ifdef FEAT_LOCALMAP
5109 else if (local)
5110 mp = curbuf->b_maphash[hash];
5111#endif
5112 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00005113 mp = maphash[hash];
5114 for ( ; mp != NULL; mp = mp->m_next)
5115 {
5116 /* skip entries with wrong mode, wrong length and not matching
5117 * ones */
Bram Moolenaar686f51e2005-05-20 21:19:57 +00005118 if ((mp->m_mode & mode) && (!exact || mp->m_keylen == len))
5119 {
5120 if (len > mp->m_keylen)
5121 minlen = mp->m_keylen;
5122 else
5123 minlen = len;
5124 s = mp->m_keys;
5125 if (ign_mod && s[0] == K_SPECIAL && s[1] == KS_MODIFIER
5126 && s[2] != NUL)
5127 {
5128 s += 3;
5129 if (len > mp->m_keylen - 3)
5130 minlen = mp->m_keylen - 3;
5131 }
5132 if (STRNCMP(s, keys, minlen) == 0)
Bram Moolenaarbd743252010-10-20 21:23:33 +02005133 {
5134 if (mp_ptr != NULL)
5135 *mp_ptr = mp;
5136 if (local_ptr != NULL)
Bram Moolenaarb8e86702010-10-22 22:13:52 +02005137#ifdef FEAT_LOCALMAP
Bram Moolenaarbd743252010-10-20 21:23:33 +02005138 *local_ptr = local;
Bram Moolenaarb8e86702010-10-22 22:13:52 +02005139#else
5140 *local_ptr = 0;
5141#endif
Bram Moolenaar686f51e2005-05-20 21:19:57 +00005142 return mp->m_str;
Bram Moolenaarbd743252010-10-20 21:23:33 +02005143 }
Bram Moolenaar686f51e2005-05-20 21:19:57 +00005144 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00005145 }
5146 }
5147
5148 return NULL;
5149}
5150#endif
5151
Bram Moolenaarbc7aa852005-03-06 23:38:09 +00005152#if defined(MSDOS) || defined(MSWIN) || defined(OS2) || defined(MACOS)
Bram Moolenaar371d5402006-03-20 21:47:49 +00005153
5154#define VIS_SEL (VISUAL+SELECTMODE) /* abbreviation */
5155
Bram Moolenaar071d4272004-06-13 20:20:40 +00005156/*
5157 * Default mappings for some often used keys.
5158 */
5159static struct initmap
5160{
5161 char_u *arg;
5162 int mode;
5163} initmappings[] =
5164{
5165#if defined(MSDOS) || defined(MSWIN) || defined(OS2)
5166 /* Use the Windows (CUA) keybindings. */
5167# ifdef FEAT_GUI
Bram Moolenaar071d4272004-06-13 20:20:40 +00005168 /* paste, copy and cut */
5169 {(char_u *)"<S-Insert> \"*P", NORMAL},
Bram Moolenaar371d5402006-03-20 21:47:49 +00005170 {(char_u *)"<S-Insert> \"-d\"*P", VIS_SEL},
Bram Moolenaar071d4272004-06-13 20:20:40 +00005171 {(char_u *)"<S-Insert> <C-R><C-O>*", INSERT+CMDLINE},
Bram Moolenaar371d5402006-03-20 21:47:49 +00005172 {(char_u *)"<C-Insert> \"*y", VIS_SEL},
5173 {(char_u *)"<S-Del> \"*d", VIS_SEL},
5174 {(char_u *)"<C-Del> \"*d", VIS_SEL},
5175 {(char_u *)"<C-X> \"*d", VIS_SEL},
Bram Moolenaar071d4272004-06-13 20:20:40 +00005176 /* Missing: CTRL-C (cancel) and CTRL-V (block selection) */
5177# else
Bram Moolenaar371d5402006-03-20 21:47:49 +00005178 {(char_u *)"\316w <C-Home>", NORMAL+VIS_SEL},
Bram Moolenaar071d4272004-06-13 20:20:40 +00005179 {(char_u *)"\316w <C-Home>", INSERT+CMDLINE},
Bram Moolenaar371d5402006-03-20 21:47:49 +00005180 {(char_u *)"\316u <C-End>", NORMAL+VIS_SEL},
Bram Moolenaar071d4272004-06-13 20:20:40 +00005181 {(char_u *)"\316u <C-End>", INSERT+CMDLINE},
5182
5183 /* paste, copy and cut */
5184# ifdef FEAT_CLIPBOARD
5185# ifdef DJGPP
5186 {(char_u *)"\316\122 \"*P", NORMAL}, /* SHIFT-Insert is "*P */
Bram Moolenaar09092152010-08-08 16:38:42 +02005187 {(char_u *)"\316\122 \"-d\"*P", VIS_SEL}, /* SHIFT-Insert is "-d"*P */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005188 {(char_u *)"\316\122 \022\017*", INSERT}, /* SHIFT-Insert is ^R^O* */
Bram Moolenaar371d5402006-03-20 21:47:49 +00005189 {(char_u *)"\316\222 \"*y", VIS_SEL}, /* CTRL-Insert is "*y */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005190# if 0 /* Shift-Del produces the same code as Del */
Bram Moolenaar371d5402006-03-20 21:47:49 +00005191 {(char_u *)"\316\123 \"*d", VIS_SEL}, /* SHIFT-Del is "*d */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005192# endif
Bram Moolenaar371d5402006-03-20 21:47:49 +00005193 {(char_u *)"\316\223 \"*d", VIS_SEL}, /* CTRL-Del is "*d */
5194 {(char_u *)"\030 \"-d", VIS_SEL}, /* CTRL-X is "-d */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005195# else
5196 {(char_u *)"\316\324 \"*P", NORMAL}, /* SHIFT-Insert is "*P */
Bram Moolenaar09092152010-08-08 16:38:42 +02005197 {(char_u *)"\316\324 \"-d\"*P", VIS_SEL}, /* SHIFT-Insert is "-d"*P */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005198 {(char_u *)"\316\324 \022\017*", INSERT}, /* SHIFT-Insert is ^R^O* */
Bram Moolenaar371d5402006-03-20 21:47:49 +00005199 {(char_u *)"\316\325 \"*y", VIS_SEL}, /* CTRL-Insert is "*y */
5200 {(char_u *)"\316\327 \"*d", VIS_SEL}, /* SHIFT-Del is "*d */
5201 {(char_u *)"\316\330 \"*d", VIS_SEL}, /* CTRL-Del is "*d */
5202 {(char_u *)"\030 \"-d", VIS_SEL}, /* CTRL-X is "-d */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005203# endif
5204# else
5205 {(char_u *)"\316\324 P", NORMAL}, /* SHIFT-Insert is P */
Bram Moolenaar371d5402006-03-20 21:47:49 +00005206 {(char_u *)"\316\324 \"-dP", VIS_SEL}, /* SHIFT-Insert is "-dP */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005207 {(char_u *)"\316\324 \022\017\"", INSERT}, /* SHIFT-Insert is ^R^O" */
Bram Moolenaar371d5402006-03-20 21:47:49 +00005208 {(char_u *)"\316\325 y", VIS_SEL}, /* CTRL-Insert is y */
5209 {(char_u *)"\316\327 d", VIS_SEL}, /* SHIFT-Del is d */
5210 {(char_u *)"\316\330 d", VIS_SEL}, /* CTRL-Del is d */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005211# endif
5212# endif
5213#endif
5214
5215#if defined(MACOS)
5216 /* Use the Standard MacOS binding. */
5217 /* paste, copy and cut */
5218 {(char_u *)"<D-v> \"*P", NORMAL},
Bram Moolenaar371d5402006-03-20 21:47:49 +00005219 {(char_u *)"<D-v> \"-d\"*P", VIS_SEL},
Bram Moolenaar071d4272004-06-13 20:20:40 +00005220 {(char_u *)"<D-v> <C-R>*", INSERT+CMDLINE},
Bram Moolenaar371d5402006-03-20 21:47:49 +00005221 {(char_u *)"<D-c> \"*y", VIS_SEL},
5222 {(char_u *)"<D-x> \"*d", VIS_SEL},
5223 {(char_u *)"<Backspace> \"-d", VIS_SEL},
Bram Moolenaar071d4272004-06-13 20:20:40 +00005224#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005225};
Bram Moolenaar371d5402006-03-20 21:47:49 +00005226
5227# undef VIS_SEL
Bram Moolenaarbc7aa852005-03-06 23:38:09 +00005228#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005229
5230/*
5231 * Set up default mappings.
5232 */
5233 void
5234init_mappings()
5235{
Bram Moolenaarbc7aa852005-03-06 23:38:09 +00005236#if defined(MSDOS) || defined(MSWIN) || defined(OS2) || defined(MACOS)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005237 int i;
5238
5239 for (i = 0; i < sizeof(initmappings) / sizeof(struct initmap); ++i)
5240 add_map(initmappings[i].arg, initmappings[i].mode);
Bram Moolenaarbc7aa852005-03-06 23:38:09 +00005241#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005242}
5243
Bram Moolenaar52b4b552005-03-07 23:00:57 +00005244#if defined(MSDOS) || defined(MSWIN) || defined(OS2) \
5245 || defined(FEAT_CMDWIN) || defined(MACOS) || defined(PROTO)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005246/*
5247 * Add a mapping "map" for mode "mode".
5248 * Need to put string in allocated memory, because do_map() will modify it.
5249 */
5250 void
5251add_map(map, mode)
5252 char_u *map;
5253 int mode;
5254{
5255 char_u *s;
5256 char_u *cpo_save = p_cpo;
5257
5258 p_cpo = (char_u *)""; /* Allow <> notation */
5259 s = vim_strsave(map);
5260 if (s != NULL)
5261 {
5262 (void)do_map(0, s, mode, FALSE);
5263 vim_free(s);
5264 }
5265 p_cpo = cpo_save;
5266}
Bram Moolenaar52b4b552005-03-07 23:00:57 +00005267#endif