1 /* vi:set ts=8 sts=4 sw=4:
3 * VIM - Vi IMproved by Bram Moolenaar
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.
13 * functions related with getting a character from the user/mapping/redo/...
15 * manipulations with redo buffer and stuff buffer
16 * mappings and abbreviations
22 * These buffers are used for storing:
23 * - stuffed characters: A command that is translated into another command.
24 * - redo characters: will redo the last change.
25 * - recorded chracters: for the "q" command.
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!
35 * Escaping CSI bytes is done by the system-specific input functions, called
37 * Escaping K_SPECIAL is done by inchar().
38 * Un-escaping is done by vgetc().
41 #define MINIMAL_SIZE 20 /* minimal size for b_str */
43 static struct buffheader redobuff
= {{NULL
, {NUL
}}, NULL
, 0, 0};
44 static struct buffheader old_redobuff
= {{NULL
, {NUL
}}, NULL
, 0, 0};
45 #if defined(FEAT_AUTOCMD) || defined(FEAT_EVAL) || defined(PROTO)
46 static struct buffheader save_redobuff
= {{NULL
, {NUL
}}, NULL
, 0, 0};
47 static struct buffheader save_old_redobuff
= {{NULL
, {NUL
}}, NULL
, 0, 0};
49 static struct buffheader recordbuff
= {{NULL
, {NUL
}}, NULL
, 0, 0};
51 static int typeahead_char
= 0; /* typeahead char that's not flushed */
54 * when block_redo is TRUE redo buffer will not be changed
55 * used by edit() to repeat insertions and 'V' command for redoing
57 static int block_redo
= FALSE
;
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.
66 #define MAP_HASH(mode, c1) (((mode) & (NORMAL + VISUAL + SELECTMODE + OP_PENDING)) ? (c1) : ((c1) ^ 0x80))
69 * Each mapping is put in one of the 256 hash lists, to speed up finding it.
71 static mapblock_T
*(maphash
[256]);
72 static int maphash_valid
= FALSE
;
75 * List used for abbreviations.
77 static mapblock_T
*first_abbr
= NULL
; /* first entry in abbrlist */
79 static int KeyNoremap
= 0; /* remapping flags */
82 * variables used by vgetorpeek() and flush_buffers()
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).
100 #define RM_YES 0 /* tb_noremap: remap */
101 #define RM_NONE 1 /* tb_noremap: don't remap */
102 #define RM_SCRIPT 2 /* tb_noremap: remap local script mappings */
103 #define RM_ABBR 4 /* tb_noremap: don't remap, do abbrev. */
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).
109 #define TYPELEN_INIT (5 * (MAXMAPLEN + 3))
110 static char_u typebuf_init
[TYPELEN_INIT
]; /* initial typebuf.tb_buf */
111 static char_u noremapbuf_init
[TYPELEN_INIT
]; /* initial typebuf.tb_noremap */
113 static int last_recorded_len
= 0; /* number of last recorded chars */
115 static char_u
*get_buffcont
__ARGS((struct buffheader
*, int));
116 static void add_buff
__ARGS((struct buffheader
*, char_u
*, long n
));
117 static void add_num_buff
__ARGS((struct buffheader
*, long));
118 static void add_char_buff
__ARGS((struct buffheader
*, int));
119 static int read_stuff
__ARGS((int advance
));
120 static void start_stuff
__ARGS((void));
121 static int read_redo
__ARGS((int, int));
122 static void copy_redo
__ARGS((int));
123 static void init_typebuf
__ARGS((void));
124 static void gotchars
__ARGS((char_u
*, int));
125 static void may_sync_undo
__ARGS((void));
126 static void closescript
__ARGS((void));
127 static int vgetorpeek
__ARGS((int));
128 static void map_free
__ARGS((mapblock_T
**));
129 static void validate_maphash
__ARGS((void));
130 static void showmap
__ARGS((mapblock_T
*mp
, int local
));
132 static char_u
*eval_map_expr
__ARGS((char_u
*str
));
136 * Free and clear a buffer.
140 struct buffheader
*buf
;
142 struct buffblock
*p
, *np
;
144 for (p
= buf
->bh_first
.b_next
; p
!= NULL
; p
= np
)
149 buf
->bh_first
.b_next
= NULL
;
153 * Return the contents of a buffer as a single string.
154 * K_SPECIAL and CSI in the returned string are escaped.
157 get_buffcont(buffer
, dozero
)
158 struct buffheader
*buffer
;
159 int dozero
; /* count == zero is not an error */
165 struct buffblock
*bp
;
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
);
171 if ((count
|| dozero
) && (p
= lalloc(count
+ 1, TRUE
)) != NULL
)
174 for (bp
= buffer
->bh_first
.b_next
; bp
!= NULL
; bp
= bp
->b_next
)
175 for (str
= bp
->b_str
; *str
; )
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.
193 p
= get_buffcont(&recordbuff
, TRUE
);
194 free_buff(&recordbuff
);
197 * Remove the characters that were added the last time, these must be the
198 * (possibly mapped) characters that stopped the recording.
201 if ((int)len
>= last_recorded_len
)
203 len
-= last_recorded_len
;
208 * When stopping recording from Insert mode with CTRL-O q, also remove the
211 if (len
> 0 && restart_edit
!= 0 && p
[len
- 1] == Ctrl_O
)
218 * Return the contents of the redo buffer as a single string.
219 * K_SPECIAL and CSI in the returned string are escaped.
224 return get_buffcont(&redobuff
, FALSE
);
228 * Add string "s" after the current block of buffer "buf".
229 * K_SPECIAL and CSI should have been escaped already.
232 add_buff(buf
, s
, slen
)
233 struct buffheader
*buf
;
235 long slen
; /* length of "s" or -1 */
241 slen
= (long)STRLEN(s
);
242 if (slen
== 0) /* don't add empty strings */
245 if (buf
->bh_first
.b_next
== NULL
) /* first add to list */
248 buf
->bh_curr
= &(buf
->bh_first
);
250 else if (buf
->bh_curr
== NULL
) /* buffer has already been read */
252 EMSG(_("E222: Add to read buffer"));
255 else if (buf
->bh_index
!= 0)
256 mch_memmove(buf
->bh_first
.b_next
->b_str
,
257 buf
->bh_first
.b_next
->b_str
+ buf
->bh_index
,
258 STRLEN(buf
->bh_first
.b_next
->b_str
+ buf
->bh_index
) + 1);
261 if (buf
->bh_space
>= (int)slen
)
263 len
= (long_u
)STRLEN(buf
->bh_curr
->b_str
);
264 vim_strncpy(buf
->bh_curr
->b_str
+ len
, s
, (size_t)slen
);
265 buf
->bh_space
-= slen
;
269 if (slen
< MINIMAL_SIZE
)
273 p
= (struct buffblock
*)lalloc((long_u
)(sizeof(struct buffblock
) + len
),
276 return; /* no space, just forget it */
277 buf
->bh_space
= (int)(len
- slen
);
278 vim_strncpy(p
->b_str
, s
, (size_t)slen
);
280 p
->b_next
= buf
->bh_curr
->b_next
;
281 buf
->bh_curr
->b_next
= p
;
288 * Add number "n" to buffer "buf".
292 struct buffheader
*buf
;
297 sprintf((char *)number
, "%ld", n
);
298 add_buff(buf
, number
, -1L);
302 * Add character 'c' to buffer "buf".
303 * Translates special keys, NUL, CSI, K_SPECIAL and multibyte characters.
306 add_char_buff(buf
, c
)
307 struct buffheader
*buf
;
311 char_u bytes
[MB_MAXBYTES
+ 1];
321 len
= (*mb_char2bytes
)(c
, bytes
);
322 for (i
= 0; i
< len
; ++i
)
328 if (IS_SPECIAL(c
) || c
== K_SPECIAL
|| c
== NUL
)
330 /* translate special key code into three byte sequence */
332 temp
[1] = K_SECOND(c
);
333 temp
[2] = K_THIRD(c
);
339 /* Translate a CSI to a CSI - KS_EXTRA - KE_CSI sequence */
342 temp
[2] = (int)KE_CSI
;
351 add_buff(buf
, temp
, -1L);
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.
367 struct buffblock
*curr
;
369 if (stuffbuff
.bh_first
.b_next
== NULL
) /* buffer is empty */
372 curr
= stuffbuff
.bh_first
.b_next
;
373 c
= curr
->b_str
[stuffbuff
.bh_index
];
377 if (curr
->b_str
[++stuffbuff
.bh_index
] == NUL
)
379 stuffbuff
.bh_first
.b_next
= curr
->b_next
;
381 stuffbuff
.bh_index
= 0;
388 * Prepare the stuff buffer for reading (if it contains something).
393 if (stuffbuff
.bh_first
.b_next
!= NULL
)
395 stuffbuff
.bh_curr
= &(stuffbuff
.bh_first
);
396 stuffbuff
.bh_space
= 0;
401 * Return TRUE if the stuff buffer is empty.
406 return (stuffbuff
.bh_first
.b_next
== NULL
);
410 * Set a typeahead character that won't be flushed.
420 * Remove the contents of the stuff buffer and the mapped characters in the
421 * typeahead buffer (used in case of an error). If 'typeahead' is true,
422 * flush all typeahead characters (used when interrupted by a CTRL-C).
425 flush_buffers(typeahead
)
431 while (read_stuff(TRUE
) != NUL
)
434 if (typeahead
) /* remove all typeahead */
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.
441 while (inchar(typebuf
.tb_buf
, typebuf
.tb_buflen
- 1, 10L,
442 typebuf
.tb_change_cnt
) != 0)
444 typebuf
.tb_off
= MAXMAPLEN
;
447 else /* remove mapped characters only */
449 typebuf
.tb_off
+= typebuf
.tb_maplen
;
450 typebuf
.tb_len
-= typebuf
.tb_maplen
;
452 typebuf
.tb_maplen
= 0;
453 typebuf
.tb_silent
= 0;
455 typebuf
.tb_no_abbr_cnt
= 0;
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.
467 free_buff(&old_redobuff
);
468 old_redobuff
= redobuff
;
469 redobuff
.bh_first
.b_next
= NULL
;
473 #if defined(FEAT_AUTOCMD) || defined(FEAT_EVAL) || defined(PROTO)
475 * Save redobuff and old_redobuff to save_redobuff and save_old_redobuff.
476 * Used before executing autocommands and user functions.
478 static int save_level
= 0;
485 if (save_level
++ == 0)
487 save_redobuff
= redobuff
;
488 redobuff
.bh_first
.b_next
= NULL
;
489 save_old_redobuff
= old_redobuff
;
490 old_redobuff
.bh_first
.b_next
= NULL
;
492 /* Make a copy, so that ":normal ." in a function works. */
493 s
= get_buffcont(&save_redobuff
, FALSE
);
496 add_buff(&redobuff
, s
, -1L);
503 * Restore redobuff and old_redobuff from save_redobuff and save_old_redobuff.
504 * Used after executing autocommands and user functions.
509 if (--save_level
== 0)
511 free_buff(&redobuff
);
512 redobuff
= save_redobuff
;
513 free_buff(&old_redobuff
);
514 old_redobuff
= save_old_redobuff
;
520 * Append "s" to the redo buffer.
521 * K_SPECIAL and CSI should already have been escaped.
528 add_buff(&redobuff
, s
, -1L);
532 * Append to Redo buffer literally, escaping special characters with CTRL-V.
533 * K_SPECIAL and CSI are escaped as well.
536 AppendToRedobuffLit(str
, len
)
538 int len
; /* length of "str" or -1 for up to the NUL */
547 while (len
< 0 ? *s
!= NUL
: s
- str
< len
)
549 /* Put a string of normal characters in the redo buffer (that's
554 && *s
< DEL
/* EBCDIC: all chars above space are normal */
556 && (len
< 0 || s
- str
< len
))
559 /* Don't put '0' or '^' as last character, just in case a CTRL-D is
561 if (*s
== NUL
&& (s
[-1] == '0' || s
[-1] == '^'))
564 add_buff(&redobuff
, start
, (long)(s
- start
));
566 if (*s
== NUL
|| (len
>= 0 && s
- str
>= len
))
569 /* Handle a special or multibyte character. */
572 /* Handle composing chars separately. */
573 c
= mb_cptr2char_adv(&s
);
577 if (c
< ' ' || c
== DEL
|| (*s
== NUL
&& (c
== '0' || c
== '^')))
578 add_char_buff(&redobuff
, Ctrl_V
);
580 /* CTRL-V '0' must be inserted as CTRL-V 048 (EBCDIC: xf0) */
581 if (*s
== NUL
&& c
== '0')
583 add_buff(&redobuff
, (char_u
*)"xf0", 3L);
585 add_buff(&redobuff
, (char_u
*)"048", 3L);
588 add_char_buff(&redobuff
, c
);
593 * Append a character to the redo buffer.
594 * Translates special keys, NUL, CSI, K_SPECIAL and multibyte characters.
597 AppendCharToRedobuff(c
)
601 add_char_buff(&redobuff
, c
);
605 * Append a number to the redo buffer.
608 AppendNumberToRedobuff(n
)
612 add_num_buff(&redobuff
, n
);
616 * Append string "s" to the stuff buffer.
617 * CSI and K_SPECIAL must already have been escaped.
623 add_buff(&stuffbuff
, s
, -1L);
627 stuffReadbuffLen(s
, len
)
631 add_buff(&stuffbuff
, s
, len
);
634 #if defined(FEAT_EVAL) || defined(PROTO)
636 * Stuff "s" into the stuff buffer, leaving special key codes unmodified and
637 * escaping other K_SPECIAL and CSI bytes.
645 if (*s
== K_SPECIAL
&& s
[1] != NUL
&& s
[2] != NUL
)
647 /* Insert special key literally. */
648 stuffReadbuffLen(s
, 3L);
653 stuffcharReadbuff(mb_ptr2char_adv(&s
));
655 stuffcharReadbuff(*s
++);
662 * Append a character to the stuff buffer.
663 * Translates special keys, NUL, CSI, K_SPECIAL and multibyte characters.
669 add_char_buff(&stuffbuff
, c
);
673 * Append a number to the stuff buffer.
679 add_num_buff(&stuffbuff
, n
);
683 * Read a character from the redo buffer. Translates K_SPECIAL, CSI and
684 * multibyte characters.
685 * The redo buffer is left as it is.
686 * if init is TRUE, prepare for redo, return FAIL if nothing to redo, OK
688 * if old is TRUE, use old_redobuff instead of redobuff
691 read_redo(init
, old_redo
)
695 static struct buffblock
*bp
;
700 char_u buf
[MB_MAXBYTES
];
707 bp
= old_redobuff
.bh_first
.b_next
;
709 bp
= redobuff
.bh_first
.b_next
;
717 /* Reverse the conversion done by add_char_buff() */
719 /* For a multi-byte character get all the bytes and return the
720 * converted character. */
721 if (has_mbyte
&& (c
!= K_SPECIAL
|| p
[1] == KS_SPECIAL
))
722 n
= MB_BYTE2LEN_CHECK(c
);
728 if (c
== K_SPECIAL
) /* special key or escaped K_SPECIAL */
730 c
= TO_SPECIAL(p
[1], p
[2]);
734 if (c
== CSI
) /* escaped CSI */
737 if (*++p
== NUL
&& bp
->b_next
!= NULL
)
744 if (i
== n
- 1) /* last byte of a character */
747 c
= (*mb_ptr2char
)(buf
);
751 if (c
== NUL
) /* cannot happen? */
761 * Copy the rest of the redo buffer into the stuff buffer (in a slow way).
762 * If old_redo is TRUE, use old_redobuff instead of redobuff.
763 * The escaped K_SPECIAL and CSI are copied without translation.
771 while ((c
= read_redo(FALSE
, old_redo
)) != NUL
)
772 stuffcharReadbuff(c
);
776 * Stuff the redo buffer into the stuffbuff.
777 * Insert the redo count into the command.
778 * If "old_redo" is TRUE, the last but one command is repeated
779 * instead of the last command (inserting text). This is used for
780 * CTRL-O <.> in insert mode
782 * return FAIL for failure, OK otherwise
785 start_redo(count
, old_redo
)
791 /* init the pointers; return if nothing to redo */
792 if (read_redo(TRUE
, old_redo
) == FAIL
)
795 c
= read_redo(FALSE
, old_redo
);
797 /* copy the buffer name, if present */
800 add_buff(&stuffbuff
, (char_u
*)"\"", 1L);
801 c
= read_redo(FALSE
, old_redo
);
803 /* if a numbered buffer is used, increment the number */
804 if (c
>= '1' && c
< '9')
806 add_char_buff(&stuffbuff
, c
);
807 c
= read_redo(FALSE
, old_redo
);
811 if (c
== 'v') /* redo Visual */
813 VIsual
= curwin
->w_cursor
;
814 VIsual_active
= TRUE
;
815 VIsual_select
= FALSE
;
816 VIsual_reselect
= TRUE
;
817 redo_VIsual_busy
= TRUE
;
818 c
= read_redo(FALSE
, old_redo
);
822 /* try to enter the count (in place of a previous count) */
825 while (VIM_ISDIGIT(c
)) /* skip "old" count */
826 c
= read_redo(FALSE
, old_redo
);
827 add_num_buff(&stuffbuff
, count
);
830 /* copy from the redo buffer into the stuff buffer */
831 add_char_buff(&stuffbuff
, c
);
837 * Repeat the last insert (R, o, O, a, A, i or I command) by stuffing
838 * the redo buffer into the stuffbuff.
839 * return FAIL for failure, OK otherwise
846 if (read_redo(TRUE
, FALSE
) == FAIL
)
850 /* skip the count and the command character */
851 while ((c
= read_redo(FALSE
, FALSE
)) != NUL
)
853 if (vim_strchr((char_u
*)"AaIiRrOo", c
) != NULL
)
855 if (c
== 'O' || c
== 'o')
856 stuffReadbuff(NL_STR
);
861 /* copy the typed text from the redo buffer into the stuff buffer */
874 * Initialize typebuf.tb_buf to point to typebuf_init.
875 * alloc() cannot be used here: In out-of-memory situations it would
876 * be impossible to type anything.
881 if (typebuf
.tb_buf
== NULL
)
883 typebuf
.tb_buf
= typebuf_init
;
884 typebuf
.tb_noremap
= noremapbuf_init
;
885 typebuf
.tb_buflen
= TYPELEN_INIT
;
888 typebuf
.tb_change_cnt
= 1;
893 * insert a string in position 'offset' in the typeahead buffer (for "@r"
894 * and ":normal" command, vgetorpeek() and check_termcode())
896 * If noremap is REMAP_YES, new string can be mapped again.
897 * If noremap is REMAP_NONE, new string cannot be mapped again.
898 * If noremap is REMAP_SKIP, fist char of new string cannot be mapped again,
899 * but abbreviations are allowed.
900 * If noremap is REMAP_SCRIPT, new string cannot be mapped again, except for
901 * script-local mappings.
902 * If noremap is > 0, that many characters of the new string cannot be mapped.
904 * If nottyped is TRUE, the string does not return KeyTyped (don't use when
905 * offset is non-zero!).
907 * If silent is TRUE, cmd_silent is set when the characters are obtained.
909 * return FAIL for failure, OK otherwise
912 ins_typebuf(str
, noremap
, offset
, nottyped
, silent
)
928 if (++typebuf
.tb_change_cnt
== 0)
929 typebuf
.tb_change_cnt
= 1;
931 addlen
= (int)STRLEN(str
);
934 * Easy case: there is room in front of typebuf.tb_buf[typebuf.tb_off]
936 if (offset
== 0 && addlen
<= typebuf
.tb_off
)
938 typebuf
.tb_off
-= addlen
;
939 mch_memmove(typebuf
.tb_buf
+ typebuf
.tb_off
, str
, (size_t)addlen
);
943 * Need to allocate a new buffer.
944 * In typebuf.tb_buf there must always be room for 3 * MAXMAPLEN + 4
945 * characters. We add some extra room to avoid having to allocate too
950 newoff
= MAXMAPLEN
+ 4;
951 newlen
= typebuf
.tb_len
+ addlen
+ newoff
+ 4 * (MAXMAPLEN
+ 4);
952 if (newlen
< 0) /* string is getting too long */
954 EMSG(_(e_toocompl
)); /* also calls flush_buffers */
959 if (s1
== NULL
) /* out of memory */
962 if (s2
== NULL
) /* out of memory */
967 typebuf
.tb_buflen
= newlen
;
969 /* copy the old chars, before the insertion point */
970 mch_memmove(s1
+ newoff
, typebuf
.tb_buf
+ typebuf
.tb_off
,
972 /* copy the new chars */
973 mch_memmove(s1
+ newoff
+ offset
, str
, (size_t)addlen
);
974 /* copy the old chars, after the insertion point, including the NUL at
976 mch_memmove(s1
+ newoff
+ offset
+ addlen
,
977 typebuf
.tb_buf
+ typebuf
.tb_off
+ offset
,
978 (size_t)(typebuf
.tb_len
- offset
+ 1));
979 if (typebuf
.tb_buf
!= typebuf_init
)
980 vim_free(typebuf
.tb_buf
);
983 mch_memmove(s2
+ newoff
, typebuf
.tb_noremap
+ typebuf
.tb_off
,
985 mch_memmove(s2
+ newoff
+ offset
+ addlen
,
986 typebuf
.tb_noremap
+ typebuf
.tb_off
+ offset
,
987 (size_t)(typebuf
.tb_len
- offset
));
988 if (typebuf
.tb_noremap
!= noremapbuf_init
)
989 vim_free(typebuf
.tb_noremap
);
990 typebuf
.tb_noremap
= s2
;
992 typebuf
.tb_off
= newoff
;
994 typebuf
.tb_len
+= addlen
;
996 /* If noremap == REMAP_SCRIPT: do remap script-local mappings. */
997 if (noremap
== REMAP_SCRIPT
)
999 else if (noremap
== REMAP_SKIP
)
1005 * Adjust typebuf.tb_noremap[] for the new characters:
1006 * If noremap == REMAP_NONE or REMAP_SCRIPT: new characters are
1007 * (sometimes) not remappable
1008 * If noremap == REMAP_YES: all the new characters are mappable
1009 * If noremap > 0: "noremap" characters are not remappable, the rest
1012 if (noremap
== REMAP_SKIP
)
1014 else if (noremap
< 0)
1018 for (i
= 0; i
< addlen
; ++i
)
1019 typebuf
.tb_noremap
[typebuf
.tb_off
+ i
+ offset
] =
1020 (--nrm
>= 0) ? val
: RM_YES
;
1022 /* tb_maplen and tb_silent only remember the length of mapped and/or
1023 * silent mappings at the start of the buffer, assuming that a mapped
1024 * sequence doesn't result in typed characters. */
1025 if (nottyped
|| typebuf
.tb_maplen
> offset
)
1026 typebuf
.tb_maplen
+= addlen
;
1027 if (silent
|| typebuf
.tb_silent
> offset
)
1029 typebuf
.tb_silent
+= addlen
;
1032 if (typebuf
.tb_no_abbr_cnt
&& offset
== 0) /* and not used for abbrev.s */
1033 typebuf
.tb_no_abbr_cnt
+= addlen
;
1039 * Put character "c" back into the typeahead buffer.
1040 * Can be used for a character obtained by vgetc() that needs to be put back.
1041 * Uses cmd_silent, KeyTyped and KeyNoremap to restore the flags belonging to
1049 char_u buf
[MB_MAXBYTES
];
1056 buf
[1] = K_SECOND(c
);
1057 buf
[2] = K_THIRD(c
);
1063 buf
[(*mb_char2bytes
)(c
, buf
)] = NUL
;
1069 (void)ins_typebuf(buf
, KeyNoremap
, 0, !KeyTyped
, cmd_silent
);
1073 * Return TRUE if the typeahead buffer was changed (while waiting for a
1074 * character to arrive). Happens when a message was received from a client or
1076 * But check in a more generic way to avoid trouble: When "typebuf.tb_buf"
1077 * changed it was reallocated and the old pointer can no longer be used.
1078 * Or "typebuf.tb_off" may have been changed and we would overwrite characters
1079 * that was just added.
1082 typebuf_changed(tb_change_cnt
)
1083 int tb_change_cnt
; /* old value of typebuf.tb_change_cnt */
1085 return (tb_change_cnt
!= 0 && (typebuf
.tb_change_cnt
!= tb_change_cnt
1086 #if defined(FEAT_CLIENTSERVER) || defined(FEAT_EVAL)
1087 || typebuf_was_filled
1093 * Return TRUE if there are no characters in the typeahead buffer that have
1094 * not been typed (result from a mapping or come from ":normal").
1099 return typebuf
.tb_maplen
== 0;
1102 #if defined(FEAT_VISUAL) || defined(PROTO)
1104 * Return the number of characters that are mapped (or not typed).
1109 return typebuf
.tb_maplen
;
1114 * remove "len" characters from typebuf.tb_buf[typebuf.tb_off + offset]
1117 del_typebuf(len
, offset
)
1124 return; /* nothing to do */
1126 typebuf
.tb_len
-= len
;
1129 * Easy case: Just increase typebuf.tb_off.
1131 if (offset
== 0 && typebuf
.tb_buflen
- (typebuf
.tb_off
+ len
)
1132 >= 3 * MAXMAPLEN
+ 3)
1133 typebuf
.tb_off
+= len
;
1135 * Have to move the characters in typebuf.tb_buf[] and typebuf.tb_noremap[]
1139 i
= typebuf
.tb_off
+ offset
;
1141 * Leave some extra room at the end to avoid reallocation.
1143 if (typebuf
.tb_off
> MAXMAPLEN
)
1145 mch_memmove(typebuf
.tb_buf
+ MAXMAPLEN
,
1146 typebuf
.tb_buf
+ typebuf
.tb_off
, (size_t)offset
);
1147 mch_memmove(typebuf
.tb_noremap
+ MAXMAPLEN
,
1148 typebuf
.tb_noremap
+ typebuf
.tb_off
, (size_t)offset
);
1149 typebuf
.tb_off
= MAXMAPLEN
;
1151 /* adjust typebuf.tb_buf (include the NUL at the end) */
1152 mch_memmove(typebuf
.tb_buf
+ typebuf
.tb_off
+ offset
,
1153 typebuf
.tb_buf
+ i
+ len
,
1154 (size_t)(typebuf
.tb_len
- offset
+ 1));
1155 /* adjust typebuf.tb_noremap[] */
1156 mch_memmove(typebuf
.tb_noremap
+ typebuf
.tb_off
+ offset
,
1157 typebuf
.tb_noremap
+ i
+ len
,
1158 (size_t)(typebuf
.tb_len
- offset
));
1161 if (typebuf
.tb_maplen
> offset
) /* adjust tb_maplen */
1163 if (typebuf
.tb_maplen
< offset
+ len
)
1164 typebuf
.tb_maplen
= offset
;
1166 typebuf
.tb_maplen
-= len
;
1168 if (typebuf
.tb_silent
> offset
) /* adjust tb_silent */
1170 if (typebuf
.tb_silent
< offset
+ len
)
1171 typebuf
.tb_silent
= offset
;
1173 typebuf
.tb_silent
-= len
;
1175 if (typebuf
.tb_no_abbr_cnt
> offset
) /* adjust tb_no_abbr_cnt */
1177 if (typebuf
.tb_no_abbr_cnt
< offset
+ len
)
1178 typebuf
.tb_no_abbr_cnt
= offset
;
1180 typebuf
.tb_no_abbr_cnt
-= len
;
1183 #if defined(FEAT_CLIENTSERVER) || defined(FEAT_EVAL)
1184 /* Reset the flag that text received from a client or from feedkeys()
1185 * was inserted in the typeahead buffer. */
1186 typebuf_was_filled
= FALSE
;
1188 if (++typebuf
.tb_change_cnt
== 0)
1189 typebuf
.tb_change_cnt
= 1;
1193 * Write typed characters to script file.
1194 * If recording is on put the character in the recordbuffer.
1197 gotchars(chars
, len
)
1206 /* remember how many chars were last recorded */
1208 last_recorded_len
+= len
;
1213 /* Handle one byte at a time; no translation to be done. */
1220 add_buff(&recordbuff
, buf
, 1L);
1226 /* output "debug mode" message next time in debug mode */
1227 debug_did_msg
= FALSE
;
1230 /* Since characters have been typed, consider the following to be in
1231 * another mapping. Search string will be kept in history. */
1236 * Sync undo. Called when typed characters are obtained from the typeahead
1237 * buffer, or when a menu is used.
1239 * - In Insert mode, unless cursor key has been used.
1240 * - While reading a script file.
1241 * - When no_u_sync is non-zero.
1246 if ((!(State
& (INSERT
+ CMDLINE
)) || arrow_used
)
1247 && scriptin
[curscript
] == NULL
)
1252 * Make "typebuf" empty and allocate new buffers.
1253 * Returns FAIL when out of memory.
1258 typebuf
.tb_buf
= alloc(TYPELEN_INIT
);
1259 typebuf
.tb_noremap
= alloc(TYPELEN_INIT
);
1260 if (typebuf
.tb_buf
== NULL
|| typebuf
.tb_noremap
== NULL
)
1265 typebuf
.tb_buflen
= TYPELEN_INIT
;
1268 typebuf
.tb_maplen
= 0;
1269 typebuf
.tb_silent
= 0;
1270 typebuf
.tb_no_abbr_cnt
= 0;
1271 if (++typebuf
.tb_change_cnt
== 0)
1272 typebuf
.tb_change_cnt
= 1;
1277 * Free the buffers of "typebuf".
1282 if (typebuf
.tb_buf
== typebuf_init
)
1283 EMSG2(_(e_intern2
), "Free typebuf 1");
1285 vim_free(typebuf
.tb_buf
);
1286 if (typebuf
.tb_buf
== noremapbuf_init
)
1287 EMSG2(_(e_intern2
), "Free typebuf 2");
1289 vim_free(typebuf
.tb_noremap
);
1293 * When doing ":so! file", the current typeahead needs to be saved, and
1294 * restored when "file" has been read completely.
1296 static typebuf_T saved_typebuf
[NSCRIPT
];
1302 saved_typebuf
[curscript
] = typebuf
;
1303 /* If out of memory: restore typebuf and close file. */
1304 if (alloc_typebuf() == FAIL
)
1312 static int old_char
= -1; /* character put back by vungetc() */
1313 static int old_mod_mask
; /* mod_mask for ungotten character */
1315 #if defined(FEAT_EVAL) || defined(FEAT_EX_EXTRA) || defined(PROTO)
1318 * Save all three kinds of typeahead, so that the user must type at a prompt.
1324 tp
->save_typebuf
= typebuf
;
1325 tp
->typebuf_valid
= (alloc_typebuf() == OK
);
1326 if (!tp
->typebuf_valid
)
1327 typebuf
= tp
->save_typebuf
;
1329 tp
->old_char
= old_char
;
1330 tp
->old_mod_mask
= old_mod_mask
;
1333 tp
->save_stuffbuff
= stuffbuff
;
1334 stuffbuff
.bh_first
.b_next
= NULL
;
1335 # ifdef USE_INPUT_BUF
1336 tp
->save_inputbuf
= get_input_buf();
1341 * Restore the typeahead to what it was before calling save_typeahead().
1342 * The allocated memory is freed, can only be called once!
1345 restore_typeahead(tp
)
1348 if (tp
->typebuf_valid
)
1351 typebuf
= tp
->save_typebuf
;
1354 old_char
= tp
->old_char
;
1355 old_mod_mask
= tp
->old_mod_mask
;
1357 free_buff(&stuffbuff
);
1358 stuffbuff
= tp
->save_stuffbuff
;
1359 # ifdef USE_INPUT_BUF
1360 set_input_buf(tp
->save_inputbuf
);
1366 * Open a new script file for the ":source!" command.
1369 openscript(name
, directly
)
1371 int directly
; /* when TRUE execute directly */
1373 if (curscript
+ 1 == NSCRIPT
)
1380 /* Not reading from script, also don't open one. Warning message? */
1384 if (scriptin
[curscript
] != NULL
) /* already reading script */
1386 /* use NameBuff for expanded name */
1387 expand_env(name
, NameBuff
, MAXPATHL
);
1388 if ((scriptin
[curscript
] = mch_fopen((char *)NameBuff
, READBIN
)) == NULL
)
1390 EMSG2(_(e_notopen
), name
);
1395 if (save_typebuf() == FAIL
)
1399 * Execute the commands from the file right now when using ":source!"
1400 * after ":global" or ":argdo" or in a loop. Also when another command
1401 * follows. This means the display won't be updated. Don't do this
1402 * always, "make test" would fail.
1408 int save_State
= State
;
1409 int save_restart_edit
= restart_edit
;
1410 int save_insertmode
= p_im
;
1411 int save_finish_op
= finish_op
;
1412 int save_msg_scroll
= msg_scroll
;
1415 msg_scroll
= FALSE
; /* no msg scrolling in Normal mode */
1416 restart_edit
= 0; /* don't go to Insert mode */
1417 p_im
= FALSE
; /* don't use 'insertmode' */
1421 oldcurscript
= curscript
;
1424 update_topline_cursor(); /* update cursor position and topline */
1425 normal_cmd(&oa
, FALSE
); /* execute one command */
1426 vpeekc(); /* check for end of file */
1428 while (scriptin
[oldcurscript
] != NULL
);
1431 msg_scroll
= save_msg_scroll
;
1432 restart_edit
= save_restart_edit
;
1433 p_im
= save_insertmode
;
1434 finish_op
= save_finish_op
;
1439 * Close the currently active input script.
1445 typebuf
= saved_typebuf
[curscript
];
1447 fclose(scriptin
[curscript
]);
1448 scriptin
[curscript
] = NULL
;
1453 #if defined(EXITFREE) || defined(PROTO)
1457 while (scriptin
[0] != NULL
)
1462 #if defined(FEAT_INS_EXPAND) || defined(PROTO)
1464 * Return TRUE when reading keys from a script file.
1469 return scriptin
[curscript
] != NULL
;
1474 * This function is called just before doing a blocking wait. Thus after
1475 * waiting 'updatetime' for a character to arrive.
1482 if (may_garbage_collect
)
1488 * updatescipt() is called when a character can be written into the script file
1489 * or when we have waited some time for a character (c == 0)
1491 * All the changed memfiles are synced if c == 0 or when the number of typed
1492 * characters reaches 'updatecount' and 'updatecount' is non-zero.
1498 static int count
= 0;
1502 if (c
== 0 || (p_uc
> 0 && ++count
>= p_uc
))
1504 ml_sync_all(c
== 0, TRUE
);
1509 #define KL_PART_KEY -1 /* keylen value for incomplete key-code */
1510 #define KL_PART_MAP -2 /* keylen value for incomplete mapping */
1513 * Get the next input character.
1514 * Can return a special key or a multi-byte character.
1515 * Can return NUL when called recursively, use safe_vgetc() if that's not
1517 * This translates escaped K_SPECIAL and CSI bytes to a K_SPECIAL or CSI byte.
1518 * Collects the bytes of a multibyte character into the whole character.
1519 * Returns the modifers in the global "mod_mask".
1527 char_u buf
[MB_MAXBYTES
];
1532 /* Do garbage collection when garbagecollect() was called previously and
1533 * we are now at the toplevel. */
1534 if (may_garbage_collect
&& want_garbage_collect
)
1539 * If a character was put back with vungetc, it was already processed.
1540 * Return it directly.
1546 mod_mask
= old_mod_mask
;
1551 last_recorded_len
= 0;
1552 for (;;) /* this is done twice if there are modifiers */
1554 if (mod_mask
) /* no mapping after modifier has been read */
1559 c
= vgetorpeek(TRUE
);
1566 /* Get two extra bytes for special keys */
1573 int save_allow_keys
= allow_keys
;
1576 allow_keys
= 0; /* make sure BS is not found */
1577 c2
= vgetorpeek(TRUE
); /* no mapping for these chars */
1578 c
= vgetorpeek(TRUE
);
1580 allow_keys
= save_allow_keys
;
1581 if (c2
== KS_MODIFIER
)
1586 c
= TO_SPECIAL(c2
, c
);
1588 #if defined(FEAT_GUI_W32) && defined(FEAT_MENU) && defined(FEAT_TEAROFF)
1589 /* Handle K_TEAROFF here, the caller of vgetc() doesn't need to
1590 * know that a menu was torn off */
1596 /* get menu path, it ends with a <CR> */
1597 for (i
= 0; (c
= vgetorpeek(TRUE
)) != '\r'; )
1604 gui_make_tearoff(name
);
1608 #if defined(FEAT_GUI) && defined(HAVE_GTK2) && defined(FEAT_MENU)
1609 /* GTK: <F10> normally selects the menu, but it's passed until
1610 * here to allow mapping it. Intercept and invoke the GTK
1611 * behavior if it's not mapped. */
1612 if (c
== K_F10
&& gui
.menubar
!= NULL
)
1614 gtk_menu_shell_select_first(GTK_MENU_SHELL(gui
.menubar
), FALSE
);
1619 /* Handle focus event here, so that the caller doesn't need to
1620 * know about it. Return K_IGNORE so that we loop once (needed if
1621 * 'lazyredraw' is set). */
1622 if (c
== K_FOCUSGAINED
|| c
== K_FOCUSLOST
)
1624 ui_focus_change(c
== K_FOCUSGAINED
);
1628 /* Handle redraw event here, this is used by CodeCheck.*/
1629 if (c
== K_REDRAW
) {
1630 /* gui_update_screen() does not work because of
1631 * update_screen(0) inside it. */
1634 update_screen(SOME_VALID
);
1642 /* Translate K_CSI to CSI. The special key is only used to avoid
1643 * it being recognized as the start of a special key. */
1650 * If K_NUL was typed, it is replaced by K_NUL, 3 in mch_inchar().
1651 * Delete the 3 here.
1653 else if (c
== K_NUL
&& vpeekc() == 3)
1654 (void)vgetorpeek(TRUE
);
1657 /* a keypad or special function key was not mapped, use it like
1658 * its ASCII equivalent */
1661 case K_KPLUS
: c
= '+'; break;
1662 case K_KMINUS
: c
= '-'; break;
1663 case K_KDIVIDE
: c
= '/'; break;
1664 case K_KMULTIPLY
: c
= '*'; break;
1665 case K_KENTER
: c
= CAR
; break;
1668 /* Can be either '.' or a ',', *
1669 * depending on the type of keypad. */
1670 c
= MapVirtualKey(VK_DECIMAL
, 2); break;
1674 case K_K0
: c
= '0'; break;
1675 case K_K1
: c
= '1'; break;
1676 case K_K2
: c
= '2'; break;
1677 case K_K3
: c
= '3'; break;
1678 case K_K4
: c
= '4'; break;
1679 case K_K5
: c
= '5'; break;
1680 case K_K6
: c
= '6'; break;
1681 case K_K7
: c
= '7'; break;
1682 case K_K8
: c
= '8'; break;
1683 case K_K9
: c
= '9'; break;
1686 case K_ZHOME
: if (mod_mask
== MOD_MASK_SHIFT
)
1691 else if (mod_mask
== MOD_MASK_CTRL
)
1700 case K_ZEND
: if (mod_mask
== MOD_MASK_SHIFT
)
1705 else if (mod_mask
== MOD_MASK_CTRL
)
1714 case K_XUP
: c
= K_UP
; break;
1715 case K_XDOWN
: c
= K_DOWN
; break;
1716 case K_XLEFT
: c
= K_LEFT
; break;
1717 case K_XRIGHT
: c
= K_RIGHT
; break;
1721 /* For a multi-byte character get all the bytes and return the
1722 * converted character.
1723 * Note: This will loop until enough bytes are received!
1725 if (has_mbyte
&& (n
= MB_BYTE2LEN_CHECK(c
)) > 1)
1729 for (i
= 1; i
< n
; ++i
)
1731 buf
[i
] = vgetorpeek(TRUE
);
1732 if (buf
[i
] == K_SPECIAL
1738 /* Must be a K_SPECIAL - KS_SPECIAL - KE_FILLER sequence,
1739 * which represents a K_SPECIAL (0x80),
1740 * or a CSI - KS_EXTRA - KE_CSI sequence, which represents
1742 * of a K_SPECIAL - KS_EXTRA - KE_CSI, which is CSI too. */
1743 c
= vgetorpeek(TRUE
);
1744 if (vgetorpeek(TRUE
) == (int)KE_CSI
&& c
== KS_EXTRA
)
1749 c
= (*mb_ptr2char
)(buf
);
1759 * In the main loop "may_garbage_collect" can be set to do garbage
1760 * collection in the first next vgetc(). It's disabled after that to
1761 * avoid internally used Lists and Dicts to be freed.
1763 may_garbage_collect
= FALSE
;
1770 * Like vgetc(), but never return a NUL when called recursively, get a key
1771 * directly from the user (ignoring typeahead).
1780 c
= get_keystroke();
1785 * Like safe_vgetc(), but loop to handle K_IGNORE.
1786 * Also ignore scrollbar events.
1796 } while (c
== K_IGNORE
|| c
== K_VER_SCROLLBAR
|| c
== K_HOR_SCROLLBAR
);
1801 * Check if a character is available, such that vgetc() will not block.
1802 * If the next character is a special character or multi-byte, the returned
1803 * character is not valid!.
1810 return vgetorpeek(FALSE
);
1813 #if defined(FEAT_TERMRESPONSE) || defined(PROTO)
1815 * Like vpeekc(), but don't allow mapping. Do allow checking for terminal
1832 #if defined(FEAT_INS_EXPAND) || defined(PROTO)
1834 * Check if any character is available, also half an escape sequence.
1835 * Trick: when no typeahead found, but there is something in the typeahead
1836 * buffer, it must be an ESC that is recognized as the start of a key code.
1844 if (c
== NUL
&& typebuf
.tb_len
> 0)
1851 * Call vpeekc() without causing anything to be mapped.
1852 * Return TRUE if a character is available, FALSE otherwise.
1862 return (retval
!= NUL
);
1866 vungetc(c
) /* unget one character (can only be done once!) */
1870 old_mod_mask
= mod_mask
;
1875 * 1. from the stuffbuffer
1876 * This is used for abbreviated commands like "D" -> "d$".
1877 * Also used to redo a command for ".".
1878 * 2. from the typeahead buffer
1879 * Stores text obtained previously but not used yet.
1880 * Also stores the result of mappings.
1881 * Also used for the ":normal" command.
1883 * This may do a blocking wait if "advance" is TRUE.
1885 * if "advance" is TRUE (vgetc()):
1886 * really get the character.
1887 * KeyTyped is set to TRUE in the case the user typed the key.
1888 * KeyStuffed is TRUE if the character comes from the stuff buffer.
1889 * if "advance" is FALSE (vpeekc()):
1890 * just look whether there is a character available.
1892 * When "no_mapping" is zero, checks for mappings in the current mode.
1893 * Only returns one byte (of a multi-byte character).
1894 * K_SPECIAL and CSI may be escaped, need to get two more bytes then.
1904 #ifdef FEAT_LOCALMAP
1907 mapblock_T
*mp_match
;
1908 int mp_match_len
= 0;
1909 int timedout
= FALSE
; /* waited for more than 1 second
1910 for mapping to complete */
1911 int mapdepth
= 0; /* check for recursive mapping */
1912 int mode_deleted
= FALSE
; /* set when mode has been deleted */
1917 #ifdef FEAT_CMDL_INFO
1918 int new_wcol
, new_wrow
;
1924 int shape_changed
= FALSE
; /* adjusted cursor shape */
1930 int old_wcol
, old_wrow
;
1934 * This function doesn't work very well when called recursively. This may
1935 * happen though, because of:
1936 * 1. The call to add_to_showcmd(). char_avail() is then used to check if
1937 * there is a character available, which calls this function. In that
1938 * case we must return NUL, to indicate no character is available.
1939 * 2. A GUI callback function writes to the screen, causing a
1941 * Using ":normal" can also do this, but it saves the typeahead buffer,
1942 * thus it should be OK. But don't get a key from the user then.
1945 #ifdef FEAT_EX_EXTRA
1946 && ex_normal_busy
== 0
1951 local_State
= get_real_state();
1960 if (advance
&& typebuf
.tb_maplen
== 0)
1965 * get a character: 1. from the stuffbuffer
1967 if (typeahead_char
!= 0)
1974 c
= read_stuff(advance
);
1975 if (c
!= NUL
&& !got_int
)
1979 /* KeyTyped = FALSE; When the command that stuffed something
1980 * was typed, behave like the stuffed command was typed.
1981 * needed for CTRL-W CTRl-] to open a fold, for example. */
1984 if (typebuf
.tb_no_abbr_cnt
== 0)
1985 typebuf
.tb_no_abbr_cnt
= 1; /* no abbreviations now */
1990 * Loop until we either find a matching mapped key, or we
1991 * are sure that it is not a mapped key.
1992 * If a mapped key sequence is found we go back to the start to
1998 * ui_breakcheck() is slow, don't use it too often when
1999 * inside a mapping. But call it each time for typed
2002 if (typebuf
.tb_maplen
)
2005 ui_breakcheck(); /* check for CTRL-C */
2009 /* flush all input */
2010 c
= inchar(typebuf
.tb_buf
, typebuf
.tb_buflen
- 1, 0L,
2011 typebuf
.tb_change_cnt
);
2013 * If inchar() returns TRUE (script file was active) or we
2014 * are inside a mapping, get out of insert mode.
2015 * Otherwise we behave like having gotten a CTRL-C.
2016 * As a result typing CTRL-C in insert mode will
2017 * really insert a CTRL-C.
2019 if ((c
|| typebuf
.tb_maplen
)
2020 && (State
& (INSERT
+ CMDLINE
)))
2024 flush_buffers(TRUE
); /* flush all typeahead */
2028 /* Also record this character, it might be needed to
2029 * get out of Insert mode. */
2030 *typebuf
.tb_buf
= c
;
2031 gotchars(typebuf
.tb_buf
, 1);
2037 else if (typebuf
.tb_len
> 0)
2040 * Check for a mappable key sequence.
2041 * Walk through one maphash[] list until we find an
2042 * entry that matches.
2044 * Don't look for mappings if:
2045 * - no_mapping set: mapping disabled (e.g. for CTRL-V)
2046 * - maphash_valid not set: no mappings present.
2047 * - typebuf.tb_buf[typebuf.tb_off] should not be remapped
2048 * - in insert or cmdline mode and 'paste' option set
2049 * - waiting for "hit return to continue" and CR or SPACE
2051 * - waiting for a char with --more--
2052 * - in Ctrl-X mode, and we get a valid char for that mode
2056 c1
= typebuf
.tb_buf
[typebuf
.tb_off
];
2057 if (no_mapping
== 0 && maphash_valid
2058 && (no_zero_mapping
== 0 || c1
!= '0')
2059 && (typebuf
.tb_maplen
== 0
2061 && (typebuf
.tb_noremap
[typebuf
.tb_off
]
2062 & (RM_NONE
|RM_ABBR
)) == 0))
2063 && !(p_paste
&& (State
& (INSERT
+ CMDLINE
)))
2064 && !(State
== HITRETURN
&& (c1
== CAR
|| c1
== ' '))
2067 #ifdef FEAT_INS_EXPAND
2068 && !((ctrl_x_mode
!= 0 && vim_is_ctrl_x_key(c1
))
2069 || ((compl_cont_status
& CONT_LOCAL
)
2070 && (c1
== Ctrl_N
|| c1
== Ctrl_P
)))
2075 if (c1
== K_SPECIAL
)
2079 LANGMAP_ADJUST(c1
, TRUE
);
2083 #ifdef FEAT_LOCALMAP
2084 /* First try buffer-local mappings. */
2085 mp
= curbuf
->b_maphash
[MAP_HASH(local_State
, c1
)];
2086 mp2
= maphash
[MAP_HASH(local_State
, c1
)];
2093 mp
= maphash
[MAP_HASH(local_State
, c1
)];
2096 * Loop until a partly matching mapping is found or
2097 * all (local) mappings have been checked.
2098 * The longest full match is remembered in "mp_match".
2099 * A full match is only accepted if there is no partly
2100 * match, so "aa" and "aaa" can both be mapped.
2105 #ifdef FEAT_LOCALMAP
2106 mp
->m_next
== NULL
? (mp
= mp2
, mp2
= NULL
) :
2111 * Only consider an entry if the first character
2112 * matches and it is for the current state.
2113 * Skip ":lmap" mappings if keys were mapped.
2115 if (mp
->m_keys
[0] == c1
2116 && (mp
->m_mode
& local_State
)
2117 && ((mp
->m_mode
& LANGMAP
) == 0
2118 || typebuf
.tb_maplen
== 0))
2121 int nomap
= nolmaplen
;
2124 /* find the match length of this mapping */
2125 for (mlen
= 1; mlen
< typebuf
.tb_len
; ++mlen
)
2128 c2
= typebuf
.tb_buf
[typebuf
.tb_off
+ mlen
];
2131 else if (c2
== K_SPECIAL
)
2134 LANGMAP_ADJUST(c2
, TRUE
);
2135 if (mp
->m_keys
[mlen
] != c2
)
2137 if (mp
->m_keys
[mlen
] !=
2138 typebuf
.tb_buf
[typebuf
.tb_off
+ mlen
])
2144 /* Don't allow mapping the first byte(s) of a
2145 * multi-byte char. Happens when mapping
2146 * <M-a> and then changing 'encoding'. */
2147 if (has_mbyte
&& MB_BYTE2LEN(c1
)
2148 > (*mb_ptr2len
)(mp
->m_keys
))
2152 * Check an entry whether it matches.
2153 * - Full match: mlen == keylen
2154 * - Partly match: mlen == typebuf.tb_len
2156 keylen
= mp
->m_keylen
;
2158 || (mlen
== typebuf
.tb_len
2159 && typebuf
.tb_len
< keylen
))
2162 * If only script-local mappings are
2163 * allowed, check if the mapping starts
2166 s
= typebuf
.tb_noremap
+ typebuf
.tb_off
;
2168 && (mp
->m_keys
[0] != K_SPECIAL
2169 || mp
->m_keys
[1] != KS_EXTRA
2174 * If one of the typed keys cannot be
2175 * remapped, skip the entry.
2177 for (n
= mlen
; --n
>= 0; )
2178 if (*s
++ & (RM_NONE
|RM_ABBR
))
2183 if (keylen
> typebuf
.tb_len
)
2187 /* break at a partly match */
2188 keylen
= KL_PART_MAP
;
2192 else if (keylen
> mp_match_len
)
2194 /* found a longer match */
2196 mp_match_len
= keylen
;
2200 /* No match; may have to check for
2201 * termcode at next character. */
2202 if (max_mlen
< mlen
)
2207 /* If no partly match found, use the longest full
2209 if (keylen
!= KL_PART_MAP
)
2212 keylen
= mp_match_len
;
2216 /* Check for match with 'pastetoggle' */
2217 if (*p_pt
!= NUL
&& mp
== NULL
&& (State
& (INSERT
|NORMAL
)))
2219 for (mlen
= 0; mlen
< typebuf
.tb_len
&& p_pt
[mlen
];
2221 if (p_pt
[mlen
] != typebuf
.tb_buf
[typebuf
.tb_off
2224 if (p_pt
[mlen
] == NUL
) /* match */
2226 /* write chars to script file(s) */
2227 if (mlen
> typebuf
.tb_maplen
)
2228 gotchars(typebuf
.tb_buf
+ typebuf
.tb_off
2229 + typebuf
.tb_maplen
,
2230 mlen
- typebuf
.tb_maplen
);
2232 del_typebuf(mlen
, 0); /* remove the chars */
2233 set_option_value((char_u
*)"paste",
2234 (long)!p_paste
, NULL
, 0);
2235 if (!(State
& INSERT
))
2239 msg_clr_eos(); /* clear ruler */
2245 /* Need more chars for partly match. */
2246 if (mlen
== typebuf
.tb_len
)
2247 keylen
= KL_PART_KEY
;
2248 else if (max_mlen
< mlen
)
2249 /* no match, may have to check for termcode at
2251 max_mlen
= mlen
+ 1;
2254 if ((mp
== NULL
|| max_mlen
>= mp_match_len
)
2255 && keylen
!= KL_PART_MAP
)
2257 int save_keylen
= keylen
;
2260 * When no matching mapping found or found a
2261 * non-matching mapping that matches at least what the
2262 * matching mapping matched:
2263 * Check if we have a terminal code, when:
2264 * mapping is allowed,
2265 * keys have not been mapped,
2266 * and not an ESC sequence, not in insert mode or
2268 * and when not timed out,
2270 if ((no_mapping
== 0 || allow_keys
!= 0)
2271 && (typebuf
.tb_maplen
== 0
2272 || (p_remap
&& typebuf
.tb_noremap
[
2273 typebuf
.tb_off
] == RM_YES
))
2276 keylen
= check_termcode(max_mlen
+ 1, NULL
, 0);
2278 /* If no termcode matched but 'pastetoggle'
2279 * matched partially it's like an incomplete key
2281 if (keylen
== 0 && save_keylen
== KL_PART_KEY
)
2282 keylen
= KL_PART_KEY
;
2285 * When getting a partial match, but the last
2286 * characters were not typed, don't wait for a
2287 * typed character to complete the termcode.
2288 * This helps a lot when a ":normal" command ends
2292 && typebuf
.tb_len
== typebuf
.tb_maplen
)
2297 if (keylen
== 0) /* no matching terminal code */
2299 #ifdef AMIGA /* check for window bounds report */
2300 if (typebuf
.tb_maplen
== 0 && (typebuf
.tb_buf
[
2301 typebuf
.tb_off
] & 0xff) == CSI
)
2303 for (s
= typebuf
.tb_buf
+ typebuf
.tb_off
+ 1;
2304 s
< typebuf
.tb_buf
+ typebuf
.tb_off
2306 && (VIM_ISDIGIT(*s
) || *s
== ';'
2310 if (*s
== 'r' || *s
== '|') /* found one */
2312 del_typebuf((int)(s
+ 1 -
2313 (typebuf
.tb_buf
+ typebuf
.tb_off
)), 0);
2314 /* get size and redraw screen */
2318 if (*s
== NUL
) /* need more characters */
2319 keylen
= KL_PART_KEY
;
2323 /* When there was a matching mapping and no
2324 * termcode could be replaced after another one,
2325 * use that mapping (loop around). If there was
2326 * no mapping use the character from the
2327 * typeahead buffer right here. */
2331 * get a character: 2. from the typeahead buffer
2333 c
= typebuf
.tb_buf
[typebuf
.tb_off
] & 255;
2334 if (advance
) /* remove chars from tb_buf */
2336 cmd_silent
= (typebuf
.tb_silent
> 0);
2337 if (typebuf
.tb_maplen
> 0)
2342 /* write char to script file(s) */
2343 gotchars(typebuf
.tb_buf
2344 + typebuf
.tb_off
, 1);
2346 KeyNoremap
= typebuf
.tb_noremap
[
2350 break; /* got character, break for loop */
2353 if (keylen
> 0) /* full matching terminal code */
2355 #if defined(FEAT_GUI) && defined(FEAT_MENU)
2356 if (typebuf
.tb_buf
[typebuf
.tb_off
] == K_SPECIAL
2357 && typebuf
.tb_buf
[typebuf
.tb_off
+ 1]
2361 * Using a menu may cause a break in undo!
2362 * It's like using gotchars(), but without
2363 * recording or writing to a script file.
2367 idx
= get_menu_index(current_menu
, local_State
);
2368 if (idx
!= MENU_INDEX_INVALID
)
2372 * In Select mode and a Visual mode menu
2373 * is used: Switch to Visual mode
2374 * temporarily. Append K_SELECT to switch
2375 * back to Select mode.
2377 if (VIsual_active
&& VIsual_select
2378 && (current_menu
->modes
& VISUAL
))
2380 VIsual_select
= FALSE
;
2381 (void)ins_typebuf(K_SELECT_STRING
,
2382 REMAP_NONE
, 0, TRUE
, FALSE
);
2385 ins_typebuf(current_menu
->strings
[idx
],
2386 current_menu
->noremap
[idx
],
2388 current_menu
->silent
[idx
]);
2391 #endif /* FEAT_GUI && FEAT_MENU */
2392 continue; /* try mapping again */
2395 /* Partial match: get some more characters. When a
2396 * matching mapping was found use that one. */
2397 if (mp
== NULL
|| keylen
< 0)
2398 keylen
= KL_PART_KEY
;
2400 keylen
= mp_match_len
;
2403 /* complete match */
2404 if (keylen
>= 0 && keylen
<= typebuf
.tb_len
)
2406 /* write chars to script file(s) */
2407 if (keylen
> typebuf
.tb_maplen
)
2408 gotchars(typebuf
.tb_buf
+ typebuf
.tb_off
2409 + typebuf
.tb_maplen
,
2410 keylen
- typebuf
.tb_maplen
);
2412 cmd_silent
= (typebuf
.tb_silent
> 0);
2413 del_typebuf(keylen
, 0); /* remove the mapped keys */
2416 * Put the replacement string in front of mapstr.
2417 * The depth check catches ":map x y" and ":map y x".
2419 if (++mapdepth
>= p_mmd
)
2421 EMSG(_("E223: recursive mapping"));
2422 if (State
& CMDLINE
)
2426 flush_buffers(FALSE
);
2427 mapdepth
= 0; /* for next one */
2434 * In Select mode and a Visual mode mapping is used:
2435 * Switch to Visual mode temporarily. Append K_SELECT
2436 * to switch back to Select mode.
2438 if (VIsual_active
&& VIsual_select
2439 && (mp
->m_mode
& VISUAL
))
2441 VIsual_select
= FALSE
;
2442 (void)ins_typebuf(K_SELECT_STRING
, REMAP_NONE
,
2449 * Handle ":map <expr>": evaluate the {rhs} as an
2450 * expression. Save and restore the typeahead so that
2451 * getchar() can be used. Also save and restore the
2452 * command line for "normal :".
2457 int save_vgetc_busy
= vgetc_busy
;
2459 save_typeahead(&tabuf
);
2460 if (tabuf
.typebuf_valid
)
2463 s
= eval_map_expr(mp
->m_str
);
2464 vgetc_busy
= save_vgetc_busy
;
2468 restore_typeahead(&tabuf
);
2475 * Insert the 'to' part in the typebuf.tb_buf.
2476 * If 'from' field is the same as the start of the
2477 * 'to' field, don't remap the first character (but do
2478 * allow abbreviations).
2479 * If m_noremap is set, don't remap the whole 'to'
2487 mp
->m_noremap
!= REMAP_YES
2489 : STRNCMP(s
, mp
->m_keys
,
2490 (size_t)keylen
) != 0
2491 ? REMAP_YES
: REMAP_SKIP
,
2492 0, TRUE
, cmd_silent
|| mp
->m_silent
);
2508 * get a character: 3. from the user - handle <Esc> in Insert mode
2511 * special case: if we get an <ESC> in insert mode and there
2512 * are no more characters at once, we pretend to go out of
2513 * insert mode. This prevents the one second delay after
2514 * typing an <ESC>. If we get something after all, we may
2515 * have to redisplay the mode. That the cursor is in the wrong
2516 * place does not matter.
2519 #ifdef FEAT_CMDL_INFO
2520 new_wcol
= curwin
->w_wcol
;
2521 new_wrow
= curwin
->w_wrow
;
2524 && typebuf
.tb_len
== 1
2525 && typebuf
.tb_buf
[typebuf
.tb_off
] == ESC
2527 #ifdef FEAT_EX_EXTRA
2528 && ex_normal_busy
== 0
2530 && typebuf
.tb_maplen
== 0
2532 && (p_timeout
|| (keylen
== KL_PART_KEY
&& p_ttimeout
))
2533 && (c
= inchar(typebuf
.tb_buf
+ typebuf
.tb_off
2534 + typebuf
.tb_len
, 3, 25L,
2535 typebuf
.tb_change_cnt
)) == 0)
2537 colnr_T col
= 0, vcol
;
2543 mode_deleted
= TRUE
;
2546 /* may show different cursor shape */
2553 gui_update_cursor(TRUE
, FALSE
);
2555 shape_changed
= TRUE
;
2559 old_wcol
= curwin
->w_wcol
;
2560 old_wrow
= curwin
->w_wrow
;
2562 /* move cursor left, if possible */
2563 if (curwin
->w_cursor
.col
!= 0)
2565 if (curwin
->w_wcol
> 0)
2570 * We are expecting to truncate the trailing
2571 * white-space, so find the last non-white
2574 col
= vcol
= curwin
->w_wcol
= 0;
2575 ptr
= ml_get_curline();
2576 while (col
< curwin
->w_cursor
.col
)
2578 if (!vim_iswhite(ptr
[col
]))
2579 curwin
->w_wcol
= vcol
;
2580 vcol
+= lbr_chartabsize(ptr
+ col
,
2584 col
+= (*mb_ptr2len
)(ptr
+ col
);
2589 curwin
->w_wrow
= curwin
->w_cline_row
2590 + curwin
->w_wcol
/ W_WIDTH(curwin
);
2591 curwin
->w_wcol
%= W_WIDTH(curwin
);
2592 curwin
->w_wcol
+= curwin_col_off();
2594 col
= 0; /* no correction needed */
2601 col
= curwin
->w_cursor
.col
- 1;
2605 else if (curwin
->w_p_wrap
&& curwin
->w_wrow
)
2608 curwin
->w_wcol
= W_WIDTH(curwin
) - 1;
2610 col
= curwin
->w_cursor
.col
- 1;
2614 if (has_mbyte
&& col
> 0 && curwin
->w_wcol
> 0)
2616 /* Correct when the cursor is on the right halve
2617 * of a double-wide character. */
2618 ptr
= ml_get_curline();
2619 col
-= (*mb_head_off
)(ptr
, ptr
+ col
);
2620 if ((*mb_ptr2cells
)(ptr
+ col
) > 1)
2627 #ifdef FEAT_CMDL_INFO
2628 new_wcol
= curwin
->w_wcol
;
2629 new_wrow
= curwin
->w_wrow
;
2631 curwin
->w_wcol
= old_wcol
;
2632 curwin
->w_wrow
= old_wrow
;
2635 continue; /* end of input script reached */
2636 typebuf
.tb_len
+= c
;
2638 /* buffer full, don't map */
2639 if (typebuf
.tb_len
>= typebuf
.tb_maplen
+ MAXMAPLEN
)
2645 #ifdef FEAT_EX_EXTRA
2646 if (ex_normal_busy
> 0)
2652 /* No typeahead left and inside ":normal". Must return
2653 * something to avoid getting stuck. When an incomplete
2654 * mapping is present, behave like it timed out. */
2655 if (typebuf
.tb_len
> 0)
2660 /* When 'insertmode' is set, ESC just beeps in Insert
2661 * mode. Use CTRL-L to make edit() return.
2662 * For the command line only CTRL-C always breaks it.
2663 * For the cmdline window: Alternate between ESC and
2664 * CTRL-C: ESC for most situations and CTRL-C to close the
2665 * cmdline window. */
2666 if (p_im
&& (State
& INSERT
))
2668 else if ((State
& CMDLINE
)
2670 || (cmdwin_type
> 0 && tc
== ESC
)
2684 * get a character: 3. from the user - update display
2686 /* In insert mode a screen update is skipped when characters
2687 * are still available. But when those available characters
2688 * are part of a mapping, and we are going to do a blocking
2689 * wait here. Need to update the screen to display the
2690 * changed text so far. */
2691 if ((State
& INSERT
) && advance
&& must_redraw
!= 0)
2694 setcursor(); /* put cursor back where it belongs */
2698 * If we have a partial match (and are going to wait for more
2699 * input from the user), show the partially matched characters
2700 * to the user with showcmd.
2702 #ifdef FEAT_CMDL_INFO
2706 if (typebuf
.tb_len
> 0 && advance
&& !exmode_active
)
2708 if (((State
& (NORMAL
| INSERT
)) || State
== LANGMAP
)
2709 && State
!= HITRETURN
)
2711 /* this looks nice when typing a dead character map */
2713 && ptr2cells(typebuf
.tb_buf
+ typebuf
.tb_off
2714 + typebuf
.tb_len
- 1) == 1)
2716 edit_putchar(typebuf
.tb_buf
[typebuf
.tb_off
2717 + typebuf
.tb_len
- 1], FALSE
);
2718 setcursor(); /* put cursor back where it belongs */
2721 #ifdef FEAT_CMDL_INFO
2722 /* need to use the col and row from above here */
2723 old_wcol
= curwin
->w_wcol
;
2724 old_wrow
= curwin
->w_wrow
;
2725 curwin
->w_wcol
= new_wcol
;
2726 curwin
->w_wrow
= new_wrow
;
2728 if (typebuf
.tb_len
> SHOWCMD_COLS
)
2729 i
= typebuf
.tb_len
- SHOWCMD_COLS
;
2730 while (i
< typebuf
.tb_len
)
2731 (void)add_to_showcmd(typebuf
.tb_buf
[typebuf
.tb_off
2733 curwin
->w_wcol
= old_wcol
;
2734 curwin
->w_wrow
= old_wrow
;
2738 /* this looks nice when typing a dead character map */
2739 if ((State
& CMDLINE
)
2740 #if defined(FEAT_CRYPT) || defined(FEAT_EVAL)
2741 && cmdline_star
== 0
2743 && ptr2cells(typebuf
.tb_buf
+ typebuf
.tb_off
2744 + typebuf
.tb_len
- 1) == 1)
2746 putcmdline(typebuf
.tb_buf
[typebuf
.tb_off
2747 + typebuf
.tb_len
- 1], FALSE
);
2753 * get a character: 3. from the user - get it
2755 wait_tb_len
= typebuf
.tb_len
;
2756 c
= inchar(typebuf
.tb_buf
+ typebuf
.tb_off
+ typebuf
.tb_len
,
2757 typebuf
.tb_buflen
- typebuf
.tb_off
- typebuf
.tb_len
- 1,
2760 : ((typebuf
.tb_len
== 0
2761 || !(p_timeout
|| (p_ttimeout
2762 && keylen
== KL_PART_KEY
)))
2764 : ((keylen
== KL_PART_KEY
&& p_ttm
>= 0)
2766 : p_tm
)), typebuf
.tb_change_cnt
);
2768 #ifdef FEAT_CMDL_INFO
2776 if (State
& CMDLINE
)
2778 setcursor(); /* put cursor back where it belongs */
2782 continue; /* end of input script reached */
2783 if (c
== NUL
) /* no character available */
2787 if (wait_tb_len
> 0) /* timed out */
2794 { /* allow mapping for just typed characters */
2795 while (typebuf
.tb_buf
[typebuf
.tb_off
2796 + typebuf
.tb_len
] != NUL
)
2797 typebuf
.tb_noremap
[typebuf
.tb_off
2798 + typebuf
.tb_len
++] = RM_YES
;
2799 #ifdef USE_IM_CONTROL
2800 /* Get IM status right after getting keys, not after the
2801 * timeout for a mapping (focus may be lost by then). */
2802 vgetc_im_active
= im_get_status();
2806 } /* if (!character from stuffbuf) */
2808 /* if advance is FALSE don't loop on NULs */
2809 } while (c
< 0 || (advance
&& c
== NUL
));
2812 * The "INSERT" message is taken care of here:
2813 * if we return an ESC to exit insert mode, the message is deleted
2814 * if we don't return an ESC but deleted the message before, redisplay it
2816 if (advance
&& p_smd
&& msg_silent
== 0 && (State
& INSERT
))
2818 if (c
== ESC
&& !mode_deleted
&& !no_mapping
&& mode_displayed
)
2820 if (typebuf
.tb_len
&& !KeyTyped
)
2821 redraw_cmdline
= TRUE
; /* delete mode later */
2825 else if (c
!= ESC
&& mode_deleted
)
2827 if (typebuf
.tb_len
&& !KeyTyped
)
2828 redraw_cmdline
= TRUE
; /* show mode later */
2834 /* may unshow different cursor shape */
2835 if (gui
.in_use
&& shape_changed
)
2836 gui_update_cursor(TRUE
, FALSE
);
2845 * inchar() - get one character from
2849 * As much characters as we can get (upto 'maxlen') are put in "buf" and
2850 * NUL terminated (buffer length must be 'maxlen' + 1).
2851 * Minimum for "maxlen" is 3!!!!
2853 * "tb_change_cnt" is the value of typebuf.tb_change_cnt if "buf" points into
2854 * it. When typebuf.tb_change_cnt changes (e.g., when a message is received
2855 * from a remote client) "buf" can no longer be used. "tb_change_cnt" is 0
2858 * If we got an interrupt all input is read until none is available.
2860 * If wait_time == 0 there is no waiting for the char.
2861 * If wait_time == n we wait for n msec for a character to arrive.
2862 * If wait_time == -1 we wait forever for a character to arrive.
2864 * Return the number of obtained characters.
2865 * Return -1 when end of input script reached.
2868 inchar(buf
, maxlen
, wait_time
, tb_change_cnt
)
2871 long wait_time
; /* milli seconds */
2874 int len
= 0; /* init for GCC */
2875 int retesc
= FALSE
; /* return ESC with gotint */
2878 if (wait_time
== -1L || wait_time
> 100L) /* flush output before waiting */
2885 gui_update_cursor(FALSE
, FALSE
);
2886 # ifdef FEAT_MOUSESHAPE
2887 if (postponed_mouseshape
)
2888 update_mouseshape(-1);
2895 * Don't reset these when at the hit-return prompt, otherwise a endless
2896 * recursive loop may result (write error in swapfile, hit-return, timeout
2897 * on char wait, flush swapfile, write error....).
2899 if (State
!= HITRETURN
)
2901 did_outofmem_msg
= FALSE
; /* display out of memory message (again) */
2902 did_swapwrite_msg
= FALSE
; /* display swap file write error again */
2904 undo_off
= FALSE
; /* restart undo now */
2907 * Get a character from a script file if there is one.
2908 * If interrupted: Stop reading script files, close them all.
2911 while (scriptin
[curscript
] != NULL
&& script_char
< 0
2918 #if defined(FEAT_NETBEANS_INTG)
2919 /* Process the queued netbeans messages. */
2920 netbeans_parse_messages();
2923 if (got_int
|| (script_char
= getc(scriptin
[curscript
])) < 0)
2926 * Careful: closescript() frees typebuf.tb_buf[] and buf[] may
2927 * point inside typebuf.tb_buf[]. Don't use buf[] after this! */
2930 * When reading script file is interrupted, return an ESC to get
2931 * back to normal mode.
2932 * Otherwise return -1, because typebuf.tb_buf[] has changed.
2941 buf
[0] = script_char
;
2946 if (script_char
< 0) /* did not get a character from script */
2949 * If we got an interrupt, skip all previously typed characters and
2950 * return TRUE if quit reading script file.
2951 * Stop reading typeahead when a single CTRL-C was read,
2952 * fill_input_buf() returns this when not able to read from stdin.
2953 * Don't use buf[] here, closescript() may have freed typebuf.tb_buf[]
2954 * and buf may be pointing inside typebuf.tb_buf[].
2958 #define DUM_LEN MAXMAPLEN * 3 + 3
2959 char_u dum
[DUM_LEN
+ 1];
2963 len
= ui_inchar(dum
, DUM_LEN
, 0L, 0);
2964 if (len
== 0 || (len
== 1 && dum
[0] == 3))
2971 * Always flush the output characters when getting input characters
2977 * Fill up to a third of the buffer, because each character may be
2980 len
= ui_inchar(buf
, maxlen
/ 3, wait_time
, tb_change_cnt
);
2983 if (typebuf_changed(tb_change_cnt
))
2986 return fix_input_buffer(buf
, len
, script_char
>= 0);
2990 * Fix typed characters for use by vgetc() and check_termcode().
2991 * buf[] must have room to triple the number of bytes!
2992 * Returns the new length.
2995 fix_input_buffer(buf
, len
, script
)
2998 int script
; /* TRUE when reading from a script */
3004 * Two characters are special: NUL and K_SPECIAL.
3005 * When compiled With the GUI CSI is also special.
3006 * Replace NUL by K_SPECIAL KS_ZERO KE_FILLER
3007 * Replace K_SPECIAL by K_SPECIAL KS_SPECIAL KE_FILLER
3008 * Replace CSI by K_SPECIAL KS_EXTRA KE_CSI
3009 * Don't replace K_SPECIAL when reading a script file.
3011 for (i
= len
; --i
>= 0; ++p
)
3014 /* When the GUI is used any character can come after a CSI, don't
3016 if (gui
.in_use
&& p
[0] == CSI
&& i
>= 2)
3021 /* When the GUI is not used CSI needs to be escaped. */
3022 else if (!gui
.in_use
&& p
[0] == CSI
)
3024 mch_memmove(p
+ 3, p
+ 1, (size_t)i
);
3032 if (p
[0] == NUL
|| (p
[0] == K_SPECIAL
&& !script
3034 /* timeout may generate K_CURSORHOLD */
3035 && (i
< 2 || p
[1] != KS_EXTRA
|| p
[2] != (int)KE_CURSORHOLD
)
3037 #if defined(WIN3264) && !defined(FEAT_GUI)
3038 /* Win32 console passes modifiers */
3039 && (i
< 2 || p
[1] != KS_MODIFIER
)
3043 mch_memmove(p
+ 3, p
+ 1, (size_t)i
);
3044 p
[2] = K_THIRD(p
[0]);
3045 p
[1] = K_SECOND(p
[0]);
3051 *p
= NUL
; /* add trailing NUL */
3055 #if defined(USE_INPUT_BUF) || defined(PROTO)
3057 * Return TRUE when bytes are in the input buffer or in the typeahead buffer.
3058 * Normally the input buffer would be sufficient, but the server_to_input_buf()
3059 * or feedkeys() may insert characters in the typeahead buffer while we are
3060 * waiting for input to arrive.
3065 return (!vim_is_input_buf_empty()
3066 # if defined(FEAT_CLIENTSERVER) || defined(FEAT_EVAL)
3067 || typebuf_was_filled
3074 * map[!] : show all key mappings
3075 * map[!] {lhs} : show key mapping for {lhs}
3076 * map[!] {lhs} {rhs} : set key mapping for {lhs} to {rhs}
3077 * noremap[!] {lhs} {rhs} : same, but no remapping for {rhs}
3078 * unmap[!] {lhs} : remove key mapping for {lhs}
3079 * abbr : show all abbreviations
3080 * abbr {lhs} : show abbreviations for {lhs}
3081 * abbr {lhs} {rhs} : set abbreviation for {lhs} to {rhs}
3082 * noreabbr {lhs} {rhs} : same, but no remapping for {rhs}
3083 * unabbr {lhs} : remove abbreviation for {lhs}
3085 * maptype: 0 for :map, 1 for :unmap, 2 for noremap.
3087 * arg is pointer to any arguments. Note: arg cannot be a read-only string,
3088 * it will be modified.
3090 * for :map mode is NORMAL + VISUAL + SELECTMODE + OP_PENDING
3091 * for :map! mode is INSERT + CMDLINE
3092 * for :cmap mode is CMDLINE
3093 * for :imap mode is INSERT
3094 * for :lmap mode is LANGMAP
3095 * for :nmap mode is NORMAL
3096 * for :vmap mode is VISUAL + SELECTMODE
3097 * for :xmap mode is VISUAL
3098 * for :smap mode is SELECTMODE
3099 * for :omap mode is OP_PENDING
3101 * for :abbr mode is INSERT + CMDLINE
3102 * for :iabbr mode is INSERT
3103 * for :cabbr mode is CMDLINE
3105 * Return 0 for success
3106 * 1 for invalid arguments
3109 * 5 for entry not unique
3112 do_map(maptype
, arg
, mode
, abbrev
)
3116 int abbrev
; /* not a mapping but an abbreviation */
3119 mapblock_T
*mp
, **mpp
;
3123 int len
= 0; /* init for GCC */
3128 #ifdef FEAT_LOCALMAP
3129 int did_local
= FALSE
;
3132 char_u
*keys_buf
= NULL
;
3133 char_u
*arg_buf
= NULL
;
3138 mapblock_T
**abbr_table
;
3139 mapblock_T
**map_table
;
3142 int special
= FALSE
;
3149 map_table
= maphash
;
3150 abbr_table
= &first_abbr
;
3152 /* For ":noremap" don't remap, otherwise do remap. */
3154 noremap
= REMAP_NONE
;
3156 noremap
= REMAP_YES
;
3158 /* Accept <buffer>, <silent>, <expr> <script> and <unique> in any order. */
3161 #ifdef FEAT_LOCALMAP
3163 * Check for "<buffer>": mapping local to buffer.
3165 if (STRNCMP(keys
, "<buffer>", 8) == 0)
3167 keys
= skipwhite(keys
+ 8);
3168 map_table
= curbuf
->b_maphash
;
3169 abbr_table
= &curbuf
->b_first_abbr
;
3175 * Check for "<silent>": don't echo commands.
3177 if (STRNCMP(keys
, "<silent>", 8) == 0)
3179 keys
= skipwhite(keys
+ 8);
3185 * Check for "<special>": accept special keys in <>
3187 if (STRNCMP(keys
, "<special>", 9) == 0)
3189 keys
= skipwhite(keys
+ 9);
3196 * Check for "<script>": remap script-local mappings only
3198 if (STRNCMP(keys
, "<script>", 8) == 0)
3200 keys
= skipwhite(keys
+ 8);
3201 noremap
= REMAP_SCRIPT
;
3206 * Check for "<expr>": {rhs} is an expression.
3208 if (STRNCMP(keys
, "<expr>", 6) == 0)
3210 keys
= skipwhite(keys
+ 6);
3216 * Check for "<unique>": don't overwrite an existing mapping.
3218 if (STRNCMP(keys
, "<unique>", 8) == 0)
3220 keys
= skipwhite(keys
+ 8);
3230 * find end of keys and skip CTRL-Vs (and backslashes) in it
3231 * Accept backslash like CTRL-V when 'cpoptions' does not contain 'B'.
3232 * with :unmap white space is included in the keys, no argument possible
3235 do_backslash
= (vim_strchr(p_cpo
, CPO_BSLASH
) == NULL
);
3236 while (*p
&& (maptype
== 1 || !vim_iswhite(*p
)))
3238 if ((p
[0] == Ctrl_V
|| (do_backslash
&& p
[0] == '\\')) &&
3240 ++p
; /* skip CTRL-V or backslash */
3247 hasarg
= (*rhs
!= NUL
);
3248 haskey
= (*keys
!= NUL
);
3250 /* check for :unmap without argument */
3251 if (maptype
== 1 && !haskey
)
3258 * If mapping has been given as ^V<C_UP> say, then replace the term codes
3259 * with the appropriate two bytes. If it is a shifted special key, unshift
3260 * it too, giving another two bytes.
3261 * replace_termcodes() may move the result to allocated memory, which
3262 * needs to be freed later (*keys_buf and *arg_buf).
3263 * replace_termcodes() also removes CTRL-Vs and sometimes backslashes.
3266 keys
= replace_termcodes(keys
, &keys_buf
, TRUE
, TRUE
, special
);
3269 if (STRICMP(rhs
, "<nop>") == 0) /* "<Nop>" means nothing */
3272 rhs
= replace_termcodes(rhs
, &arg_buf
, FALSE
, TRUE
, special
);
3277 * when in right-to-left mode and alternate keymap option set,
3278 * reverse the character flow in the rhs in Farsi.
3280 if (p_altkeymap
&& curwin
->w_p_rl
)
3285 * check arguments and translate function keys
3289 len
= (int)STRLEN(keys
);
3290 if (len
> MAXMAPLEN
) /* maximum length of MAXMAPLEN chars */
3296 if (abbrev
&& maptype
!= 1)
3299 * If an abbreviation ends in a keyword character, the
3300 * rest must be all keyword-char or all non-keyword-char.
3301 * Otherwise we won't be able to find the start of it in a
3302 * vi-compatible way.
3310 first
= vim_iswordp(keys
);
3312 p
= keys
+ (*mb_ptr2len
)(keys
);
3314 while (p
< keys
+ len
)
3316 ++n
; /* nr of (multi-byte) chars */
3317 last
= vim_iswordp(p
); /* type of last char */
3318 if (same
== -1 && last
!= first
)
3319 same
= n
- 1; /* count of same char type */
3320 p
+= (*mb_ptr2len
)(p
);
3322 if (last
&& n
> 2 && same
>= 0 && same
< n
- 1)
3330 if (vim_iswordc(keys
[len
- 1])) /* ends in keyword char */
3331 for (n
= 0; n
< len
- 2; ++n
)
3332 if (vim_iswordc(keys
[n
]) != vim_iswordc(keys
[len
- 2]))
3337 /* An abbrevation cannot contain white space. */
3338 for (n
= 0; n
< len
; ++n
)
3339 if (vim_iswhite(keys
[n
]))
3347 if (haskey
&& hasarg
&& abbrev
) /* if we will add an abbreviation */
3348 no_abbr
= FALSE
; /* reset flag that indicates there are
3351 if (!haskey
|| (maptype
!= 1 && !hasarg
))
3354 #ifdef FEAT_LOCALMAP
3356 * Check if a new local mapping wasn't already defined globally.
3358 if (map_table
== curbuf
->b_maphash
&& haskey
&& hasarg
&& maptype
!= 1)
3360 /* need to loop over all global hash lists */
3361 for (hash
= 0; hash
< 256 && !got_int
; ++hash
)
3365 if (hash
!= 0) /* there is only one abbreviation list */
3371 for ( ; mp
!= NULL
&& !got_int
; mp
= mp
->m_next
)
3373 /* check entries with the same mode */
3374 if ((mp
->m_mode
& mode
) != 0
3375 && mp
->m_keylen
== len
3377 && STRNCMP(mp
->m_keys
, keys
, (size_t)len
) == 0)
3380 EMSG2(_("E224: global abbreviation already exists for %s"),
3383 EMSG2(_("E225: global mapping already exists for %s"),
3393 * When listing global mappings, also list buffer-local ones here.
3395 if (map_table
!= curbuf
->b_maphash
&& !hasarg
&& maptype
!= 1)
3397 /* need to loop over all global hash lists */
3398 for (hash
= 0; hash
< 256 && !got_int
; ++hash
)
3402 if (hash
!= 0) /* there is only one abbreviation list */
3404 mp
= curbuf
->b_first_abbr
;
3407 mp
= curbuf
->b_maphash
[hash
];
3408 for ( ; mp
!= NULL
&& !got_int
; mp
= mp
->m_next
)
3410 /* check entries with the same mode */
3411 if ((mp
->m_mode
& mode
) != 0)
3413 if (!haskey
) /* show all entries */
3421 if (STRNCMP(mp
->m_keys
, keys
,
3422 (size_t)(n
< len
? n
: len
)) == 0)
3435 * Find an entry in the maphash[] list that matches.
3436 * For :unmap we may loop two times: once to try to unmap an entry with a
3437 * matching 'from' part, a second time, if the first fails, to unmap an
3438 * entry with a matching 'to' part. This was done to allow ":ab foo bar"
3439 * to be unmapped by typing ":unab foo", where "foo" will be replaced by
3440 * "bar" because of the abbreviation.
3442 for (round
= 0; (round
== 0 || maptype
== 1) && round
<= 1
3443 && !did_it
&& !got_int
; ++round
)
3445 /* need to loop over all hash lists */
3446 for (hash
= 0; hash
< 256 && !got_int
; ++hash
)
3450 if (hash
> 0) /* there is only one abbreviation list */
3455 mpp
= &(map_table
[hash
]);
3456 for (mp
= *mpp
; mp
!= NULL
&& !got_int
; mp
= *mpp
)
3459 if (!(mp
->m_mode
& mode
)) /* skip entries with wrong mode */
3461 mpp
= &(mp
->m_next
);
3464 if (!haskey
) /* show all entries */
3466 showmap(mp
, map_table
!= maphash
);
3469 else /* do we have a match? */
3471 if (round
) /* second round: Try unmap "rhs" string */
3473 n
= (int)STRLEN(mp
->m_str
);
3481 if (STRNCMP(p
, keys
, (size_t)(n
< len
? n
: len
)) == 0)
3483 if (maptype
== 1) /* delete entry */
3485 /* Only accept a full match. For abbreviations we
3486 * ignore trailing space when matching with the
3487 * "lhs", since an abbreviation can't have
3488 * trailing space. */
3489 if (n
!= len
&& (!abbrev
|| round
|| n
> len
3490 || *skipwhite(keys
+ n
) != NUL
))
3492 mpp
= &(mp
->m_next
);
3496 * We reset the indicated mode bits. If nothing is
3497 * left the entry is deleted below.
3499 mp
->m_mode
&= ~mode
;
3500 did_it
= TRUE
; /* remember we did something */
3502 else if (!hasarg
) /* show matching entry */
3504 showmap(mp
, map_table
!= maphash
);
3507 else if (n
!= len
) /* new entry is ambiguous */
3509 mpp
= &(mp
->m_next
);
3515 EMSG2(_("E226: abbreviation already exists for %s"),
3518 EMSG2(_("E227: mapping already exists for %s"), p
);
3522 else /* new rhs for existing entry */
3524 mp
->m_mode
&= ~mode
; /* remove mode bits */
3525 if (mp
->m_mode
== 0 && !did_it
) /* reuse entry */
3527 newstr
= vim_strsave(rhs
);
3530 retval
= 4; /* no mem */
3533 vim_free(mp
->m_str
);
3535 mp
->m_noremap
= noremap
;
3536 mp
->m_silent
= silent
;
3540 mp
->m_script_ID
= current_SID
;
3545 if (mp
->m_mode
== 0) /* entry can be deleted */
3548 continue; /* continue with *mpp */
3552 * May need to put this entry into another hash list.
3554 new_hash
= MAP_HASH(mp
->m_mode
, mp
->m_keys
[0]);
3555 if (!abbrev
&& new_hash
!= hash
)
3558 mp
->m_next
= map_table
[new_hash
];
3559 map_table
[new_hash
] = mp
;
3561 continue; /* continue with *mpp */
3565 mpp
= &(mp
->m_next
);
3570 if (maptype
== 1) /* delete entry */
3573 retval
= 2; /* no match */
3577 if (!haskey
|| !hasarg
) /* print entries */
3580 #ifdef FEAT_LOCALMAP
3586 MSG(_("No abbreviation found"));
3588 MSG(_("No mapping found"));
3590 goto theend
; /* listing finished */
3593 if (did_it
) /* have added the new entry already */
3597 * Get here when adding a new entry to the maphash[] list or abbrlist.
3599 mp
= (mapblock_T
*)alloc((unsigned)sizeof(mapblock_T
));
3602 retval
= 4; /* no mem */
3606 /* If CTRL-C has been mapped, don't always use it for Interrupting */
3607 if (*keys
== Ctrl_C
)
3608 mapped_ctrl_c
= TRUE
;
3610 mp
->m_keys
= vim_strsave(keys
);
3611 mp
->m_str
= vim_strsave(rhs
);
3612 if (mp
->m_keys
== NULL
|| mp
->m_str
== NULL
)
3614 vim_free(mp
->m_keys
);
3615 vim_free(mp
->m_str
);
3617 retval
= 4; /* no mem */
3620 mp
->m_keylen
= (int)STRLEN(mp
->m_keys
);
3621 mp
->m_noremap
= noremap
;
3622 mp
->m_silent
= silent
;
3626 mp
->m_script_ID
= current_SID
;
3629 /* add the new entry in front of the abbrlist or maphash[] list */
3632 mp
->m_next
= *abbr_table
;
3637 n
= MAP_HASH(mp
->m_mode
, mp
->m_keys
[0]);
3638 mp
->m_next
= map_table
[n
];
3649 * Delete one entry from the abbrlist or maphash[].
3650 * "mpp" is a pointer to the m_next field of the PREVIOUS entry!
3659 vim_free(mp
->m_keys
);
3660 vim_free(mp
->m_str
);
3666 * Initialize maphash[] for first use.
3673 vim_memset(maphash
, 0, sizeof(maphash
));
3674 maphash_valid
= TRUE
;
3679 * Get the mapping mode from the command name.
3682 get_map_mode(cmdp
, forceit
)
3693 mode
= INSERT
; /* :imap */
3694 else if (modec
== 'l')
3695 mode
= LANGMAP
; /* :lmap */
3696 else if (modec
== 'c')
3697 mode
= CMDLINE
; /* :cmap */
3698 else if (modec
== 'n' && *p
!= 'o') /* avoid :noremap */
3699 mode
= NORMAL
; /* :nmap */
3700 else if (modec
== 'v')
3701 mode
= VISUAL
+ SELECTMODE
; /* :vmap */
3702 else if (modec
== 'x')
3703 mode
= VISUAL
; /* :xmap */
3704 else if (modec
== 's')
3705 mode
= SELECTMODE
; /* :smap */
3706 else if (modec
== 'o')
3707 mode
= OP_PENDING
; /* :omap */
3712 mode
= INSERT
+ CMDLINE
; /* :map ! */
3714 mode
= VISUAL
+ SELECTMODE
+ NORMAL
+ OP_PENDING
;/* :map */
3722 * Clear all mappings or abbreviations.
3723 * 'abbr' should be FALSE for mappings, TRUE for abbreviations.
3726 map_clear(cmdp
, arg
, forceit
, abbr
)
3733 #ifdef FEAT_LOCALMAP
3736 local
= (STRCMP(arg
, "<buffer>") == 0);
3737 if (!local
&& *arg
!= NUL
)
3744 mode
= get_map_mode(&cmdp
, forceit
);
3745 map_clear_int(curbuf
, mode
,
3746 #ifdef FEAT_LOCALMAP
3755 * Clear all mappings in "mode".
3758 map_clear_int(buf
, mode
, local
, abbr
)
3759 buf_T
*buf UNUSED
; /* buffer for local mappings */
3760 int mode
; /* mode in which to delete */
3761 int local UNUSED
; /* TRUE for buffer-local mappings */
3762 int abbr
; /* TRUE for abbreviations */
3764 mapblock_T
*mp
, **mpp
;
3770 for (hash
= 0; hash
< 256; ++hash
)
3774 if (hash
> 0) /* there is only one abbrlist */
3776 #ifdef FEAT_LOCALMAP
3778 mpp
= &buf
->b_first_abbr
;
3785 #ifdef FEAT_LOCALMAP
3787 mpp
= &buf
->b_maphash
[hash
];
3790 mpp
= &maphash
[hash
];
3792 while (*mpp
!= NULL
)
3795 if (mp
->m_mode
& mode
)
3797 mp
->m_mode
&= ~mode
;
3798 if (mp
->m_mode
== 0) /* entry can be deleted */
3804 * May need to put this entry into another hash list.
3806 new_hash
= MAP_HASH(mp
->m_mode
, mp
->m_keys
[0]);
3807 if (!abbr
&& new_hash
!= hash
)
3810 #ifdef FEAT_LOCALMAP
3813 mp
->m_next
= buf
->b_maphash
[new_hash
];
3814 buf
->b_maphash
[new_hash
] = mp
;
3819 mp
->m_next
= maphash
[new_hash
];
3820 maphash
[new_hash
] = mp
;
3822 continue; /* continue with *mpp */
3825 mpp
= &(mp
->m_next
);
3833 int local
; /* TRUE for buffer-local map */
3837 if (msg_didout
|| msg_silent
!= 0)
3840 if (got_int
) /* 'q' typed at MORE prompt */
3843 if ((mp
->m_mode
& (INSERT
+ CMDLINE
)) == INSERT
+ CMDLINE
)
3844 msg_putchar('!'); /* :map! */
3845 else if (mp
->m_mode
& INSERT
)
3846 msg_putchar('i'); /* :imap */
3847 else if (mp
->m_mode
& LANGMAP
)
3848 msg_putchar('l'); /* :lmap */
3849 else if (mp
->m_mode
& CMDLINE
)
3850 msg_putchar('c'); /* :cmap */
3851 else if ((mp
->m_mode
& (NORMAL
+ VISUAL
+ SELECTMODE
+ OP_PENDING
))
3852 == NORMAL
+ VISUAL
+ SELECTMODE
+ OP_PENDING
)
3853 msg_putchar(' '); /* :map */
3857 if (mp
->m_mode
& NORMAL
)
3859 msg_putchar('n'); /* :nmap */
3862 if (mp
->m_mode
& OP_PENDING
)
3864 msg_putchar('o'); /* :omap */
3867 if ((mp
->m_mode
& (VISUAL
+ SELECTMODE
)) == VISUAL
+ SELECTMODE
)
3869 msg_putchar('v'); /* :vmap */
3874 if (mp
->m_mode
& VISUAL
)
3876 msg_putchar('x'); /* :xmap */
3879 if (mp
->m_mode
& SELECTMODE
)
3881 msg_putchar('s'); /* :smap */
3889 /* Display the LHS. Get length of what we write. */
3890 len
= msg_outtrans_special(mp
->m_keys
, TRUE
);
3893 msg_putchar(' '); /* padd with blanks */
3897 if (mp
->m_noremap
== REMAP_NONE
)
3898 msg_puts_attr((char_u
*)"*", hl_attr(HLF_8
));
3899 else if (mp
->m_noremap
== REMAP_SCRIPT
)
3900 msg_puts_attr((char_u
*)"&", hl_attr(HLF_8
));
3909 /* Use FALSE below if we only want things like <Up> to show up as such on
3910 * the rhs, and not M-x etc, TRUE gets both -- webb
3912 if (*mp
->m_str
== NUL
)
3913 msg_puts_attr((char_u
*)"<Nop>", hl_attr(HLF_8
));
3915 msg_outtrans_special(mp
->m_str
, FALSE
);
3918 last_set_msg(mp
->m_script_ID
);
3920 out_flush(); /* show one line at a time */
3923 #if defined(FEAT_EVAL) || defined(PROTO)
3925 * Return TRUE if a map exists that has "str" in the rhs for mode "modechars".
3926 * Recognize termcap codes in "str".
3927 * Also checks mappings local to the current buffer.
3930 map_to_exists(str
, modechars
, abbr
)
3940 rhs
= replace_termcodes(str
, &buf
, FALSE
, TRUE
, FALSE
);
3942 if (vim_strchr(modechars
, 'n') != NULL
)
3944 if (vim_strchr(modechars
, 'v') != NULL
)
3945 mode
|= VISUAL
+ SELECTMODE
;
3946 if (vim_strchr(modechars
, 'x') != NULL
)
3948 if (vim_strchr(modechars
, 's') != NULL
)
3950 if (vim_strchr(modechars
, 'o') != NULL
)
3952 if (vim_strchr(modechars
, 'i') != NULL
)
3954 if (vim_strchr(modechars
, 'l') != NULL
)
3956 if (vim_strchr(modechars
, 'c') != NULL
)
3959 retval
= map_to_exists_mode(rhs
, mode
, abbr
);
3967 * Return TRUE if a map exists that has "str" in the rhs for mode "mode".
3968 * Also checks mappings local to the current buffer.
3971 map_to_exists_mode(rhs
, mode
, abbr
)
3978 # ifdef FEAT_LOCALMAP
3979 int expand_buffer
= FALSE
;
3983 /* Do it twice: once for global maps and once for local maps. */
3987 for (hash
= 0; hash
< 256; ++hash
)
3991 if (hash
> 0) /* there is only one abbr list */
3993 #ifdef FEAT_LOCALMAP
3995 mp
= curbuf
->b_first_abbr
;
4000 # ifdef FEAT_LOCALMAP
4001 else if (expand_buffer
)
4002 mp
= curbuf
->b_maphash
[hash
];
4006 for (; mp
; mp
= mp
->m_next
)
4008 if ((mp
->m_mode
& mode
)
4009 && strstr((char *)mp
->m_str
, (char *)rhs
) != NULL
)
4013 # ifdef FEAT_LOCALMAP
4016 expand_buffer
= TRUE
;
4023 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
4025 * Used below when expanding mapping/abbreviation names.
4027 static int expand_mapmodes
= 0;
4028 static int expand_isabbrev
= 0;
4029 #ifdef FEAT_LOCALMAP
4030 static int expand_buffer
= FALSE
;
4034 * Work out what to complete when doing command line completion of mapping
4035 * or abbreviation names.
4038 set_context_in_map_cmd(xp
, cmd
, arg
, forceit
, isabbrev
, isunmap
, cmdidx
)
4042 int forceit
; /* TRUE if '!' given */
4043 int isabbrev
; /* TRUE if abbreviation */
4044 int isunmap
; /* TRUE if unmap/unabbrev command */
4047 if (forceit
&& cmdidx
!= CMD_map
&& cmdidx
!= CMD_unmap
)
4048 xp
->xp_context
= EXPAND_NOTHING
;
4052 expand_mapmodes
= get_map_mode(&cmd
, forceit
|| isabbrev
);
4055 expand_mapmodes
= INSERT
+ CMDLINE
;
4057 expand_mapmodes
+= VISUAL
+ SELECTMODE
+ NORMAL
+ OP_PENDING
;
4059 expand_isabbrev
= isabbrev
;
4060 xp
->xp_context
= EXPAND_MAPPINGS
;
4061 #ifdef FEAT_LOCALMAP
4062 expand_buffer
= FALSE
;
4066 #ifdef FEAT_LOCALMAP
4067 if (STRNCMP(arg
, "<buffer>", 8) == 0)
4069 expand_buffer
= TRUE
;
4070 arg
= skipwhite(arg
+ 8);
4074 if (STRNCMP(arg
, "<unique>", 8) == 0)
4076 arg
= skipwhite(arg
+ 8);
4079 if (STRNCMP(arg
, "<silent>", 8) == 0)
4081 arg
= skipwhite(arg
+ 8);
4085 if (STRNCMP(arg
, "<script>", 8) == 0)
4087 arg
= skipwhite(arg
+ 8);
4090 if (STRNCMP(arg
, "<expr>", 6) == 0)
4092 arg
= skipwhite(arg
+ 6);
4098 xp
->xp_pattern
= arg
;
4105 * Find all mapping/abbreviation names that match regexp 'prog'.
4106 * For command line expansion of ":[un]map" and ":[un]abbrev" in all modes.
4107 * Return OK if matches found, FAIL otherwise.
4110 ExpandMappings(regmatch
, num_file
, file
)
4111 regmatch_T
*regmatch
;
4124 *num_file
= 0; /* return values in case of FAIL */
4128 * round == 1: Count the matches.
4129 * round == 2: Build the array to keep the matches.
4131 for (round
= 1; round
<= 2; ++round
)
4135 for (i
= 0; i
< 5; ++i
)
4138 p
= (char_u
*)"<silent>";
4140 p
= (char_u
*)"<unique>";
4143 p
= (char_u
*)"<script>";
4145 p
= (char_u
*)"<expr>";
4147 #ifdef FEAT_LOCALMAP
4148 else if (i
== 4 && !expand_buffer
)
4149 p
= (char_u
*)"<buffer>";
4154 if (vim_regexec(regmatch
, p
, (colnr_T
)0))
4159 (*file
)[count
++] = vim_strsave(p
);
4163 for (hash
= 0; hash
< 256; ++hash
)
4165 if (expand_isabbrev
)
4167 if (hash
> 0) /* only one abbrev list */
4168 break; /* for (hash) */
4171 #ifdef FEAT_LOCALMAP
4172 else if (expand_buffer
)
4173 mp
= curbuf
->b_maphash
[hash
];
4177 for (; mp
; mp
= mp
->m_next
)
4179 if (mp
->m_mode
& expand_mapmodes
)
4181 p
= translate_mapping(mp
->m_keys
, TRUE
);
4182 if (p
!= NULL
&& vim_regexec(regmatch
, p
, (colnr_T
)0))
4188 (*file
)[count
++] = p
;
4197 if (count
== 0) /* no match found */
4198 break; /* for (round) */
4202 *file
= (char_u
**)alloc((unsigned)(count
* sizeof(char_u
*)));
4214 /* Sort the matches */
4215 sort_strings(*file
, count
);
4217 /* Remove multiple entries */
4220 ptr3
= ptr1
+ count
;
4224 if (STRCMP(*ptr1
, *ptr2
))
4235 return (count
== 0 ? FAIL
: OK
);
4237 #endif /* FEAT_CMDL_COMPL */
4240 * Check for an abbreviation.
4241 * Cursor is at ptr[col]. When inserting, mincol is where insert started.
4242 * "c" is the character typed before check_abbr was called. It may have
4243 * ABBR_OFF added to avoid prepending a CTRL-V to it.
4245 * Historic vi practice: The last character of an abbreviation must be an id
4246 * character ([a-zA-Z0-9_]). The characters in front of it must be all id
4247 * characters or all non-id characters. This allows for abbr. "#i" to
4250 * Vim addition: Allow for abbreviations that end in a non-keyword character.
4251 * Then there must be white space before the abbr.
4253 * return TRUE if there is an abbreviation, FALSE if not
4256 check_abbr(c
, ptr
, col
, mincol
)
4263 int scol
; /* starting column of the abbr. */
4267 char_u tb
[MB_MAXBYTES
+ 4];
4272 #ifdef FEAT_LOCALMAP
4276 int clen
= 0; /* length in characters */
4281 if (typebuf
.tb_no_abbr_cnt
) /* abbrev. are not recursive */
4283 if ((KeyNoremap
& (RM_NONE
|RM_SCRIPT
)) != 0)
4284 /* no remapping implies no abbreviation */
4288 * Check for word before the cursor: If it ends in a keyword char all
4289 * chars before it must be al keyword chars or non-keyword chars, but not
4290 * white space. If it ends in a non-keyword char we accept any characters
4291 * before it except white space.
4293 if (col
== 0) /* cannot be an abbr. */
4301 p
= mb_prevptr(ptr
, ptr
+ col
);
4302 if (!vim_iswordp(p
))
4303 vim_abbr
= TRUE
; /* Vim added abbr. */
4306 vim_abbr
= FALSE
; /* vi compatible abbr. */
4308 is_id
= vim_iswordp(mb_prevptr(ptr
, p
));
4311 while (p
> ptr
+ mincol
)
4313 p
= mb_prevptr(ptr
, p
);
4314 if (vim_isspace(*p
) || (!vim_abbr
&& is_id
!= vim_iswordp(p
)))
4316 p
+= (*mb_ptr2len
)(p
);
4321 scol
= (int)(p
- ptr
);
4326 if (!vim_iswordc(ptr
[col
- 1]))
4327 vim_abbr
= TRUE
; /* Vim added abbr. */
4330 vim_abbr
= FALSE
; /* vi compatible abbr. */
4332 is_id
= vim_iswordc(ptr
[col
- 2]);
4334 for (scol
= col
- 1; scol
> 0 && !vim_isspace(ptr
[scol
- 1])
4335 && (vim_abbr
|| is_id
== vim_iswordc(ptr
[scol
- 1])); --scol
)
4341 if (scol
< col
) /* there is a word in front of the cursor */
4345 #ifdef FEAT_LOCALMAP
4346 mp
= curbuf
->b_first_abbr
;
4357 #ifdef FEAT_LOCALMAP
4358 mp
->m_next
== NULL
? (mp
= mp2
, mp2
= NULL
) :
4362 /* find entries with right mode and keys */
4363 if ( (mp
->m_mode
& State
)
4364 && mp
->m_keylen
== len
4365 && !STRNCMP(mp
->m_keys
, ptr
, (size_t)len
))
4372 * Insert the rest of the abbreviation in typebuf.tb_buf[].
4373 * This goes from end to start.
4375 * Characters 0x000 - 0x100: normal chars, may need CTRL-V,
4376 * except K_SPECIAL: Becomes K_SPECIAL KS_SPECIAL KE_FILLER
4377 * Characters where IS_SPECIAL() == TRUE: key codes, need
4378 * K_SPECIAL. Other characters (with ABBR_OFF): don't use CTRL-V.
4380 * Character CTRL-] is treated specially - it completes the
4381 * abbreviation, but is not inserted into the input stream.
4384 /* special key code, split up */
4387 if (IS_SPECIAL(c
) || c
== K_SPECIAL
)
4389 tb
[j
++] = K_SPECIAL
;
4390 tb
[j
++] = K_SECOND(c
);
4391 tb
[j
++] = K_THIRD(c
);
4395 if (c
< ABBR_OFF
&& (c
< ' ' || c
> '~'))
4396 tb
[j
++] = Ctrl_V
; /* special char needs CTRL-V */
4400 /* if ABBR_OFF has been added, remove it here */
4403 j
+= (*mb_char2bytes
)(c
, tb
+ j
);
4410 /* insert the last typed char */
4411 (void)ins_typebuf(tb
, 1, 0, TRUE
, mp
->m_silent
);
4415 s
= eval_map_expr(mp
->m_str
);
4421 /* insert the to string */
4422 (void)ins_typebuf(s
, mp
->m_noremap
, 0, TRUE
, mp
->m_silent
);
4423 /* no abbrev. for these chars */
4424 typebuf
.tb_no_abbr_cnt
+= (int)STRLEN(s
) + j
+ 1;
4435 len
= clen
; /* Delete characters instead of bytes */
4437 while (len
-- > 0) /* delete the from string */
4438 (void)ins_typebuf(tb
, 1, 0, TRUE
, mp
->m_silent
);
4447 * Evaluate the RHS of a mapping or abbreviations and take care of escaping
4448 * special characters.
4459 save_cmd
= save_cmdline_alloc();
4460 if (save_cmd
== NULL
)
4463 /* Forbid changing text or using ":normal" to avoid most of the bad side
4464 * effects. Also restore the cursor position. */
4466 #ifdef FEAT_EX_EXTRA
4469 save_cursor
= curwin
->w_cursor
;
4470 p
= eval_to_string(str
, NULL
, FALSE
);
4472 #ifdef FEAT_EX_EXTRA
4475 curwin
->w_cursor
= save_cursor
;
4477 restore_cmdline_alloc(save_cmd
);
4480 res
= vim_strsave_escape_csi(p
);
4488 * Copy "p" to allocated memory, escaping K_SPECIAL and CSI so that the result
4489 * can be put in the typeahead buffer.
4490 * Returns NULL when out of memory.
4493 vim_strsave_escape_csi(p
)
4499 /* Need a buffer to hold up to three times as much. */
4500 res
= alloc((unsigned)(STRLEN(p
) * 3) + 1);
4504 for (s
= p
; *s
!= NUL
; )
4506 if (s
[0] == K_SPECIAL
&& s
[1] != NUL
&& s
[2] != NUL
)
4508 /* Copy special key unmodified. */
4515 /* Add character, possibly multi-byte to destination, escaping
4516 * CSI and K_SPECIAL. */
4517 d
= add_char2buf(PTR2CHAR(s
), d
);
4527 * Remove escaping from CSI and K_SPECIAL characters. Reverse of
4528 * vim_strsave_escape_csi(). Works in-place.
4534 char_u
*s
= p
, *d
= p
;
4538 if (s
[0] == K_SPECIAL
&& s
[1] == KS_SPECIAL
&& s
[2] == KE_FILLER
)
4543 else if ((s
[0] == K_SPECIAL
|| s
[0] == CSI
)
4544 && s
[1] == KS_EXTRA
&& s
[2] == (int)KE_CSI
)
4556 * Write map commands for the current mappings to an .exrc file.
4557 * Return FAIL on error, OK otherwise.
4562 buf_T
*buf
; /* buffer for local mappings or NULL */
4570 int did_cpo
= FALSE
;
4576 * Do the loop twice: Once for mappings, once for abbreviations.
4577 * Then loop over all map hash lists.
4579 for (abbr
= 0; abbr
< 2; ++abbr
)
4580 for (hash
= 0; hash
< 256; ++hash
)
4584 if (hash
> 0) /* there is only one abbr list */
4586 #ifdef FEAT_LOCALMAP
4588 mp
= buf
->b_first_abbr
;
4595 #ifdef FEAT_LOCALMAP
4597 mp
= buf
->b_maphash
[hash
];
4603 for ( ; mp
; mp
= mp
->m_next
)
4605 /* skip script-local mappings */
4606 if (mp
->m_noremap
== REMAP_SCRIPT
)
4609 /* skip mappings that contain a <SNR> (script-local thing),
4610 * they probably don't work when loaded again */
4611 for (p
= mp
->m_str
; *p
!= NUL
; ++p
)
4612 if (p
[0] == K_SPECIAL
&& p
[1] == KS_EXTRA
4613 && p
[2] == (int)KE_SNR
)
4618 /* It's possible to create a mapping and then ":unmap" certain
4619 * modes. We recreate this here by mapping the individual
4620 * modes, which requires up to three of them. */
4630 case NORMAL
+ VISUAL
+ SELECTMODE
+ OP_PENDING
:
4644 case NORMAL
+ VISUAL
:
4648 case NORMAL
+ SELECTMODE
:
4652 case NORMAL
+ OP_PENDING
:
4656 case VISUAL
+ SELECTMODE
:
4659 case VISUAL
+ OP_PENDING
:
4663 case SELECTMODE
+ OP_PENDING
:
4667 case NORMAL
+ VISUAL
+ SELECTMODE
:
4671 case NORMAL
+ VISUAL
+ OP_PENDING
:
4676 case NORMAL
+ SELECTMODE
+ OP_PENDING
:
4681 case VISUAL
+ SELECTMODE
+ OP_PENDING
:
4685 case CMDLINE
+ INSERT
:
4699 EMSG(_("E228: makemap: Illegal mode"));
4702 do /* do this twice if c2 is set, 3 times with c3 */
4704 /* When outputting <> form, need to make sure that 'cpo'
4705 * is set to the Vim default. */
4708 if (*mp
->m_str
== NUL
) /* will use <Nop> */
4711 for (i
= 0; i
< 2; ++i
)
4712 for (p
= (i
? mp
->m_str
: mp
->m_keys
); *p
; ++p
)
4713 if (*p
== K_SPECIAL
|| *p
== NL
)
4717 if (fprintf(fd
, "let s:cpo_save=&cpo") < 0
4719 || fprintf(fd
, "set cpo&vim") < 0
4724 if (c1
&& putc(c1
, fd
) < 0)
4726 if (mp
->m_noremap
!= REMAP_YES
&& fprintf(fd
, "nore") < 0)
4728 if (fputs(cmd
, fd
) < 0)
4730 if (buf
!= NULL
&& fputs(" <buffer>", fd
) < 0)
4732 if (mp
->m_silent
&& fputs(" <silent>", fd
) < 0)
4735 if (mp
->m_noremap
== REMAP_SCRIPT
4736 && fputs("<script>", fd
) < 0)
4738 if (mp
->m_expr
&& fputs(" <expr>", fd
) < 0)
4742 if ( putc(' ', fd
) < 0
4743 || put_escstr(fd
, mp
->m_keys
, 0) == FAIL
4744 || putc(' ', fd
) < 0
4745 || put_escstr(fd
, mp
->m_str
, 1) == FAIL
4751 } while (c1
!= NUL
);
4756 if (fprintf(fd
, "let &cpo=s:cpo_save") < 0
4758 || fprintf(fd
, "unlet s:cpo_save") < 0
4765 * write escape string to file
4766 * "what": 0 for :map lhs, 1 for :map rhs, 2 for :set
4768 * return FAIL for failure, OK otherwise
4771 put_escstr(fd
, strstart
, what
)
4776 char_u
*str
= strstart
;
4781 if (*str
== NUL
&& what
== 1)
4783 if (fprintf(fd
, "<Nop>") < 0)
4788 for ( ; *str
!= NUL
; ++str
)
4793 /* Check for a multi-byte character, which may contain escaped
4794 * K_SPECIAL and CSI bytes */
4795 p
= mb_unescape(&str
);
4799 if (fputc(*p
++, fd
) < 0)
4808 * Special key codes have to be translated to be able to make sense
4809 * when they are read back.
4811 if (c
== K_SPECIAL
&& what
!= 2)
4814 if (str
[1] == KS_MODIFIER
)
4822 c
= TO_SPECIAL(str
[1], str
[2]);
4825 if (IS_SPECIAL(c
) || modifiers
) /* special key */
4827 if (fputs((char *)get_special_key_name(c
, modifiers
), fd
) < 0)
4834 * A '\n' in a map command should be written as <NL>.
4835 * A '\n' in a set command should be written as \^V^J.
4841 if (fprintf(fd
, IF_EB("\\\026\n", "\\" CTRL_V_STR
"\n")) < 0)
4846 if (fprintf(fd
, "<NL>") < 0)
4853 * Some characters have to be escaped with CTRL-V to
4854 * prevent them from misinterpreted in DoOneCmd().
4855 * A space, Tab and '"' has to be escaped with a backslash to
4856 * prevent it to be misinterpreted in do_set().
4857 * A space has to be escaped with a CTRL-V when it's at the start of a
4859 * A '<' has to be escaped with a CTRL-V to prevent it being
4860 * interpreted as the start of a special key name.
4861 * A space in the lhs of a :map needs a CTRL-V.
4863 if (what
== 2 && (vim_iswhite(c
) || c
== '"' || c
== '\\'))
4865 if (putc('\\', fd
) < 0)
4868 else if (c
< ' ' || c
> '~' || c
== '|'
4869 || (what
== 0 && c
== ' ')
4870 || (what
== 1 && str
== strstart
&& c
== ' ')
4871 || (what
!= 2 && c
== '<'))
4873 if (putc(Ctrl_V
, fd
) < 0)
4876 if (putc(c
, fd
) < 0)
4883 * Check all mappings for the presence of special key codes.
4884 * Used after ":set term=xxx".
4887 check_map_keycodes()
4896 #ifdef FEAT_LOCALMAP
4901 save_name
= sourcing_name
;
4902 sourcing_name
= (char_u
*)"mappings"; /* avoids giving error messages */
4904 #ifdef FEAT_LOCALMAP
4905 /* This this once for each buffer, and then once for global
4906 * mappings/abbreviations with bp == NULL */
4907 for (bp
= firstbuf
; ; bp
= bp
->b_next
)
4911 * Do the loop twice: Once for mappings, once for abbreviations.
4912 * Then loop over all map hash lists.
4914 for (abbr
= 0; abbr
<= 1; ++abbr
)
4915 for (hash
= 0; hash
< 256; ++hash
)
4919 if (hash
) /* there is only one abbr list */
4921 #ifdef FEAT_LOCALMAP
4923 mp
= bp
->b_first_abbr
;
4930 #ifdef FEAT_LOCALMAP
4932 mp
= bp
->b_maphash
[hash
];
4937 for ( ; mp
!= NULL
; mp
= mp
->m_next
)
4939 for (i
= 0; i
<= 1; ++i
) /* do this twice */
4942 p
= mp
->m_keys
; /* once for the "from" part */
4944 p
= mp
->m_str
; /* and once for the "to" part */
4947 if (*p
== K_SPECIAL
)
4950 if (*p
< 128) /* for "normal" tcap entries */
4955 (void)add_termcap_entry(buf
, FALSE
);
4964 #ifdef FEAT_LOCALMAP
4969 sourcing_name
= save_name
;
4974 * Check the string "keys" against the lhs of all mappings
4975 * Return pointer to rhs of mapping (mapblock->m_str)
4979 check_map(keys
, mode
, exact
, ign_mod
, abbr
)
4982 int exact
; /* require exact match */
4983 int ign_mod
; /* ignore preceding modifier */
4984 int abbr
; /* do abbreviations */
4990 #ifdef FEAT_LOCALMAP
4996 len
= (int)STRLEN(keys
);
4997 #ifdef FEAT_LOCALMAP
4998 for (local
= 1; local
>= 0; --local
)
5000 /* loop over all hash lists */
5001 for (hash
= 0; hash
< 256; ++hash
)
5005 if (hash
> 0) /* there is only one list. */
5007 #ifdef FEAT_LOCALMAP
5009 mp
= curbuf
->b_first_abbr
;
5014 #ifdef FEAT_LOCALMAP
5016 mp
= curbuf
->b_maphash
[hash
];
5020 for ( ; mp
!= NULL
; mp
= mp
->m_next
)
5022 /* skip entries with wrong mode, wrong length and not matching
5024 if ((mp
->m_mode
& mode
) && (!exact
|| mp
->m_keylen
== len
))
5026 if (len
> mp
->m_keylen
)
5027 minlen
= mp
->m_keylen
;
5031 if (ign_mod
&& s
[0] == K_SPECIAL
&& s
[1] == KS_MODIFIER
5035 if (len
> mp
->m_keylen
- 3)
5036 minlen
= mp
->m_keylen
- 3;
5038 if (STRNCMP(s
, keys
, minlen
) == 0)
5048 #if defined(MSDOS) || defined(MSWIN) || defined(OS2) || defined(MACOS)
5050 #define VIS_SEL (VISUAL+SELECTMODE) /* abbreviation */
5053 * Default mappings for some often used keys.
5055 static struct initmap
5061 #if defined(MSDOS) || defined(MSWIN) || defined(OS2)
5062 /* Use the Windows (CUA) keybindings. */
5064 # if 0 /* These are now used to move tab pages */
5065 {(char_u
*)"<C-PageUp> H", NORMAL
+VIS_SEL
},
5066 {(char_u
*)"<C-PageUp> <C-O>H",INSERT
},
5067 {(char_u
*)"<C-PageDown> L$", NORMAL
+VIS_SEL
},
5068 {(char_u
*)"<C-PageDown> <C-O>L<C-O>$", INSERT
},
5071 /* paste, copy and cut */
5072 {(char_u
*)"<S-Insert> \"*P", NORMAL
},
5073 {(char_u
*)"<S-Insert> \"-d\"*P", VIS_SEL
},
5074 {(char_u
*)"<S-Insert> <C-R><C-O>*", INSERT
+CMDLINE
},
5075 {(char_u
*)"<C-Insert> \"*y", VIS_SEL
},
5076 {(char_u
*)"<S-Del> \"*d", VIS_SEL
},
5077 {(char_u
*)"<C-Del> \"*d", VIS_SEL
},
5078 {(char_u
*)"<C-X> \"*d", VIS_SEL
},
5079 /* Missing: CTRL-C (cancel) and CTRL-V (block selection) */
5081 # if 0 /* These are now used to move tab pages */
5082 {(char_u
*)"\316\204 H", NORMAL
+VIS_SEL
}, /* CTRL-PageUp is "H" */
5083 {(char_u
*)"\316\204 \017H",INSERT
}, /* CTRL-PageUp is "^OH"*/
5084 {(char_u
*)"\316v L$", NORMAL
+VIS_SEL
}, /* CTRL-PageDown is "L$" */
5085 {(char_u
*)"\316v \017L\017$", INSERT
}, /* CTRL-PageDown ="^OL^O$"*/
5087 {(char_u
*)"\316w <C-Home>", NORMAL
+VIS_SEL
},
5088 {(char_u
*)"\316w <C-Home>", INSERT
+CMDLINE
},
5089 {(char_u
*)"\316u <C-End>", NORMAL
+VIS_SEL
},
5090 {(char_u
*)"\316u <C-End>", INSERT
+CMDLINE
},
5092 /* paste, copy and cut */
5093 # ifdef FEAT_CLIPBOARD
5095 {(char_u
*)"\316\122 \"*P", NORMAL
}, /* SHIFT-Insert is "*P */
5096 {(char_u
*)"\316\122 \"-d\"*P", VIS_SEL
}, /* SHIFT-Insert is "-d"*P */
5097 {(char_u
*)"\316\122 \022\017*", INSERT
}, /* SHIFT-Insert is ^R^O* */
5098 {(char_u
*)"\316\222 \"*y", VIS_SEL
}, /* CTRL-Insert is "*y */
5099 # if 0 /* Shift-Del produces the same code as Del */
5100 {(char_u
*)"\316\123 \"*d", VIS_SEL
}, /* SHIFT-Del is "*d */
5102 {(char_u
*)"\316\223 \"*d", VIS_SEL
}, /* CTRL-Del is "*d */
5103 {(char_u
*)"\030 \"-d", VIS_SEL
}, /* CTRL-X is "-d */
5105 {(char_u
*)"\316\324 \"*P", NORMAL
}, /* SHIFT-Insert is "*P */
5106 {(char_u
*)"\316\324 \"-d\"*P", VIS_SEL
}, /* SHIFT-Insert is "-d"*P */
5107 {(char_u
*)"\316\324 \022\017*", INSERT
}, /* SHIFT-Insert is ^R^O* */
5108 {(char_u
*)"\316\325 \"*y", VIS_SEL
}, /* CTRL-Insert is "*y */
5109 {(char_u
*)"\316\327 \"*d", VIS_SEL
}, /* SHIFT-Del is "*d */
5110 {(char_u
*)"\316\330 \"*d", VIS_SEL
}, /* CTRL-Del is "*d */
5111 {(char_u
*)"\030 \"-d", VIS_SEL
}, /* CTRL-X is "-d */
5114 {(char_u
*)"\316\324 P", NORMAL
}, /* SHIFT-Insert is P */
5115 {(char_u
*)"\316\324 \"-dP", VIS_SEL
}, /* SHIFT-Insert is "-dP */
5116 {(char_u
*)"\316\324 \022\017\"", INSERT
}, /* SHIFT-Insert is ^R^O" */
5117 {(char_u
*)"\316\325 y", VIS_SEL
}, /* CTRL-Insert is y */
5118 {(char_u
*)"\316\327 d", VIS_SEL
}, /* SHIFT-Del is d */
5119 {(char_u
*)"\316\330 d", VIS_SEL
}, /* CTRL-Del is d */
5125 /* Use the Standard MacOS binding. */
5126 /* paste, copy and cut */
5127 {(char_u
*)"<D-v> \"*P", NORMAL
},
5128 {(char_u
*)"<D-v> \"-d\"*P", VIS_SEL
},
5129 {(char_u
*)"<D-v> <C-R>*", INSERT
+CMDLINE
},
5130 {(char_u
*)"<D-c> \"*y", VIS_SEL
},
5131 {(char_u
*)"<D-x> \"*d", VIS_SEL
},
5132 {(char_u
*)"<Backspace> \"-d", VIS_SEL
},
5140 * Set up default mappings.
5145 #if defined(MSDOS) || defined(MSWIN) || defined(OS2) || defined(MACOS)
5148 for (i
= 0; i
< sizeof(initmappings
) / sizeof(struct initmap
); ++i
)
5149 add_map(initmappings
[i
].arg
, initmappings
[i
].mode
);
5153 #if defined(MSDOS) || defined(MSWIN) || defined(OS2) \
5154 || defined(FEAT_CMDWIN) || defined(MACOS) || defined(PROTO)
5156 * Add a mapping "map" for mode "mode".
5157 * Need to put string in allocated memory, because do_map() will modify it.
5165 char_u
*cpo_save
= p_cpo
;
5167 p_cpo
= (char_u
*)""; /* Allow <> notation */
5168 s
= vim_strsave(map
);
5171 (void)do_map(0, s
, mode
, FALSE
);