Google Git
Sign in
fuchsia / third_party / vim / 5803ae6c076b1d61381afe27fcdedac61dd2cda9 / . / src / getchar.c
blob: b39e64d97a1ea064a0dcfee3479b1bb2217359c4 [file] [log] [blame]
/* vi:set ts=8 sts=4 sw=4:
*
* VIM - Vi IMproved by Bram Moolenaar
*
* Do ":help uganda" in Vim to read copying and usage conditions.
* Do ":help credits" in Vim to see a list of people who contributed.
* See README.txt for an overview of the Vim source code.
*/
/*
* getchar.c
*
* functions related with getting a character from the user/mapping/redo/...
*
* manipulations with redo buffer and stuff buffer
* mappings and abbreviations
*/
#include "vim.h"
/*
* These buffers are used for storing:
* - stuffed characters: A command that is translated into another command.
* - redo characters: will redo the last change.
* - recorded characters: for the "q" command.
*
* The bytes are stored like in the typeahead buffer:
* - K_SPECIAL introduces a special key (two more bytes follow). A literal
* K_SPECIAL is stored as K_SPECIAL KS_SPECIAL KE_FILLER.
* - CSI introduces a GUI termcap code (also when gui.in_use is FALSE,
* otherwise switching the GUI on would make mappings invalid).
* A literal CSI is stored as CSI KS_EXTRA KE_CSI.
* These translations are also done on multi-byte characters!
*
* Escaping CSI bytes is done by the system-specific input functions, called
* by ui_inchar().
* Escaping K_SPECIAL is done by inchar().
* Un-escaping is done by vgetc().
*/
#define MINIMAL_SIZE 20 /* minimal size for b_str */
static buffheader_T redobuff = {{NULL, {NUL}}, NULL, 0, 0};
static buffheader_T old_redobuff = {{NULL, {NUL}}, NULL, 0, 0};
#if defined(FEAT_AUTOCMD) || defined(FEAT_EVAL) || defined(PROTO)
static buffheader_T save_redobuff = {{NULL, {NUL}}, NULL, 0, 0};
static buffheader_T save_old_redobuff = {{NULL, {NUL}}, NULL, 0, 0};
#endif
static buffheader_T recordbuff = {{NULL, {NUL}}, NULL, 0, 0};
static int typeahead_char = 0; /* typeahead char that's not flushed */
/*
* when block_redo is TRUE redo buffer will not be changed
* used by edit() to repeat insertions and 'V' command for redoing
*/
static int block_redo = FALSE;
/*
* Make a hash value for a mapping.
* "mode" is the lower 4 bits of the State for the mapping.
* "c1" is the first character of the "lhs".
* Returns a value between 0 and 255, index in maphash.
* Put Normal/Visual mode mappings mostly separately from Insert/Cmdline mode.
*/
#define MAP_HASH(mode, c1) (((mode) & (NORMAL + VISUAL + SELECTMODE + OP_PENDING)) ? (c1) : ((c1) ^ 0x80))
/*
* Each mapping is put in one of the 256 hash lists, to speed up finding it.
*/
static mapblock_T *(maphash[256]);
static int maphash_valid = FALSE;
/*
* List used for abbreviations.
*/
static mapblock_T *first_abbr = NULL; /* first entry in abbrlist */
static int KeyNoremap = 0; /* remapping flags */
/*
* variables used by vgetorpeek() and flush_buffers()
*
* typebuf.tb_buf[] contains all characters that are not consumed yet.
* typebuf.tb_buf[typebuf.tb_off] is the first valid character.
* typebuf.tb_buf[typebuf.tb_off + typebuf.tb_len - 1] is the last valid char.
* typebuf.tb_buf[typebuf.tb_off + typebuf.tb_len] must be NUL.
* The head of the buffer may contain the result of mappings, abbreviations
* and @a commands. The length of this part is typebuf.tb_maplen.
* typebuf.tb_silent is the part where <silent> applies.
* After the head are characters that come from the terminal.
* typebuf.tb_no_abbr_cnt is the number of characters in typebuf.tb_buf that
* should not be considered for abbreviations.
* Some parts of typebuf.tb_buf may not be mapped. These parts are remembered
* in typebuf.tb_noremap[], which is the same length as typebuf.tb_buf and
* contains RM_NONE for the characters that are not to be remapped.
* typebuf.tb_noremap[typebuf.tb_off] is the first valid flag.
* (typebuf has been put in globals.h, because check_termcode() needs it).
*/
#define RM_YES 0 /* tb_noremap: remap */
#define RM_NONE 1 /* tb_noremap: don't remap */
#define RM_SCRIPT 2 /* tb_noremap: remap local script mappings */
#define RM_ABBR 4 /* tb_noremap: don't remap, do abbrev. */
/* typebuf.tb_buf has three parts: room in front (for result of mappings), the
* middle for typeahead and room for new characters (which needs to be 3 *
* MAXMAPLEN) for the Amiga).
*/
#define TYPELEN_INIT (5 * (MAXMAPLEN + 3))
static char_u typebuf_init[TYPELEN_INIT]; /* initial typebuf.tb_buf */
static char_u noremapbuf_init[TYPELEN_INIT]; /* initial typebuf.tb_noremap */
static int last_recorded_len = 0; /* number of last recorded chars */
static char_u *get_buffcont __ARGS((buffheader_T *, int));
static void add_buff __ARGS((buffheader_T *, char_u *, long n));
static void add_num_buff __ARGS((buffheader_T *, long));
static void add_char_buff __ARGS((buffheader_T *, int));
static int read_readbuffers __ARGS((int advance));
static int read_readbuf __ARGS((buffheader_T *buf, int advance));
static void start_stuff __ARGS((void));
static int read_redo __ARGS((int, int));
static void copy_redo __ARGS((int));
static void init_typebuf __ARGS((void));
static void gotchars __ARGS((char_u *, int));
static void may_sync_undo __ARGS((void));
static void closescript __ARGS((void));
static int vgetorpeek __ARGS((int));
static void map_free __ARGS((mapblock_T **));
static void validate_maphash __ARGS((void));
static void showmap __ARGS((mapblock_T *mp, int local));
#ifdef FEAT_EVAL
static char_u *eval_map_expr __ARGS((char_u *str, int c));
#endif
/*
* Free and clear a buffer.
*/
void
free_buff(buf)
buffheader_T *buf;
{
buffblock_T *p, *np;
for (p = buf->bh_first.b_next; p != NULL; p = np)
{
np = p->b_next;
vim_free(p);
}
buf->bh_first.b_next = NULL;
}
/*
* Return the contents of a buffer as a single string.
* K_SPECIAL and CSI in the returned string are escaped.
*/
static char_u *
get_buffcont(buffer, dozero)
buffheader_T *buffer;
int dozero; /* count == zero is not an error */
{
long_u count = 0;
char_u *p = NULL;
char_u *p2;
char_u *str;
buffblock_T *bp;
/* compute the total length of the string */
for (bp = buffer->bh_first.b_next; bp != NULL; bp = bp->b_next)
count += (long_u)STRLEN(bp->b_str);
if ((count || dozero) && (p = lalloc(count + 1, TRUE)) != NULL)
{
p2 = p;
for (bp = buffer->bh_first.b_next; bp != NULL; bp = bp->b_next)
for (str = bp->b_str; *str; )
*p2++ = *str++;
*p2 = NUL;
}
return (p);
}
/*
* Return the contents of the record buffer as a single string
* and clear the record buffer.
* K_SPECIAL and CSI in the returned string are escaped.
*/
char_u *
get_recorded()
{
char_u *p;
size_t len;
p = get_buffcont(&recordbuff, TRUE);
free_buff(&recordbuff);
/*
* Remove the characters that were added the last time, these must be the
* (possibly mapped) characters that stopped the recording.
*/
len = STRLEN(p);
if ((int)len >= last_recorded_len)
{
len -= last_recorded_len;
p[len] = NUL;
}
/*
* When stopping recording from Insert mode with CTRL-O q, also remove the
* CTRL-O.
*/
if (len > 0 && restart_edit != 0 && p[len - 1] == Ctrl_O)
p[len - 1] = NUL;
return (p);
}
/*
* Return the contents of the redo buffer as a single string.
* K_SPECIAL and CSI in the returned string are escaped.
*/
char_u *
get_inserted()
{
return get_buffcont(&redobuff, FALSE);
}
/*
* Add string "s" after the current block of buffer "buf".
* K_SPECIAL and CSI should have been escaped already.
*/
static void
add_buff(buf, s, slen)
buffheader_T *buf;
char_u *s;
long slen; /* length of "s" or -1 */
{
buffblock_T *p;
long_u len;
if (slen < 0)
slen = (long)STRLEN(s);
if (slen == 0) /* don't add empty strings */
return;
if (buf->bh_first.b_next == NULL) /* first add to list */
{
buf->bh_space = 0;
buf->bh_curr = &(buf->bh_first);
}
else if (buf->bh_curr == NULL) /* buffer has already been read */
{
EMSG(_("E222: Add to read buffer"));
return;
}
else if (buf->bh_index != 0)
mch_memmove(buf->bh_first.b_next->b_str,
buf->bh_first.b_next->b_str + buf->bh_index,
STRLEN(buf->bh_first.b_next->b_str + buf->bh_index) + 1);
buf->bh_index = 0;
if (buf->bh_space >= (int)slen)
{
len = (long_u)STRLEN(buf->bh_curr->b_str);
vim_strncpy(buf->bh_curr->b_str + len, s, (size_t)slen);
buf->bh_space -= slen;
}
else
{
if (slen < MINIMAL_SIZE)
len = MINIMAL_SIZE;
else
len = slen;
p = (buffblock_T *)lalloc((long_u)(sizeof(buffblock_T) + len),
TRUE);
if (p == NULL)
return; /* no space, just forget it */
buf->bh_space = (int)(len - slen);
vim_strncpy(p->b_str, s, (size_t)slen);
p->b_next = buf->bh_curr->b_next;
buf->bh_curr->b_next = p;
buf->bh_curr = p;
}
return;
}
/*
* Add number "n" to buffer "buf".
*/
static void
add_num_buff(buf, n)
buffheader_T *buf;
long n;
{
char_u number[32];
sprintf((char *)number, "%ld", n);
add_buff(buf, number, -1L);
}
/*
* Add character 'c' to buffer "buf".
* Translates special keys, NUL, CSI, K_SPECIAL and multibyte characters.
*/
static void
add_char_buff(buf, c)
buffheader_T *buf;
int c;
{
#ifdef FEAT_MBYTE
char_u bytes[MB_MAXBYTES + 1];
int len;
int i;
#endif
char_u temp[4];
#ifdef FEAT_MBYTE
if (IS_SPECIAL(c))
len = 1;
else
len = (*mb_char2bytes)(c, bytes);
for (i = 0; i < len; ++i)
{
if (!IS_SPECIAL(c))
c = bytes[i];
#endif
if (IS_SPECIAL(c) || c == K_SPECIAL || c == NUL)
{
/* translate special key code into three byte sequence */
temp[0] = K_SPECIAL;
temp[1] = K_SECOND(c);
temp[2] = K_THIRD(c);
temp[3] = NUL;
}
#ifdef FEAT_GUI
else if (c == CSI)
{
/* Translate a CSI to a CSI - KS_EXTRA - KE_CSI sequence */
temp[0] = CSI;
temp[1] = KS_EXTRA;
temp[2] = (int)KE_CSI;
temp[3] = NUL;
}
#endif
else
{
temp[0] = c;
temp[1] = NUL;
}
add_buff(buf, temp, -1L);
#ifdef FEAT_MBYTE
}
#endif
}
/* First read ahead buffer. Used for translated commands. */
static buffheader_T readbuf1 = {{NULL, {NUL}}, NULL, 0, 0};
/* Second read ahead buffer. Used for redo. */
static buffheader_T readbuf2 = {{NULL, {NUL}}, NULL, 0, 0};
/*
* Get one byte from the read buffers. Use readbuf1 one first, use readbuf2
* if that one is empty.
* If advance == TRUE go to the next char.
* No translation is done K_SPECIAL and CSI are escaped.
*/
static int
read_readbuffers(advance)
int advance;
{
int c;
c = read_readbuf(&readbuf1, advance);
if (c == NUL)
c = read_readbuf(&readbuf2, advance);
return c;
}
static int
read_readbuf(buf, advance)
buffheader_T *buf;
int advance;
{
char_u c;
buffblock_T *curr;
if (buf->bh_first.b_next == NULL) /* buffer is empty */
return NUL;
curr = buf->bh_first.b_next;
c = curr->b_str[buf->bh_index];
if (advance)
{
if (curr->b_str[++buf->bh_index] == NUL)
{
buf->bh_first.b_next = curr->b_next;
vim_free(curr);
buf->bh_index = 0;
}
}
return c;
}
/*
* Prepare the read buffers for reading (if they contain something).
*/
static void
start_stuff()
{
if (readbuf1.bh_first.b_next != NULL)
{
readbuf1.bh_curr = &(readbuf1.bh_first);
readbuf1.bh_space = 0;
}
if (readbuf2.bh_first.b_next != NULL)
{
readbuf2.bh_curr = &(readbuf2.bh_first);
readbuf2.bh_space = 0;
}
}
/*
* Return TRUE if the stuff buffer is empty.
*/
int
stuff_empty()
{
return (readbuf1.bh_first.b_next == NULL
&& readbuf2.bh_first.b_next == NULL);
}
/*
* Return TRUE if readbuf1 is empty. There may still be redo characters in
* redbuf2.
*/
int
readbuf1_empty()
{
return (readbuf1.bh_first.b_next == NULL);
}
/*
* Set a typeahead character that won't be flushed.
*/
void
typeahead_noflush(c)
int c;
{
typeahead_char = c;
}
/*
* Remove the contents of the stuff buffer and the mapped characters in the
* typeahead buffer (used in case of an error). If "flush_typeahead" is true,
* flush all typeahead characters (used when interrupted by a CTRL-C).
*/
void
flush_buffers(flush_typeahead)
int flush_typeahead;
{
init_typebuf();
start_stuff();
while (read_readbuffers(TRUE) != NUL)
;
if (flush_typeahead) /* remove all typeahead */
{
/*
* We have to get all characters, because we may delete the first part
* of an escape sequence.
* In an xterm we get one char at a time and we have to get them all.
*/
while (inchar(typebuf.tb_buf, typebuf.tb_buflen - 1, 10L,
typebuf.tb_change_cnt) != 0)
;
typebuf.tb_off = MAXMAPLEN;
typebuf.tb_len = 0;
}
else /* remove mapped characters at the start only */
{
typebuf.tb_off += typebuf.tb_maplen;
typebuf.tb_len -= typebuf.tb_maplen;
}
typebuf.tb_maplen = 0;
typebuf.tb_silent = 0;
cmd_silent = FALSE;
typebuf.tb_no_abbr_cnt = 0;
}
/*
* The previous contents of the redo buffer is kept in old_redobuffer.
* This is used for the CTRL-O <.> command in insert mode.
*/
void
ResetRedobuff()
{
if (!block_redo)
{
free_buff(&old_redobuff);
old_redobuff = redobuff;
redobuff.bh_first.b_next = NULL;
}
}
/*
* Discard the contents of the redo buffer and restore the previous redo
* buffer.
*/
void
CancelRedo()
{
if (!block_redo)
{
free_buff(&redobuff);
redobuff = old_redobuff;
old_redobuff.bh_first.b_next = NULL;
start_stuff();
while (read_readbuffers(TRUE) != NUL)
;
}
}
#if defined(FEAT_AUTOCMD) || defined(FEAT_EVAL) || defined(PROTO)
/*
* Save redobuff and old_redobuff to save_redobuff and save_old_redobuff.
* Used before executing autocommands and user functions.
*/
static int save_level = 0;
void
saveRedobuff()
{
char_u *s;
if (save_level++ == 0)
{
save_redobuff = redobuff;
redobuff.bh_first.b_next = NULL;
save_old_redobuff = old_redobuff;
old_redobuff.bh_first.b_next = NULL;
/* Make a copy, so that ":normal ." in a function works. */
s = get_buffcont(&save_redobuff, FALSE);
if (s != NULL)
{
add_buff(&redobuff, s, -1L);
vim_free(s);
}
}
}
/*
* Restore redobuff and old_redobuff from save_redobuff and save_old_redobuff.
* Used after executing autocommands and user functions.
*/
void
restoreRedobuff()
{
if (--save_level == 0)
{
free_buff(&redobuff);
redobuff = save_redobuff;
free_buff(&old_redobuff);
old_redobuff = save_old_redobuff;
}
}
#endif
/*
* Append "s" to the redo buffer.
* K_SPECIAL and CSI should already have been escaped.
*/
void
AppendToRedobuff(s)
char_u *s;
{
if (!block_redo)
add_buff(&redobuff, s, -1L);
}
/*
* Append to Redo buffer literally, escaping special characters with CTRL-V.
* K_SPECIAL and CSI are escaped as well.
*/
void
AppendToRedobuffLit(str, len)
char_u *str;
int len; /* length of "str" or -1 for up to the NUL */
{
char_u *s = str;
int c;
char_u *start;
if (block_redo)
return;
while (len < 0 ? *s != NUL : s - str < len)
{
/* Put a string of normal characters in the redo buffer (that's
* faster). */
start = s;
while (*s >= ' '
#ifndef EBCDIC
&& *s < DEL /* EBCDIC: all chars above space are normal */
#endif
&& (len < 0 || s - str < len))
++s;
/* Don't put '0' or '^' as last character, just in case a CTRL-D is
* typed next. */
if (*s == NUL && (s[-1] == '0' || s[-1] == '^'))
--s;
if (s > start)
add_buff(&redobuff, start, (long)(s - start));
if (*s == NUL || (len >= 0 && s - str >= len))
break;
/* Handle a special or multibyte character. */
#ifdef FEAT_MBYTE
if (has_mbyte)
/* Handle composing chars separately. */
c = mb_cptr2char_adv(&s);
else
#endif
c = *s++;
if (c < ' ' || c == DEL || (*s == NUL && (c == '0' || c == '^')))
add_char_buff(&redobuff, Ctrl_V);
/* CTRL-V '0' must be inserted as CTRL-V 048 (EBCDIC: xf0) */
if (*s == NUL && c == '0')
#ifdef EBCDIC
add_buff(&redobuff, (char_u *)"xf0", 3L);
#else
add_buff(&redobuff, (char_u *)"048", 3L);
#endif
else
add_char_buff(&redobuff, c);
}
}
/*
* Append a character to the redo buffer.
* Translates special keys, NUL, CSI, K_SPECIAL and multibyte characters.
*/
void
AppendCharToRedobuff(c)
int c;
{
if (!block_redo)
add_char_buff(&redobuff, c);
}
/*
* Append a number to the redo buffer.
*/
void
AppendNumberToRedobuff(n)
long n;
{
if (!block_redo)
add_num_buff(&redobuff, n);
}
/*
* Append string "s" to the stuff buffer.
* CSI and K_SPECIAL must already have been escaped.
*/
void
stuffReadbuff(s)
char_u *s;
{
add_buff(&readbuf1, s, -1L);
}
void
stuffReadbuffLen(s, len)
char_u *s;
long len;
{
add_buff(&readbuf1, s, len);
}
#if defined(FEAT_EVAL) || defined(PROTO)
/*
* Stuff "s" into the stuff buffer, leaving special key codes unmodified and
* escaping other K_SPECIAL and CSI bytes.
* Change CR, LF and ESC into a space.
*/
void
stuffReadbuffSpec(s)
char_u *s;
{
int c;
while (*s != NUL)
{
if (*s == K_SPECIAL && s[1] != NUL && s[2] != NUL)
{
/* Insert special key literally. */
stuffReadbuffLen(s, 3L);
s += 3;
}
else
{
#ifdef FEAT_MBYTE
c = mb_ptr2char_adv(&s);
#else
c = *s++;
#endif
if (c == CAR || c == NL || c == ESC)
c = ' ';
stuffcharReadbuff(c);
}
}
}
#endif
/*
* Append a character to the stuff buffer.
* Translates special keys, NUL, CSI, K_SPECIAL and multibyte characters.
*/
void
stuffcharReadbuff(c)
int c;
{
add_char_buff(&readbuf1, c);
}
/*
* Append a number to the stuff buffer.
*/
void
stuffnumReadbuff(n)
long n;
{
add_num_buff(&readbuf1, n);
}
/*
* Read a character from the redo buffer. Translates K_SPECIAL, CSI and
* multibyte characters.
* The redo buffer is left as it is.
* If init is TRUE, prepare for redo, return FAIL if nothing to redo, OK
* otherwise.
* If old is TRUE, use old_redobuff instead of redobuff.
*/
static int
read_redo(init, old_redo)
int init;
int old_redo;
{
static buffblock_T *bp;
static char_u *p;
int c;
#ifdef FEAT_MBYTE
int n;
char_u buf[MB_MAXBYTES + 1];
int i;
#endif
if (init)
{
if (old_redo)
bp = old_redobuff.bh_first.b_next;
else
bp = redobuff.bh_first.b_next;
if (bp == NULL)
return FAIL;
p = bp->b_str;
return OK;
}
if ((c = *p) != NUL)
{
/* Reverse the conversion done by add_char_buff() */
#ifdef FEAT_MBYTE
/* For a multi-byte character get all the bytes and return the
* converted character. */
if (has_mbyte && (c != K_SPECIAL || p[1] == KS_SPECIAL))
n = MB_BYTE2LEN_CHECK(c);
else
n = 1;
for (i = 0; ; ++i)
#endif
{
if (c == K_SPECIAL) /* special key or escaped K_SPECIAL */
{
c = TO_SPECIAL(p[1], p[2]);
p += 2;
}
#ifdef FEAT_GUI
if (c == CSI) /* escaped CSI */
p += 2;
#endif
if (*++p == NUL && bp->b_next != NULL)
{
bp = bp->b_next;
p = bp->b_str;
}
#ifdef FEAT_MBYTE
buf[i] = c;
if (i == n - 1) /* last byte of a character */
{
if (n != 1)
c = (*mb_ptr2char)(buf);
break;
}
c = *p;
if (c == NUL) /* cannot happen? */
break;
#endif
}
}
return c;
}
/*
* Copy the rest of the redo buffer into the stuff buffer (in a slow way).
* If old_redo is TRUE, use old_redobuff instead of redobuff.
* The escaped K_SPECIAL and CSI are copied without translation.
*/
static void
copy_redo(old_redo)
int old_redo;
{
int c;
while ((c = read_redo(FALSE, old_redo)) != NUL)
add_char_buff(&readbuf2, c);
}
/*
* Stuff the redo buffer into readbuf2.
* Insert the redo count into the command.
* If "old_redo" is TRUE, the last but one command is repeated
* instead of the last command (inserting text). This is used for
* CTRL-O <.> in insert mode
*
* return FAIL for failure, OK otherwise
*/
int
start_redo(count, old_redo)
long count;
int old_redo;
{
int c;
/* init the pointers; return if nothing to redo */
if (read_redo(TRUE, old_redo) == FAIL)
return FAIL;
c = read_redo(FALSE, old_redo);
/* copy the buffer name, if present */
if (c == '"')
{
add_buff(&readbuf2, (char_u *)"\"", 1L);
c = read_redo(FALSE, old_redo);
/* if a numbered buffer is used, increment the number */
if (c >= '1' && c < '9')
++c;
add_char_buff(&readbuf2, c);
c = read_redo(FALSE, old_redo);
}
if (c == 'v') /* redo Visual */
{
VIsual = curwin->w_cursor;
VIsual_active = TRUE;
VIsual_select = FALSE;
VIsual_reselect = TRUE;
redo_VIsual_busy = TRUE;
c = read_redo(FALSE, old_redo);
}
/* try to enter the count (in place of a previous count) */
if (count)
{
while (VIM_ISDIGIT(c)) /* skip "old" count */
c = read_redo(FALSE, old_redo);
add_num_buff(&readbuf2, count);
}
/* copy from the redo buffer into the stuff buffer */
add_char_buff(&readbuf2, c);
copy_redo(old_redo);
return OK;
}
/*
* Repeat the last insert (R, o, O, a, A, i or I command) by stuffing
* the redo buffer into readbuf2.
* return FAIL for failure, OK otherwise
*/
int
start_redo_ins()
{
int c;
if (read_redo(TRUE, FALSE) == FAIL)
return FAIL;
start_stuff();
/* skip the count and the command character */
while ((c = read_redo(FALSE, FALSE)) != NUL)
{
if (vim_strchr((char_u *)"AaIiRrOo", c) != NULL)
{
if (c == 'O' || c == 'o')
add_buff(&readbuf2, NL_STR, -1L);
break;
}
}
/* copy the typed text from the redo buffer into the stuff buffer */
copy_redo(FALSE);
block_redo = TRUE;
return OK;
}
void
stop_redo_ins()
{
block_redo = FALSE;
}
/*
* Initialize typebuf.tb_buf to point to typebuf_init.
* alloc() cannot be used here: In out-of-memory situations it would
* be impossible to type anything.
*/
static void
init_typebuf()
{
if (typebuf.tb_buf == NULL)
{
typebuf.tb_buf = typebuf_init;
typebuf.tb_noremap = noremapbuf_init;
typebuf.tb_buflen = TYPELEN_INIT;
typebuf.tb_len = 0;
typebuf.tb_off = 0;
typebuf.tb_change_cnt = 1;
}
}
/*
* insert a string in position 'offset' in the typeahead buffer (for "@r"
* and ":normal" command, vgetorpeek() and check_termcode())
*
* If noremap is REMAP_YES, new string can be mapped again.
* If noremap is REMAP_NONE, new string cannot be mapped again.
* If noremap is REMAP_SKIP, fist char of new string cannot be mapped again,
* but abbreviations are allowed.
* If noremap is REMAP_SCRIPT, new string cannot be mapped again, except for
* script-local mappings.
* If noremap is > 0, that many characters of the new string cannot be mapped.
*
* If nottyped is TRUE, the string does not return KeyTyped (don't use when
* offset is non-zero!).
*
* If silent is TRUE, cmd_silent is set when the characters are obtained.
*
* return FAIL for failure, OK otherwise
*/
int
ins_typebuf(str, noremap, offset, nottyped, silent)
char_u *str;
int noremap;
int offset;
int nottyped;
int silent;
{
char_u *s1, *s2;
int newlen;
int addlen;
int i;
int newoff;
int val;
int nrm;
init_typebuf();
if (++typebuf.tb_change_cnt == 0)
typebuf.tb_change_cnt = 1;
addlen = (int)STRLEN(str);
/*
* Easy case: there is room in front of typebuf.tb_buf[typebuf.tb_off]
*/
if (offset == 0 && addlen <= typebuf.tb_off)
{
typebuf.tb_off -= addlen;
mch_memmove(typebuf.tb_buf + typebuf.tb_off, str, (size_t)addlen);
}
/*
* Need to allocate a new buffer.
* In typebuf.tb_buf there must always be room for 3 * MAXMAPLEN + 4
* characters. We add some extra room to avoid having to allocate too
* often.
*/
else
{
newoff = MAXMAPLEN + 4;
newlen = typebuf.tb_len + addlen + newoff + 4 * (MAXMAPLEN + 4);
if (newlen < 0) /* string is getting too long */
{
EMSG(_(e_toocompl)); /* also calls flush_buffers */
setcursor();
return FAIL;
}
s1 = alloc(newlen);
if (s1 == NULL) /* out of memory */
return FAIL;
s2 = alloc(newlen);
if (s2 == NULL) /* out of memory */
{
vim_free(s1);
return FAIL;
}
typebuf.tb_buflen = newlen;
/* copy the old chars, before the insertion point */
mch_memmove(s1 + newoff, typebuf.tb_buf + typebuf.tb_off,
(size_t)offset);
/* copy the new chars */
mch_memmove(s1 + newoff + offset, str, (size_t)addlen);
/* copy the old chars, after the insertion point, including the NUL at
* the end */
mch_memmove(s1 + newoff + offset + addlen,
typebuf.tb_buf + typebuf.tb_off + offset,
(size_t)(typebuf.tb_len - offset + 1));
if (typebuf.tb_buf != typebuf_init)
vim_free(typebuf.tb_buf);
typebuf.tb_buf = s1;
mch_memmove(s2 + newoff, typebuf.tb_noremap + typebuf.tb_off,
(size_t)offset);
mch_memmove(s2 + newoff + offset + addlen,
typebuf.tb_noremap + typebuf.tb_off + offset,
(size_t)(typebuf.tb_len - offset));
if (typebuf.tb_noremap != noremapbuf_init)
vim_free(typebuf.tb_noremap);
typebuf.tb_noremap = s2;
typebuf.tb_off = newoff;
}
typebuf.tb_len += addlen;
/* If noremap == REMAP_SCRIPT: do remap script-local mappings. */
if (noremap == REMAP_SCRIPT)
val = RM_SCRIPT;
else if (noremap == REMAP_SKIP)
val = RM_ABBR;
else
val = RM_NONE;
/*
* Adjust typebuf.tb_noremap[] for the new characters:
* If noremap == REMAP_NONE or REMAP_SCRIPT: new characters are
* (sometimes) not remappable
* If noremap == REMAP_YES: all the new characters are mappable
* If noremap > 0: "noremap" characters are not remappable, the rest
* mappable
*/
if (noremap == REMAP_SKIP)
nrm = 1;
else if (noremap < 0)
nrm = addlen;
else
nrm = noremap;
for (i = 0; i < addlen; ++i)
typebuf.tb_noremap[typebuf.tb_off + i + offset] =
(--nrm >= 0) ? val : RM_YES;
/* tb_maplen and tb_silent only remember the length of mapped and/or
* silent mappings at the start of the buffer, assuming that a mapped
* sequence doesn't result in typed characters. */
if (nottyped || typebuf.tb_maplen > offset)
typebuf.tb_maplen += addlen;
if (silent || typebuf.tb_silent > offset)
{
typebuf.tb_silent += addlen;
cmd_silent = TRUE;
}
if (typebuf.tb_no_abbr_cnt && offset == 0) /* and not used for abbrev.s */
typebuf.tb_no_abbr_cnt += addlen;
return OK;
}
/*
* Put character "c" back into the typeahead buffer.
* Can be used for a character obtained by vgetc() that needs to be put back.
* Uses cmd_silent, KeyTyped and KeyNoremap to restore the flags belonging to
* the char.
*/
void
ins_char_typebuf(c)
int c;
{
#ifdef FEAT_MBYTE
char_u buf[MB_MAXBYTES + 1];
#else
char_u buf[4];
#endif
if (IS_SPECIAL(c))
{
buf[0] = K_SPECIAL;
buf[1] = K_SECOND(c);
buf[2] = K_THIRD(c);
buf[3] = NUL;
}
else
{
#ifdef FEAT_MBYTE
buf[(*mb_char2bytes)(c, buf)] = NUL;
#else
buf[0] = c;
buf[1] = NUL;
#endif
}
(void)ins_typebuf(buf, KeyNoremap, 0, !KeyTyped, cmd_silent);
}
/*
* Return TRUE if the typeahead buffer was changed (while waiting for a
* character to arrive). Happens when a message was received from a client or
* from feedkeys().
* But check in a more generic way to avoid trouble: When "typebuf.tb_buf"
* changed it was reallocated and the old pointer can no longer be used.
* Or "typebuf.tb_off" may have been changed and we would overwrite characters
* that was just added.
*/
int
typebuf_changed(tb_change_cnt)
int tb_change_cnt; /* old value of typebuf.tb_change_cnt */
{
return (tb_change_cnt != 0 && (typebuf.tb_change_cnt != tb_change_cnt
#if defined(FEAT_CLIENTSERVER) || defined(FEAT_EVAL)
|| typebuf_was_filled
#endif
));
}
/*
* Return TRUE if there are no characters in the typeahead buffer that have
* not been typed (result from a mapping or come from ":normal").
*/
int
typebuf_typed()
{
return typebuf.tb_maplen == 0;
}
/*
* Return the number of characters that are mapped (or not typed).
*/
int
typebuf_maplen()
{
return typebuf.tb_maplen;
}
/*
* remove "len" characters from typebuf.tb_buf[typebuf.tb_off + offset]
*/
void
del_typebuf(len, offset)
int len;
int offset;
{
int i;
if (len == 0)
return; /* nothing to do */
typebuf.tb_len -= len;
/*
* Easy case: Just increase typebuf.tb_off.
*/
if (offset == 0 && typebuf.tb_buflen - (typebuf.tb_off + len)
>= 3 * MAXMAPLEN + 3)
typebuf.tb_off += len;
/*
* Have to move the characters in typebuf.tb_buf[] and typebuf.tb_noremap[]
*/
else
{
i = typebuf.tb_off + offset;
/*
* Leave some extra room at the end to avoid reallocation.
*/
if (typebuf.tb_off > MAXMAPLEN)
{
mch_memmove(typebuf.tb_buf + MAXMAPLEN,
typebuf.tb_buf + typebuf.tb_off, (size_t)offset);
mch_memmove(typebuf.tb_noremap + MAXMAPLEN,
typebuf.tb_noremap + typebuf.tb_off, (size_t)offset);
typebuf.tb_off = MAXMAPLEN;
}
/* adjust typebuf.tb_buf (include the NUL at the end) */
mch_memmove(typebuf.tb_buf + typebuf.tb_off + offset,
typebuf.tb_buf + i + len,
(size_t)(typebuf.tb_len - offset + 1));
/* adjust typebuf.tb_noremap[] */
mch_memmove(typebuf.tb_noremap + typebuf.tb_off + offset,
typebuf.tb_noremap + i + len,
(size_t)(typebuf.tb_len - offset));
}
if (typebuf.tb_maplen > offset) /* adjust tb_maplen */
{
if (typebuf.tb_maplen < offset + len)
typebuf.tb_maplen = offset;
else
typebuf.tb_maplen -= len;
}
if (typebuf.tb_silent > offset) /* adjust tb_silent */
{
if (typebuf.tb_silent < offset + len)
typebuf.tb_silent = offset;
else
typebuf.tb_silent -= len;
}
if (typebuf.tb_no_abbr_cnt > offset) /* adjust tb_no_abbr_cnt */
{
if (typebuf.tb_no_abbr_cnt < offset + len)
typebuf.tb_no_abbr_cnt = offset;
else
typebuf.tb_no_abbr_cnt -= len;
}
#if defined(FEAT_CLIENTSERVER) || defined(FEAT_EVAL)
/* Reset the flag that text received from a client or from feedkeys()
* was inserted in the typeahead buffer. */
typebuf_was_filled = FALSE;
#endif
if (++typebuf.tb_change_cnt == 0)
typebuf.tb_change_cnt = 1;
}
/*
* Write typed characters to script file.
* If recording is on put the character in the recordbuffer.
*/
static void
gotchars(chars, len)
char_u *chars;
int len;
{
char_u *s = chars;
int c;
char_u buf[2];
int todo = len;
/* remember how many chars were last recorded */
if (Recording)
last_recorded_len += len;
buf[1] = NUL;
while (todo--)
{
/* Handle one byte at a time; no translation to be done. */
c = *s++;
updatescript(c);
if (Recording)
{
buf[0] = c;
add_buff(&recordbuff, buf, 1L);
}
}
may_sync_undo();
#ifdef FEAT_EVAL
/* output "debug mode" message next time in debug mode */
debug_did_msg = FALSE;
#endif
/* Since characters have been typed, consider the following to be in
* another mapping. Search string will be kept in history. */
++maptick;
}
/*
* Sync undo. Called when typed characters are obtained from the typeahead
* buffer, or when a menu is used.
* Do not sync:
* - In Insert mode, unless cursor key has been used.
* - While reading a script file.
* - When no_u_sync is non-zero.
*/
static void
may_sync_undo()
{
if ((!(State & (INSERT + CMDLINE)) || arrow_used)
&& scriptin[curscript] == NULL)
u_sync(FALSE);
}
/*
* Make "typebuf" empty and allocate new buffers.
* Returns FAIL when out of memory.
*/
int
alloc_typebuf()
{
typebuf.tb_buf = alloc(TYPELEN_INIT);
typebuf.tb_noremap = alloc(TYPELEN_INIT);
if (typebuf.tb_buf == NULL || typebuf.tb_noremap == NULL)
{
free_typebuf();
return FAIL;
}
typebuf.tb_buflen = TYPELEN_INIT;
typebuf.tb_off = 0;
typebuf.tb_len = 0;
typebuf.tb_maplen = 0;
typebuf.tb_silent = 0;
typebuf.tb_no_abbr_cnt = 0;
if (++typebuf.tb_change_cnt == 0)
typebuf.tb_change_cnt = 1;
return OK;
}
/*
* Free the buffers of "typebuf".
*/
void
free_typebuf()
{
if (typebuf.tb_buf == typebuf_init)
EMSG2(_(e_intern2), "Free typebuf 1");
else
vim_free(typebuf.tb_buf);
if (typebuf.tb_noremap == noremapbuf_init)
EMSG2(_(e_intern2), "Free typebuf 2");
else
vim_free(typebuf.tb_noremap);
}
/*
* When doing ":so! file", the current typeahead needs to be saved, and
* restored when "file" has been read completely.
*/
static typebuf_T saved_typebuf[NSCRIPT];
int
save_typebuf()
{
init_typebuf();
saved_typebuf[curscript] = typebuf;
/* If out of memory: restore typebuf and close file. */
if (alloc_typebuf() == FAIL)
{
closescript();
return FAIL;
}
return OK;
}
static int old_char = -1; /* character put back by vungetc() */
static int old_mod_mask; /* mod_mask for ungotten character */
#ifdef FEAT_MOUSE
static int old_mouse_row; /* mouse_row related to old_char */
static int old_mouse_col; /* mouse_col related to old_char */
#endif
#if defined(FEAT_EVAL) || defined(FEAT_EX_EXTRA) || defined(PROTO)
/*
* Save all three kinds of typeahead, so that the user must type at a prompt.
*/
void
save_typeahead(tp)
tasave_T *tp;
{
tp->save_typebuf = typebuf;
tp->typebuf_valid = (alloc_typebuf() == OK);
if (!tp->typebuf_valid)
typebuf = tp->save_typebuf;
tp->old_char = old_char;
tp->old_mod_mask = old_mod_mask;
old_char = -1;
tp->save_readbuf1 = readbuf1;
readbuf1.bh_first.b_next = NULL;
tp->save_readbuf2 = readbuf2;
readbuf2.bh_first.b_next = NULL;
# ifdef USE_INPUT_BUF
tp->save_inputbuf = get_input_buf();
# endif
}
/*
* Restore the typeahead to what it was before calling save_typeahead().
* The allocated memory is freed, can only be called once!
*/
void
restore_typeahead(tp)
tasave_T *tp;
{
if (tp->typebuf_valid)
{
free_typebuf();
typebuf = tp->save_typebuf;
}
old_char = tp->old_char;
old_mod_mask = tp->old_mod_mask;
free_buff(&readbuf1);
readbuf1 = tp->save_readbuf1;
free_buff(&readbuf2);
readbuf2 = tp->save_readbuf2;
# ifdef USE_INPUT_BUF
set_input_buf(tp->save_inputbuf);
# endif
}
#endif
/*
* Open a new script file for the ":source!" command.
*/
void
openscript(name, directly)
char_u *name;
int directly; /* when TRUE execute directly */
{
if (curscript + 1 == NSCRIPT)
{
EMSG(_(e_nesting));
return;
}
#ifdef FEAT_EVAL
if (ignore_script)
/* Not reading from script, also don't open one. Warning message? */
return;
#endif
if (scriptin[curscript] != NULL) /* already reading script */
++curscript;
/* use NameBuff for expanded name */
expand_env(name, NameBuff, MAXPATHL);
if ((scriptin[curscript] = mch_fopen((char *)NameBuff, READBIN)) == NULL)
{
EMSG2(_(e_notopen), name);
if (curscript)
--curscript;
return;
}
if (save_typebuf() == FAIL)
return;
/*
* Execute the commands from the file right now when using ":source!"
* after ":global" or ":argdo" or in a loop. Also when another command
* follows. This means the display won't be updated. Don't do this
* always, "make test" would fail.
*/
if (directly)
{
oparg_T oa;
int oldcurscript;
int save_State = State;
int save_restart_edit = restart_edit;
int save_insertmode = p_im;
int save_finish_op = finish_op;
int save_msg_scroll = msg_scroll;
State = NORMAL;
msg_scroll = FALSE; /* no msg scrolling in Normal mode */
restart_edit = 0; /* don't go to Insert mode */
p_im = FALSE; /* don't use 'insertmode' */
clear_oparg(&oa);
finish_op = FALSE;
oldcurscript = curscript;
do
{
update_topline_cursor(); /* update cursor position and topline */
normal_cmd(&oa, FALSE); /* execute one command */
vpeekc(); /* check for end of file */
}
while (scriptin[oldcurscript] != NULL);
State = save_State;
msg_scroll = save_msg_scroll;
restart_edit = save_restart_edit;
p_im = save_insertmode;
finish_op = save_finish_op;
}
}
/*
* Close the currently active input script.
*/
static void
closescript()
{
free_typebuf();
typebuf = saved_typebuf[curscript];
fclose(scriptin[curscript]);
scriptin[curscript] = NULL;
if (curscript > 0)
--curscript;
}
#if defined(EXITFREE) || defined(PROTO)
void
close_all_scripts()
{
while (scriptin[0] != NULL)
closescript();
}
#endif
#if defined(FEAT_INS_EXPAND) || defined(PROTO)
/*
* Return TRUE when reading keys from a script file.
*/
int
using_script()
{
return scriptin[curscript] != NULL;
}
#endif
/*
* This function is called just before doing a blocking wait. Thus after
* waiting 'updatetime' for a character to arrive.
*/
void
before_blocking()
{
updatescript(0);
#ifdef FEAT_EVAL
if (may_garbage_collect)
garbage_collect();
#endif
}
/*
* updatescipt() is called when a character can be written into the script file
* or when we have waited some time for a character (c == 0)
*
* All the changed memfiles are synced if c == 0 or when the number of typed
* characters reaches 'updatecount' and 'updatecount' is non-zero.
*/
void
updatescript(c)
int c;
{
static int count = 0;
if (c && scriptout)
putc(c, scriptout);
if (c == 0 || (p_uc > 0 && ++count >= p_uc))
{
ml_sync_all(c == 0, TRUE);
count = 0;
}
}
/*
* Get the next input character.
* Can return a special key or a multi-byte character.
* Can return NUL when called recursively, use safe_vgetc() if that's not
* wanted.
* This translates escaped K_SPECIAL and CSI bytes to a K_SPECIAL or CSI byte.
* Collects the bytes of a multibyte character into the whole character.
* Returns the modifiers in the global "mod_mask".
*/
int
vgetc()
{
int c, c2;
#ifdef FEAT_MBYTE
int n;
char_u buf[MB_MAXBYTES + 1];
int i;
#endif
#ifdef FEAT_EVAL
/* Do garbage collection when garbagecollect() was called previously and
* we are now at the toplevel. */
if (may_garbage_collect && want_garbage_collect)
garbage_collect();
#endif
/*
* If a character was put back with vungetc, it was already processed.
* Return it directly.
*/
if (old_char != -1)
{
c = old_char;
old_char = -1;
mod_mask = old_mod_mask;
#ifdef FEAT_MOUSE
mouse_row = old_mouse_row;
mouse_col = old_mouse_col;
#endif
}
else
{
mod_mask = 0x0;
last_recorded_len = 0;
for (;;) /* this is done twice if there are modifiers */
{
if (mod_mask) /* no mapping after modifier has been read */
{
++no_mapping;
++allow_keys;
}
c = vgetorpeek(TRUE);
if (mod_mask)
{
--no_mapping;
--allow_keys;
}
/* Get two extra bytes for special keys */
if (c == K_SPECIAL
#ifdef FEAT_GUI
|| c == CSI
#endif
)
{
int save_allow_keys = allow_keys;
++no_mapping;
allow_keys = 0; /* make sure BS is not found */
c2 = vgetorpeek(TRUE); /* no mapping for these chars */
c = vgetorpeek(TRUE);
--no_mapping;
allow_keys = save_allow_keys;
if (c2 == KS_MODIFIER)
{
mod_mask = c;
continue;
}
c = TO_SPECIAL(c2, c);
#if defined(FEAT_GUI_W32) && defined(FEAT_MENU) && defined(FEAT_TEAROFF)
/* Handle K_TEAROFF here, the caller of vgetc() doesn't need to
* know that a menu was torn off */
if (c == K_TEAROFF)
{
char_u name[200];
int i;
/* get menu path, it ends with a <CR> */
for (i = 0; (c = vgetorpeek(TRUE)) != '\r'; )
{
name[i] = c;
if (i < 199)
++i;
}
name[i] = NUL;
gui_make_tearoff(name);
continue;
}
#endif
#if defined(FEAT_GUI) && defined(FEAT_GUI_GTK) && defined(FEAT_MENU)
/* GTK: <F10> normally selects the menu, but it's passed until
* here to allow mapping it. Intercept and invoke the GTK
* behavior if it's not mapped. */
if (c == K_F10 && gui.menubar != NULL)
{
gtk_menu_shell_select_first(GTK_MENU_SHELL(gui.menubar), FALSE);
continue;
}
#endif
#ifdef FEAT_GUI
/* Handle focus event here, so that the caller doesn't need to
* know about it. Return K_IGNORE so that we loop once (needed if
* 'lazyredraw' is set). */
if (c == K_FOCUSGAINED || c == K_FOCUSLOST)
{
ui_focus_change(c == K_FOCUSGAINED);
c = K_IGNORE;
}
/* Translate K_CSI to CSI. The special key is only used to avoid
* it being recognized as the start of a special key. */
if (c == K_CSI)
c = CSI;
#endif
}
#ifdef MSDOS
/*
* If K_NUL was typed, it is replaced by K_NUL, 3 in mch_inchar().
* Delete the 3 here.
*/
else if (c == K_NUL && vpeekc() == 3)
(void)vgetorpeek(TRUE);
#endif
/* a keypad or special function key was not mapped, use it like
* its ASCII equivalent */
switch (c)
{
case K_KPLUS: c = '+'; break;
case K_KMINUS: c = '-'; break;
case K_KDIVIDE: c = '/'; break;
case K_KMULTIPLY: c = '*'; break;
case K_KENTER: c = CAR; break;
case K_KPOINT:
#ifdef WIN32
/* Can be either '.' or a ',', *
* depending on the type of keypad. */
c = MapVirtualKey(VK_DECIMAL, 2); break;
#else
c = '.'; break;
#endif
case K_K0: c = '0'; break;
case K_K1: c = '1'; break;
case K_K2: c = '2'; break;
case K_K3: c = '3'; break;
case K_K4: c = '4'; break;
case K_K5: c = '5'; break;
case K_K6: c = '6'; break;
case K_K7: c = '7'; break;
case K_K8: c = '8'; break;
case K_K9: c = '9'; break;
case K_XHOME:
case K_ZHOME: if (mod_mask == MOD_MASK_SHIFT)
{
c = K_S_HOME;
mod_mask = 0;
}
else if (mod_mask == MOD_MASK_CTRL)
{
c = K_C_HOME;
mod_mask = 0;
}
else
c = K_HOME;
break;
case K_XEND:
case K_ZEND: if (mod_mask == MOD_MASK_SHIFT)
{
c = K_S_END;
mod_mask = 0;
}
else if (mod_mask == MOD_MASK_CTRL)
{
c = K_C_END;
mod_mask = 0;
}
else
c = K_END;
break;
case K_XUP: c = K_UP; break;
case K_XDOWN: c = K_DOWN; break;
case K_XLEFT: c = K_LEFT; break;
case K_XRIGHT: c = K_RIGHT; break;
}
#ifdef FEAT_MBYTE
/* For a multi-byte character get all the bytes and return the
* converted character.
* Note: This will loop until enough bytes are received!
*/
if (has_mbyte && (n = MB_BYTE2LEN_CHECK(c)) > 1)
{
++no_mapping;
buf[0] = c;
for (i = 1; i < n; ++i)
{
buf[i] = vgetorpeek(TRUE);
if (buf[i] == K_SPECIAL
#ifdef FEAT_GUI
|| buf[i] == CSI
#endif
)
{
/* Must be a K_SPECIAL - KS_SPECIAL - KE_FILLER sequence,
* which represents a K_SPECIAL (0x80),
* or a CSI - KS_EXTRA - KE_CSI sequence, which represents
* a CSI (0x9B),
* of a K_SPECIAL - KS_EXTRA - KE_CSI, which is CSI too. */
c = vgetorpeek(TRUE);
if (vgetorpeek(TRUE) == (int)KE_CSI && c == KS_EXTRA)
buf[i] = CSI;
}
}
--no_mapping;
c = (*mb_ptr2char)(buf);
}
#endif
break;
}
}
#ifdef FEAT_EVAL
/*
* In the main loop "may_garbage_collect" can be set to do garbage
* collection in the first next vgetc(). It's disabled after that to
* avoid internally used Lists and Dicts to be freed.
*/
may_garbage_collect = FALSE;
#endif
return c;
}
/*
* Like vgetc(), but never return a NUL when called recursively, get a key
* directly from the user (ignoring typeahead).
*/
int
safe_vgetc()
{
int c;
c = vgetc();
if (c == NUL)
c = get_keystroke();
return c;
}
/*
* Like safe_vgetc(), but loop to handle K_IGNORE.
* Also ignore scrollbar events.
*/
int
plain_vgetc()
{
int c;
do
{
c = safe_vgetc();
} while (c == K_IGNORE || c == K_VER_SCROLLBAR || c == K_HOR_SCROLLBAR);
return c;
}
/*
* Check if a character is available, such that vgetc() will not block.
* If the next character is a special character or multi-byte, the returned
* character is not valid!.
*/
int
vpeekc()
{
if (old_char != -1)
return old_char;
return vgetorpeek(FALSE);
}
#if defined(FEAT_TERMRESPONSE) || defined(PROTO)
/*
* Like vpeekc(), but don't allow mapping. Do allow checking for terminal
* codes.
*/
int
vpeekc_nomap()
{
int c;
++no_mapping;
++allow_keys;
c = vpeekc();
--no_mapping;
--allow_keys;
return c;
}
#endif
#if defined(FEAT_INS_EXPAND) || defined(PROTO)
/*
* Check if any character is available, also half an escape sequence.
* Trick: when no typeahead found, but there is something in the typeahead
* buffer, it must be an ESC that is recognized as the start of a key code.
*/
int
vpeekc_any()
{
int c;
c = vpeekc();
if (c == NUL && typebuf.tb_len > 0)
c = ESC;
return c;
}
#endif
/*
* Call vpeekc() without causing anything to be mapped.
* Return TRUE if a character is available, FALSE otherwise.
*/
int
char_avail()
{
int retval;
++no_mapping;
retval = vpeekc();
--no_mapping;
return (retval != NUL);
}
void
vungetc(c) /* unget one character (can only be done once!) */
int c;
{
old_char = c;
old_mod_mask = mod_mask;
#ifdef FEAT_MOUSE
old_mouse_row = mouse_row;
old_mouse_col = mouse_col;
#endif
}
/*
* get a character:
* 1. from the stuffbuffer
* This is used for abbreviated commands like "D" -> "d$".
* Also used to redo a command for ".".
* 2. from the typeahead buffer
* Stores text obtained previously but not used yet.
* Also stores the result of mappings.
* Also used for the ":normal" command.
* 3. from the user
* This may do a blocking wait if "advance" is TRUE.
*
* if "advance" is TRUE (vgetc()):
* really get the character.
* KeyTyped is set to TRUE in the case the user typed the key.
* KeyStuffed is TRUE if the character comes from the stuff buffer.
* if "advance" is FALSE (vpeekc()):
* just look whether there is a character available.
*
* When "no_mapping" is zero, checks for mappings in the current mode.
* Only returns one byte (of a multi-byte character).
* K_SPECIAL and CSI may be escaped, need to get two more bytes then.
*/
static int
vgetorpeek(advance)
int advance;
{
int c, c1;
int keylen;
char_u *s;
mapblock_T *mp;
#ifdef FEAT_LOCALMAP
mapblock_T *mp2;
#endif
mapblock_T *mp_match;
int mp_match_len = 0;
int timedout = FALSE; /* waited for more than 1 second
for mapping to complete */
int mapdepth = 0; /* check for recursive mapping */
int mode_deleted = FALSE; /* set when mode has been deleted */
int local_State;
int mlen;
int max_mlen;
int i;
#ifdef FEAT_CMDL_INFO
int new_wcol, new_wrow;
#endif
#ifdef FEAT_GUI
# ifdef FEAT_MENU
int idx;
# endif
int shape_changed = FALSE; /* adjusted cursor shape */
#endif
int n;
#ifdef FEAT_LANGMAP
int nolmaplen;
#endif
int old_wcol, old_wrow;
int wait_tb_len;
/*
* This function doesn't work very well when called recursively. This may
* happen though, because of:
* 1. The call to add_to_showcmd(). char_avail() is then used to check if
* there is a character available, which calls this function. In that
* case we must return NUL, to indicate no character is available.
* 2. A GUI callback function writes to the screen, causing a
* wait_return().
* Using ":normal" can also do this, but it saves the typeahead buffer,
* thus it should be OK. But don't get a key from the user then.
*/
if (vgetc_busy > 0
#ifdef FEAT_EX_EXTRA
&& ex_normal_busy == 0
#endif
)
return NUL;
local_State = get_real_state();
++vgetc_busy;
if (advance)
KeyStuffed = FALSE;
init_typebuf();
start_stuff();
if (advance && typebuf.tb_maplen == 0)
Exec_reg = FALSE;
do
{
/*
* get a character: 1. from the stuffbuffer
*/
if (typeahead_char != 0)
{
c = typeahead_char;
if (advance)
typeahead_char = 0;
}
else
c = read_readbuffers(advance);
if (c != NUL && !got_int)
{
if (advance)
{
/* KeyTyped = FALSE; When the command that stuffed something
* was typed, behave like the stuffed command was typed.
* needed for CTRL-W CTRl-] to open a fold, for example. */
KeyStuffed = TRUE;
}
if (typebuf.tb_no_abbr_cnt == 0)
typebuf.tb_no_abbr_cnt = 1; /* no abbreviations now */
}
else
{
/*
* Loop until we either find a matching mapped key, or we
* are sure that it is not a mapped key.
* If a mapped key sequence is found we go back to the start to
* try re-mapping.
*/
for (;;)
{
/*
* ui_breakcheck() is slow, don't use it too often when
* inside a mapping. But call it each time for typed
* characters.
*/
if (typebuf.tb_maplen)
line_breakcheck();
else
ui_breakcheck(); /* check for CTRL-C */
keylen = 0;
if (got_int)
{
/* flush all input */
c = inchar(typebuf.tb_buf, typebuf.tb_buflen - 1, 0L,
typebuf.tb_change_cnt);
/*
* If inchar() returns TRUE (script file was active) or we
* are inside a mapping, get out of insert mode.
* Otherwise we behave like having gotten a CTRL-C.
* As a result typing CTRL-C in insert mode will
* really insert a CTRL-C.
*/
if ((c || typebuf.tb_maplen)
&& (State & (INSERT + CMDLINE)))
c = ESC;
else
c = Ctrl_C;
flush_buffers(TRUE); /* flush all typeahead */
if (advance)
{
/* Also record this character, it might be needed to
* get out of Insert mode. */
*typebuf.tb_buf = c;
gotchars(typebuf.tb_buf, 1);
}
cmd_silent = FALSE;
break;
}
else if (typebuf.tb_len > 0)
{
/*
* Check for a mappable key sequence.
* Walk through one maphash[] list until we find an
* entry that matches.
*
* Don't look for mappings if:
* - no_mapping set: mapping disabled (e.g. for CTRL-V)
* - maphash_valid not set: no mappings present.
* - typebuf.tb_buf[typebuf.tb_off] should not be remapped
* - in insert or cmdline mode and 'paste' option set
* - waiting for "hit return to continue" and CR or SPACE
* typed
* - waiting for a char with --more--
* - in Ctrl-X mode, and we get a valid char for that mode
*/
mp = NULL;
max_mlen = 0;
c1 = typebuf.tb_buf[typebuf.tb_off];
if (no_mapping == 0 && maphash_valid
&& (no_zero_mapping == 0 || c1 != '0')
&& (typebuf.tb_maplen == 0
|| (p_remap
&& (typebuf.tb_noremap[typebuf.tb_off]
& (RM_NONE|RM_ABBR)) == 0))
&& !(p_paste && (State & (INSERT + CMDLINE)))
&& !(State == HITRETURN && (c1 == CAR || c1 == ' '))
&& State != ASKMORE
&& State != CONFIRM
#ifdef FEAT_INS_EXPAND
&& !((ctrl_x_mode != 0 && vim_is_ctrl_x_key(c1))
|| ((compl_cont_status & CONT_LOCAL)
&& (c1 == Ctrl_N || c1 == Ctrl_P)))
#endif
)
{
#ifdef FEAT_LANGMAP
if (c1 == K_SPECIAL)
nolmaplen = 2;
else
{
LANGMAP_ADJUST(c1, TRUE);
nolmaplen = 0;
}
#endif
#ifdef FEAT_LOCALMAP
/* First try buffer-local mappings. */
mp = curbuf->b_maphash[MAP_HASH(local_State, c1)];
mp2 = maphash[MAP_HASH(local_State, c1)];
if (mp == NULL)
{
/* There are no buffer-local mappings. */
mp = mp2;
mp2 = NULL;
}
#else
mp = maphash[MAP_HASH(local_State, c1)];
#endif
/*
* Loop until a partly matching mapping is found or
* all (local) mappings have been checked.
* The longest full match is remembered in "mp_match".
* A full match is only accepted if there is no partly
* match, so "aa" and "aaa" can both be mapped.
*/
mp_match = NULL;
mp_match_len = 0;
for ( ; mp != NULL;
#ifdef FEAT_LOCALMAP
mp->m_next == NULL ? (mp = mp2, mp2 = NULL) :
#endif
(mp = mp->m_next))
{
/*
* Only consider an entry if the first character
* matches and it is for the current state.
* Skip ":lmap" mappings if keys were mapped.
*/
if (mp->m_keys[0] == c1
&& (mp->m_mode & local_State)
&& ((mp->m_mode & LANGMAP) == 0
|| typebuf.tb_maplen == 0))
{
#ifdef FEAT_LANGMAP
int nomap = nolmaplen;
int c2;
#endif
/* find the match length of this mapping */
for (mlen = 1; mlen < typebuf.tb_len; ++mlen)
{
#ifdef FEAT_LANGMAP
c2 = typebuf.tb_buf[typebuf.tb_off + mlen];
if (nomap > 0)
--nomap;
else if (c2 == K_SPECIAL)
nomap = 2;
else
LANGMAP_ADJUST(c2, TRUE);
if (mp->m_keys[mlen] != c2)
#else
if (mp->m_keys[mlen] !=
typebuf.tb_buf[typebuf.tb_off + mlen])
#endif
break;
}
#ifdef FEAT_MBYTE
/* Don't allow mapping the first byte(s) of a
* multi-byte char. Happens when mapping
* <M-a> and then changing 'encoding'. Beware
* that 0x80 is escaped. */
{
char_u *p1 = mp->m_keys;
char_u *p2 = mb_unescape(&p1);
if (has_mbyte && p2 != NULL
&& MB_BYTE2LEN(c1) > MB_PTR2LEN(p2))
mlen = 0;
}
#endif
/*
* Check an entry whether it matches.
* - Full match: mlen == keylen
* - Partly match: mlen == typebuf.tb_len
*/
keylen = mp->m_keylen;
if (mlen == keylen
|| (mlen == typebuf.tb_len
&& typebuf.tb_len < keylen))
{
/*
* If only script-local mappings are
* allowed, check if the mapping starts
* with K_SNR.
*/
s = typebuf.tb_noremap + typebuf.tb_off;
if (*s == RM_SCRIPT
&& (mp->m_keys[0] != K_SPECIAL
|| mp->m_keys[1] != KS_EXTRA
|| mp->m_keys[2]
!= (int)KE_SNR))
continue;
/*
* If one of the typed keys cannot be
* remapped, skip the entry.
*/
for (n = mlen; --n >= 0; )
if (*s++ & (RM_NONE|RM_ABBR))
break;
if (n >= 0)
continue;
if (keylen > typebuf.tb_len)
{
if (!timedout && !(mp_match != NULL
&& mp_match->m_nowait))
{
/* break at a partly match */
keylen = KEYLEN_PART_MAP;
break;
}
}
else if (keylen > mp_match_len)
{
/* found a longer match */
mp_match = mp;
mp_match_len = keylen;
}
}
else
/* No match; may have to check for
* termcode at next character. */
if (max_mlen < mlen)
max_mlen = mlen;
}
}
/* If no partly match found, use the longest full
* match. */
if (keylen != KEYLEN_PART_MAP)
{
mp = mp_match;
keylen = mp_match_len;
}
}
/* Check for match with 'pastetoggle' */
if (*p_pt != NUL && mp == NULL && (State & (INSERT|NORMAL)))
{
for (mlen = 0; mlen < typebuf.tb_len && p_pt[mlen];
++mlen)
if (p_pt[mlen] != typebuf.tb_buf[typebuf.tb_off
+ mlen])
break;
if (p_pt[mlen] == NUL) /* match */
{
/* write chars to script file(s) */
if (mlen > typebuf.tb_maplen)
gotchars(typebuf.tb_buf + typebuf.tb_off
+ typebuf.tb_maplen,
mlen - typebuf.tb_maplen);
del_typebuf(mlen, 0); /* remove the chars */
set_option_value((char_u *)"paste",
(long)!p_paste, NULL, 0);
if (!(State & INSERT))
{
msg_col = 0;
msg_row = Rows - 1;
msg_clr_eos(); /* clear ruler */
}
#ifdef FEAT_WINDOWS
status_redraw_all();
redraw_statuslines();
#endif
showmode();
setcursor();
continue;
}
/* Need more chars for partly match. */
if (mlen == typebuf.tb_len)
keylen = KEYLEN_PART_KEY;
else if (max_mlen < mlen)
/* no match, may have to check for termcode at
* next character */
max_mlen = mlen + 1;
}
if ((mp == NULL || max_mlen >= mp_match_len)
&& keylen != KEYLEN_PART_MAP)
{
int save_keylen = keylen;
/*
* When no matching mapping found or found a
* non-matching mapping that matches at least what the
* matching mapping matched:
* Check if we have a terminal code, when:
* mapping is allowed,
* keys have not been mapped,
* and not an ESC sequence, not in insert mode or
* p_ek is on,
* and when not timed out,
*/
if ((no_mapping == 0 || allow_keys != 0)
&& (typebuf.tb_maplen == 0
|| (p_remap && typebuf.tb_noremap[
typebuf.tb_off] == RM_YES))
&& !timedout)
{
keylen = check_termcode(max_mlen + 1,
NULL, 0, NULL);
/* If no termcode matched but 'pastetoggle'
* matched partially it's like an incomplete key
* sequence. */
if (keylen == 0 && save_keylen == KEYLEN_PART_KEY)
keylen = KEYLEN_PART_KEY;
/*
* When getting a partial match, but the last
* characters were not typed, don't wait for a
* typed character to complete the termcode.
* This helps a lot when a ":normal" command ends
* in an ESC.
*/
if (keylen < 0
&& typebuf.tb_len == typebuf.tb_maplen)
keylen = 0;
}
else
keylen = 0;
if (keylen == 0) /* no matching terminal code */
{
#ifdef AMIGA /* check for window bounds report */
if (typebuf.tb_maplen == 0 && (typebuf.tb_buf[
typebuf.tb_off] & 0xff) == CSI)
{
for (s = typebuf.tb_buf + typebuf.tb_off + 1;
s < typebuf.tb_buf + typebuf.tb_off
+ typebuf.tb_len
&& (VIM_ISDIGIT(*s) || *s == ';'
|| *s == ' ');
++s)
;
if (*s == 'r' || *s == '|') /* found one */
{
del_typebuf((int)(s + 1 -
(typebuf.tb_buf + typebuf.tb_off)), 0);
/* get size and redraw screen */
shell_resized();
continue;
}
if (*s == NUL) /* need more characters */
keylen = KEYLEN_PART_KEY;
}
if (keylen >= 0)
#endif
/* When there was a matching mapping and no
* termcode could be replaced after another one,
* use that mapping (loop around). If there was
* no mapping use the character from the
* typeahead buffer right here. */
if (mp == NULL)
{
/*
* get a character: 2. from the typeahead buffer
*/
c = typebuf.tb_buf[typebuf.tb_off] & 255;
if (advance) /* remove chars from tb_buf */
{
cmd_silent = (typebuf.tb_silent > 0);
if (typebuf.tb_maplen > 0)
KeyTyped = FALSE;
else
{
KeyTyped = TRUE;
/* write char to script file(s) */
gotchars(typebuf.tb_buf
+ typebuf.tb_off, 1);
}
KeyNoremap = typebuf.tb_noremap[
typebuf.tb_off];
del_typebuf(1, 0);
}
break; /* got character, break for loop */
}
}
if (keylen > 0) /* full matching terminal code */
{
#if defined(FEAT_GUI) && defined(FEAT_MENU)
if (typebuf.tb_len >= 2
&& typebuf.tb_buf[typebuf.tb_off] == K_SPECIAL
&& typebuf.tb_buf[typebuf.tb_off + 1]
== KS_MENU)
{
/*
* Using a menu may cause a break in undo!
* It's like using gotchars(), but without
* recording or writing to a script file.
*/
may_sync_undo();
del_typebuf(3, 0);
idx = get_menu_index(current_menu, local_State);
if (idx != MENU_INDEX_INVALID)
{
/*
* In Select mode and a Visual mode menu
* is used: Switch to Visual mode
* temporarily. Append K_SELECT to switch
* back to Select mode.
*/
if (VIsual_active && VIsual_select
&& (current_menu->modes & VISUAL))
{
VIsual_select = FALSE;
(void)ins_typebuf(K_SELECT_STRING,
REMAP_NONE, 0, TRUE, FALSE);
}
ins_typebuf(current_menu->strings[idx],
current_menu->noremap[idx],
0, TRUE,
current_menu->silent[idx]);
}
}
#endif /* FEAT_GUI && FEAT_MENU */
continue; /* try mapping again */
}
/* Partial match: get some more characters. When a
* matching mapping was found use that one. */
if (mp == NULL || keylen < 0)
keylen = KEYLEN_PART_KEY;
else
keylen = mp_match_len;
}
/* complete match */
if (keylen >= 0 && keylen <= typebuf.tb_len)
{
#ifdef FEAT_EVAL
int save_m_expr;
int save_m_noremap;
int save_m_silent;
char_u *save_m_keys;
char_u *save_m_str;
#else
# define save_m_noremap mp->m_noremap
# define save_m_silent mp->m_silent
#endif
/* write chars to script file(s) */
if (keylen > typebuf.tb_maplen)
gotchars(typebuf.tb_buf + typebuf.tb_off
+ typebuf.tb_maplen,
keylen - typebuf.tb_maplen);
cmd_silent = (typebuf.tb_silent > 0);
del_typebuf(keylen, 0); /* remove the mapped keys */
/*
* Put the replacement string in front of mapstr.
* The depth check catches ":map x y" and ":map y x".
*/
if (++mapdepth >= p_mmd)
{
EMSG(_("E223: recursive mapping"));
if (State & CMDLINE)
redrawcmdline();
else
setcursor();
flush_buffers(FALSE);
mapdepth = 0; /* for next one */
c = -1;
break;
}
/*
* In Select mode and a Visual mode mapping is used:
* Switch to Visual mode temporarily. Append K_SELECT
* to switch back to Select mode.
*/
if (VIsual_active && VIsual_select
&& (mp->m_mode & VISUAL))
{
VIsual_select = FALSE;
(void)ins_typebuf(K_SELECT_STRING, REMAP_NONE,
0, TRUE, FALSE);
}
#ifdef FEAT_EVAL
/* Copy the values from *mp that are used, because
* evaluating the expression may invoke a function
* that redefines the mapping, thereby making *mp
* invalid. */
save_m_expr = mp->m_expr;
save_m_noremap = mp->m_noremap;
save_m_silent = mp->m_silent;
save_m_keys = NULL; /* only saved when needed */
save_m_str = NULL; /* only saved when needed */
/*
* Handle ":map <expr>": evaluate the {rhs} as an
* expression. Also save and restore the command line
* for "normal :".
*/
if (mp->m_expr)
{
int save_vgetc_busy = vgetc_busy;
vgetc_busy = 0;
save_m_keys = vim_strsave(mp->m_keys);
save_m_str = vim_strsave(mp->m_str);
s = eval_map_expr(save_m_str, NUL);
vgetc_busy = save_vgetc_busy;
}
else
#endif
s = mp->m_str;
/*
* Insert the 'to' part in the typebuf.tb_buf.
* If 'from' field is the same as the start of the
* 'to' field, don't remap the first character (but do
* allow abbreviations).
* If m_noremap is set, don't remap the whole 'to'
* part.
*/
if (s == NULL)
i = FAIL;
else
{
int noremap;
if (save_m_noremap != REMAP_YES)
noremap = save_m_noremap;
else if (
#ifdef FEAT_EVAL
STRNCMP(s, save_m_keys != NULL
? save_m_keys : mp->m_keys,
(size_t)keylen)
#else
STRNCMP(s, mp->m_keys, (size_t)keylen)
#endif
!= 0)
noremap = REMAP_YES;
else
noremap = REMAP_SKIP;
i = ins_typebuf(s, noremap,
0, TRUE, cmd_silent || save_m_silent);
#ifdef FEAT_EVAL
if (save_m_expr)
vim_free(s);
#endif
}
#ifdef FEAT_EVAL
vim_free(save_m_keys);
vim_free(save_m_str);
#endif
if (i == FAIL)
{
c = -1;
break;
}
continue;
}
}
/*
* get a character: 3. from the user - handle <Esc> in Insert mode
*/
/*
* special case: if we get an <ESC> in insert mode and there
* are no more characters at once, we pretend to go out of
* insert mode. This prevents the one second delay after
* typing an <ESC>. If we get something after all, we may
* have to redisplay the mode. That the cursor is in the wrong
* place does not matter.
*/
c = 0;
#ifdef FEAT_CMDL_INFO
new_wcol = curwin->w_wcol;
new_wrow = curwin->w_wrow;
#endif
if ( advance
&& typebuf.tb_len == 1
&& typebuf.tb_buf[typebuf.tb_off] == ESC
&& !no_mapping
#ifdef FEAT_EX_EXTRA
&& ex_normal_busy == 0
#endif
&& typebuf.tb_maplen == 0
&& (State & INSERT)
&& (p_timeout
|| (keylen == KEYLEN_PART_KEY && p_ttimeout))
&& (c = inchar(typebuf.tb_buf + typebuf.tb_off
+ typebuf.tb_len, 3, 25L,
typebuf.tb_change_cnt)) == 0)
{
colnr_T col = 0, vcol;
char_u *ptr;
if (mode_displayed)
{
unshowmode(TRUE);
mode_deleted = TRUE;
}
#ifdef FEAT_GUI
/* may show different cursor shape */
if (gui.in_use)
{
int save_State;
save_State = State;
State = NORMAL;
gui_update_cursor(TRUE, FALSE);
State = save_State;
shape_changed = TRUE;
}
#endif
validate_cursor();
old_wcol = curwin->w_wcol;
old_wrow = curwin->w_wrow;
/* move cursor left, if possible */
if (curwin->w_cursor.col != 0)
{
if (curwin->w_wcol > 0)
{
if (did_ai)
{
/*
* We are expecting to truncate the trailing
* white-space, so find the last non-white
* character -- webb
*/
col = vcol = curwin->w_wcol = 0;
ptr = ml_get_curline();
while (col < curwin->w_cursor.col)
{
if (!vim_iswhite(ptr[col]))
curwin->w_wcol = vcol;
vcol += lbr_chartabsize(ptr + col,
(colnr_T)vcol);
#ifdef FEAT_MBYTE
if (has_mbyte)
col += (*mb_ptr2len)(ptr + col);
else
#endif
++col;
}
curwin->w_wrow = curwin->w_cline_row
+ curwin->w_wcol / W_WIDTH(curwin);
curwin->w_wcol %= W_WIDTH(curwin);
curwin->w_wcol += curwin_col_off();
#ifdef FEAT_MBYTE
col = 0; /* no correction needed */
#endif
}
else
{
--curwin->w_wcol;
#ifdef FEAT_MBYTE
col = curwin->w_cursor.col - 1;
#endif
}
}
else if (curwin->w_p_wrap && curwin->w_wrow)
{
--curwin->w_wrow;
curwin->w_wcol = W_WIDTH(curwin) - 1;
#ifdef FEAT_MBYTE
col = curwin->w_cursor.col - 1;
#endif
}
#ifdef FEAT_MBYTE
if (has_mbyte && col > 0 && curwin->w_wcol > 0)
{
/* Correct when the cursor is on the right halve
* of a double-wide character. */
ptr = ml_get_curline();
col -= (*mb_head_off)(ptr, ptr + col);
if ((*mb_ptr2cells)(ptr + col) > 1)
--curwin->w_wcol;
}
#endif
}
setcursor();
out_flush();
#ifdef FEAT_CMDL_INFO
new_wcol = curwin->w_wcol;
new_wrow = curwin->w_wrow;
#endif
curwin->w_wcol = old_wcol;
curwin->w_wrow = old_wrow;
}
if (c < 0)
continue; /* end of input script reached */
typebuf.tb_len += c;
/* buffer full, don't map */
if (typebuf.tb_len >= typebuf.tb_maplen + MAXMAPLEN)
{
timedout = TRUE;
continue;
}
#ifdef FEAT_EX_EXTRA
if (ex_normal_busy > 0)
{
# ifdef FEAT_CMDWIN
static int tc = 0;
# endif
/* No typeahead left and inside ":normal". Must return
* something to avoid getting stuck. When an incomplete
* mapping is present, behave like it timed out. */
if (typebuf.tb_len > 0)
{
timedout = TRUE;
continue;
}
/* When 'insertmode' is set, ESC just beeps in Insert
* mode. Use CTRL-L to make edit() return.
* For the command line only CTRL-C always breaks it.
* For the cmdline window: Alternate between ESC and
* CTRL-C: ESC for most situations and CTRL-C to close the
* cmdline window. */
if (p_im && (State & INSERT))
c = Ctrl_L;
else if ((State & CMDLINE)
# ifdef FEAT_CMDWIN
|| (cmdwin_type > 0 && tc == ESC)
# endif
)
c = Ctrl_C;
else
c = ESC;
# ifdef FEAT_CMDWIN
tc = c;
# endif
break;
}
#endif
/*
* get a character: 3. from the user - update display
*/
/* In insert mode a screen update is skipped when characters
* are still available. But when those available characters
* are part of a mapping, and we are going to do a blocking
* wait here. Need to update the screen to display the
* changed text so far. Also for when 'lazyredraw' is set and
* redrawing was postponed because there was something in the
* input buffer (e.g., termresponse). */
if (((State & INSERT) != 0 || p_lz) && (State & CMDLINE) == 0
&& advance && must_redraw != 0 && !need_wait_return)
{
update_screen(0);
setcursor(); /* put cursor back where it belongs */
}
/*
* If we have a partial match (and are going to wait for more
* input from the user), show the partially matched characters
* to the user with showcmd.
*/
#ifdef FEAT_CMDL_INFO
i = 0;
#endif
c1 = 0;
if (typebuf.tb_len > 0 && advance && !exmode_active)
{
if (((State & (NORMAL | INSERT)) || State == LANGMAP)
&& State != HITRETURN)
{
/* this looks nice when typing a dead character map */
if (State & INSERT
&& ptr2cells(typebuf.tb_buf + typebuf.tb_off
+ typebuf.tb_len - 1) == 1)
{
edit_putchar(typebuf.tb_buf[typebuf.tb_off
+ typebuf.tb_len - 1], FALSE);
setcursor(); /* put cursor back where it belongs */
c1 = 1;
}
#ifdef FEAT_CMDL_INFO
/* need to use the col and row from above here */
old_wcol = curwin->w_wcol;
old_wrow = curwin->w_wrow;
curwin->w_wcol = new_wcol;
curwin->w_wrow = new_wrow;
push_showcmd();
if (typebuf.tb_len > SHOWCMD_COLS)
i = typebuf.tb_len - SHOWCMD_COLS;
while (i < typebuf.tb_len)
(void)add_to_showcmd(typebuf.tb_buf[typebuf.tb_off
+ i++]);
curwin->w_wcol = old_wcol;
curwin->w_wrow = old_wrow;
#endif
}
/* this looks nice when typing a dead character map */
if ((State & CMDLINE)
#if defined(FEAT_CRYPT) || defined(FEAT_EVAL)
&& cmdline_star == 0
#endif
&& ptr2cells(typebuf.tb_buf + typebuf.tb_off
+ typebuf.tb_len - 1) == 1)
{
putcmdline(typebuf.tb_buf[typebuf.tb_off
+ typebuf.tb_len - 1], FALSE);
c1 = 1;
}
}
/*
* get a character: 3. from the user - get it
*/
wait_tb_len = typebuf.tb_len;
c = inchar(typebuf.tb_buf + typebuf.tb_off + typebuf.tb_len,
typebuf.tb_buflen - typebuf.tb_off - typebuf.tb_len - 1,
!advance
? 0
: ((typebuf.tb_len == 0
|| !(p_timeout || (p_ttimeout
&& keylen == KEYLEN_PART_KEY)))
? -1L
: ((keylen == KEYLEN_PART_KEY && p_ttm >= 0)
? p_ttm
: p_tm)), typebuf.tb_change_cnt);
#ifdef FEAT_CMDL_INFO
if (i != 0)
pop_showcmd();
#endif
if (c1 == 1)
{
if (State & INSERT)
edit_unputchar();
if (State & CMDLINE)
unputcmdline();
else
setcursor(); /* put cursor back where it belongs */
}
if (c < 0)
continue; /* end of input script reached */
if (c == NUL) /* no character available */
{
if (!advance)
break;
if (wait_tb_len > 0) /* timed out */
{
timedout = TRUE;
continue;
}
}
else
{ /* allow mapping for just typed characters */
while (typebuf.tb_buf[typebuf.tb_off
+ typebuf.tb_len] != NUL)
typebuf.tb_noremap[typebuf.tb_off
+ typebuf.tb_len++] = RM_YES;
#ifdef USE_IM_CONTROL
/* Get IM status right after getting keys, not after the
* timeout for a mapping (focus may be lost by then). */
vgetc_im_active = im_get_status();
#endif
}
} /* for (;;) */
} /* if (!character from stuffbuf) */
/* if advance is FALSE don't loop on NULs */
} while (c < 0 || (advance && c == NUL));
/*
* The "INSERT" message is taken care of here:
* if we return an ESC to exit insert mode, the message is deleted
* if we don't return an ESC but deleted the message before, redisplay it
*/
if (advance && p_smd && msg_silent == 0 && (State & INSERT))
{
if (c == ESC && !mode_deleted && !no_mapping && mode_displayed)
{
if (typebuf.tb_len && !KeyTyped)
redraw_cmdline = TRUE; /* delete mode later */
else
unshowmode(FALSE);
}
else if (c != ESC && mode_deleted)
{
if (typebuf.tb_len && !KeyTyped)
redraw_cmdline = TRUE; /* show mode later */
else
showmode();
}
}
#ifdef FEAT_GUI
/* may unshow different cursor shape */
if (gui.in_use && shape_changed)
gui_update_cursor(TRUE, FALSE);
#endif
--vgetc_busy;
return c;
}
/*
* inchar() - get one character from
* 1. a scriptfile
* 2. the keyboard
*
* As much characters as we can get (upto 'maxlen') are put in "buf" and
* NUL terminated (buffer length must be 'maxlen' + 1).
* Minimum for "maxlen" is 3!!!!
*
* "tb_change_cnt" is the value of typebuf.tb_change_cnt if "buf" points into
* it. When typebuf.tb_change_cnt changes (e.g., when a message is received
* from a remote client) "buf" can no longer be used. "tb_change_cnt" is 0
* otherwise.
*
* If we got an interrupt all input is read until none is available.
*
* If wait_time == 0 there is no waiting for the char.
* If wait_time == n we wait for n msec for a character to arrive.
* If wait_time == -1 we wait forever for a character to arrive.
*
* Return the number of obtained characters.
* Return -1 when end of input script reached.
*/
int
inchar(buf, maxlen, wait_time, tb_change_cnt)
char_u *buf;
int maxlen;
long wait_time; /* milli seconds */
int tb_change_cnt;
{
int len = 0; /* init for GCC */
int retesc = FALSE; /* return ESC with gotint */
int script_char;
if (wait_time == -1L || wait_time > 100L) /* flush output before waiting */
{
cursor_on();
out_flush();
#ifdef FEAT_GUI
if (gui.in_use)
{
gui_update_cursor(FALSE, FALSE);
# ifdef FEAT_MOUSESHAPE
if (postponed_mouseshape)
update_mouseshape(-1);
# endif
}
#endif
}
/*
* Don't reset these when at the hit-return prompt, otherwise a endless
* recursive loop may result (write error in swapfile, hit-return, timeout
* on char wait, flush swapfile, write error....).
*/
if (State != HITRETURN)
{
did_outofmem_msg = FALSE; /* display out of memory message (again) */
did_swapwrite_msg = FALSE; /* display swap file write error again */
}
undo_off = FALSE; /* restart undo now */
/*
* Get a character from a script file if there is one.
* If interrupted: Stop reading script files, close them all.
*/
script_char = -1;
while (scriptin[curscript] != NULL && script_char < 0
#ifdef FEAT_EVAL
&& !ignore_script
#endif
)
{
#if defined(FEAT_NETBEANS_INTG)
/* Process the queued netbeans messages. */
netbeans_parse_messages();
#endif
if (got_int || (script_char = getc(scriptin[curscript])) < 0)
{
/* Reached EOF.
* Careful: closescript() frees typebuf.tb_buf[] and buf[] may
* point inside typebuf.tb_buf[]. Don't use buf[] after this! */
closescript();
/*
* When reading script file is interrupted, return an ESC to get
* back to normal mode.
* Otherwise return -1, because typebuf.tb_buf[] has changed.
*/
if (got_int)
retesc = TRUE;
else
return -1;
}
else
{
buf[0] = script_char;
len = 1;
}
}
if (script_char < 0) /* did not get a character from script */
{
/*
* If we got an interrupt, skip all previously typed characters and
* return TRUE if quit reading script file.
* Stop reading typeahead when a single CTRL-C was read,
* fill_input_buf() returns this when not able to read from stdin.
* Don't use buf[] here, closescript() may have freed typebuf.tb_buf[]
* and buf may be pointing inside typebuf.tb_buf[].
*/
if (got_int)
{
#define DUM_LEN MAXMAPLEN * 3 + 3
char_u dum[DUM_LEN + 1];
for (;;)
{
len = ui_inchar(dum, DUM_LEN, 0L, 0);
if (len == 0 || (len == 1 && dum[0] == 3))
break;
}
return retesc;
}
/*
* Always flush the output characters when getting input characters
* from the user.
*/
out_flush();
/*
* Fill up to a third of the buffer, because each character may be
* tripled below.
*/
len = ui_inchar(buf, maxlen / 3, wait_time, tb_change_cnt);
}
if (typebuf_changed(tb_change_cnt))
return 0;
return fix_input_buffer(buf, len, script_char >= 0);
}
/*
* Fix typed characters for use by vgetc() and check_termcode().
* buf[] must have room to triple the number of bytes!
* Returns the new length.
*/
int
fix_input_buffer(buf, len, script)
char_u *buf;
int len;
int script; /* TRUE when reading from a script */
{
int i;
char_u *p = buf;
/*
* Two characters are special: NUL and K_SPECIAL.
* When compiled With the GUI CSI is also special.
* Replace NUL by K_SPECIAL KS_ZERO KE_FILLER
* Replace K_SPECIAL by K_SPECIAL KS_SPECIAL KE_FILLER
* Replace CSI by K_SPECIAL KS_EXTRA KE_CSI
* Don't replace K_SPECIAL when reading a script file.
*/
for (i = len; --i >= 0; ++p)
{
#ifdef FEAT_GUI
/* When the GUI is used any character can come after a CSI, don't
* escape it. */
if (gui.in_use && p[0] == CSI && i >= 2)
{
p += 2;
i -= 2;
}
/* When the GUI is not used CSI needs to be escaped. */
else if (!gui.in_use && p[0] == CSI)
{
mch_memmove(p + 3, p + 1, (size_t)i);
*p++ = K_SPECIAL;
*p++ = KS_EXTRA;
*p = (int)KE_CSI;
len += 2;
}
else
#endif
if (p[0] == NUL || (p[0] == K_SPECIAL && !script
#ifdef FEAT_AUTOCMD
/* timeout may generate K_CURSORHOLD */
&& (i < 2 || p[1] != KS_EXTRA || p[2] != (int)KE_CURSORHOLD)
#endif
#if defined(WIN3264) && !defined(FEAT_GUI)
/* Win32 console passes modifiers */
&& (i < 2 || p[1] != KS_MODIFIER)
#endif
))
{
mch_memmove(p + 3, p + 1, (size_t)i);
p[2] = K_THIRD(p[0]);
p[1] = K_SECOND(p[0]);
p[0] = K_SPECIAL;
p += 2;
len += 2;
}
}
*p = NUL; /* add trailing NUL */
return len;
}
#if defined(USE_INPUT_BUF) || defined(PROTO)
/*
* Return TRUE when bytes are in the input buffer or in the typeahead buffer.
* Normally the input buffer would be sufficient, but the server_to_input_buf()
* or feedkeys() may insert characters in the typeahead buffer while we are
* waiting for input to arrive.
*/
int
input_available()
{
return (!vim_is_input_buf_empty()
# if defined(FEAT_CLIENTSERVER) || defined(FEAT_EVAL)
|| typebuf_was_filled
# endif
);
}
#endif
/*
* map[!] : show all key mappings
* map[!] {lhs} : show key mapping for {lhs}
* map[!] {lhs} {rhs} : set key mapping for {lhs} to {rhs}
* noremap[!] {lhs} {rhs} : same, but no remapping for {rhs}
* unmap[!] {lhs} : remove key mapping for {lhs}
* abbr : show all abbreviations
* abbr {lhs} : show abbreviations for {lhs}
* abbr {lhs} {rhs} : set abbreviation for {lhs} to {rhs}
* noreabbr {lhs} {rhs} : same, but no remapping for {rhs}
* unabbr {lhs} : remove abbreviation for {lhs}
*
* maptype: 0 for :map, 1 for :unmap, 2 for noremap.
*
* arg is pointer to any arguments. Note: arg cannot be a read-only string,
* it will be modified.
*
* for :map mode is NORMAL + VISUAL + SELECTMODE + OP_PENDING
* for :map! mode is INSERT + CMDLINE
* for :cmap mode is CMDLINE
* for :imap mode is INSERT
* for :lmap mode is LANGMAP
* for :nmap mode is NORMAL
* for :vmap mode is VISUAL + SELECTMODE
* for :xmap mode is VISUAL
* for :smap mode is SELECTMODE
* for :omap mode is OP_PENDING
*
* for :abbr mode is INSERT + CMDLINE
* for :iabbr mode is INSERT
* for :cabbr mode is CMDLINE
*
* Return 0 for success
* 1 for invalid arguments
* 2 for no match
* 4 for out of mem
* 5 for entry not unique
*/
int
do_map(maptype, arg, mode, abbrev)
int maptype;
char_u *arg;
int mode;
int abbrev; /* not a mapping but an abbreviation */
{
char_u *keys;
mapblock_T *mp, **mpp;
char_u *rhs;
char_u *p;
int n;
int len = 0; /* init for GCC */
char_u *newstr;
int hasarg;
int haskey;
int did_it = FALSE;
#ifdef FEAT_LOCALMAP
int did_local = FALSE;
#endif
int round;
char_u *keys_buf = NULL;
char_u *arg_buf = NULL;
int retval = 0;
int do_backslash;
int hash;
int new_hash;
mapblock_T **abbr_table;
mapblock_T **map_table;
int unique = FALSE;
int nowait = FALSE;
int silent = FALSE;
int special = FALSE;
#ifdef FEAT_EVAL
int expr = FALSE;
#endif
int noremap;
char_u *orig_rhs;
keys = arg;
map_table = maphash;
abbr_table = &first_abbr;
/* For ":noremap" don't remap, otherwise do remap. */
if (maptype == 2)
noremap = REMAP_NONE;
else
noremap = REMAP_YES;
/* Accept <buffer>, <nowait>, <silent>, <expr> <script> and <unique> in
* any order. */
for (;;)
{
#ifdef FEAT_LOCALMAP
/*
* Check for "<buffer>": mapping local to buffer.
*/
if (STRNCMP(keys, "<buffer>", 8) == 0)
{
keys = skipwhite(keys + 8);
map_table = curbuf->b_maphash;
abbr_table = &curbuf->b_first_abbr;
continue;
}
#endif
/*
* Check for "<nowait>": don't wait for more characters.
*/
if (STRNCMP(keys, "<nowait>", 8) == 0)
{
keys = skipwhite(keys + 8);
nowait = TRUE;
continue;
}
/*
* Check for "<silent>": don't echo commands.
*/
if (STRNCMP(keys, "<silent>", 8) == 0)
{
keys = skipwhite(keys + 8);
silent = TRUE;
continue;
}
/*
* Check for "<special>": accept special keys in <>
*/
if (STRNCMP(keys, "<special>", 9) == 0)
{
keys = skipwhite(keys + 9);
special = TRUE;
continue;
}
#ifdef FEAT_EVAL
/*
* Check for "<script>": remap script-local mappings only
*/
if (STRNCMP(keys, "<script>", 8) == 0)
{
keys = skipwhite(keys + 8);
noremap = REMAP_SCRIPT;
continue;
}
/*
* Check for "<expr>": {rhs} is an expression.
*/
if (STRNCMP(keys, "<expr>", 6) == 0)
{
keys = skipwhite(keys + 6);
expr = TRUE;
continue;
}
#endif
/*
* Check for "<unique>": don't overwrite an existing mapping.
*/
if (STRNCMP(keys, "<unique>", 8) == 0)
{
keys = skipwhite(keys + 8);
unique = TRUE;
continue;
}
break;
}
validate_maphash();
/*
* Find end of keys and skip CTRL-Vs (and backslashes) in it.
* Accept backslash like CTRL-V when 'cpoptions' does not contain 'B'.
* with :unmap white space is included in the keys, no argument possible.
*/
p = keys;
do_backslash = (vim_strchr(p_cpo, CPO_BSLASH) == NULL);
while (*p && (maptype == 1 || !vim_iswhite(*p)))
{
if ((p[0] == Ctrl_V || (do_backslash && p[0] == '\\')) &&
p[1] != NUL)
++p; /* skip CTRL-V or backslash */
++p;
}
if (*p != NUL)
*p++ = NUL;
p = skipwhite(p);
rhs = p;
hasarg = (*rhs != NUL);
haskey = (*keys != NUL);
/* check for :unmap without argument */
if (maptype == 1 && !haskey)
{
retval = 1;
goto theend;
}
/*
* If mapping has been given as ^V<C_UP> say, then replace the term codes
* with the appropriate two bytes. If it is a shifted special key, unshift
* it too, giving another two bytes.
* replace_termcodes() may move the result to allocated memory, which
* needs to be freed later (*keys_buf and *arg_buf).
* replace_termcodes() also removes CTRL-Vs and sometimes backslashes.
*/
if (haskey)
keys = replace_termcodes(keys, &keys_buf, TRUE, TRUE, special);
orig_rhs = rhs;
if (hasarg)
{
if (STRICMP(rhs, "<nop>") == 0) /* "<Nop>" means nothing */
rhs = (char_u *)"";
else
rhs = replace_termcodes(rhs, &arg_buf, FALSE, TRUE, special);
}
#ifdef FEAT_FKMAP
/*
* When in right-to-left mode and alternate keymap option set,
* reverse the character flow in the rhs in Farsi.
*/
if (p_altkeymap && curwin->w_p_rl)
lrswap(rhs);
#endif
/*
* check arguments and translate function keys
*/
if (haskey)
{
len = (int)STRLEN(keys);
if (len > MAXMAPLEN) /* maximum length of MAXMAPLEN chars */
{
retval = 1;
goto theend;
}
if (abbrev && maptype != 1)
{
/*
* If an abbreviation ends in a keyword character, the
* rest must be all keyword-char or all non-keyword-char.
* Otherwise we won't be able to find the start of it in a
* vi-compatible way.
*/
#ifdef FEAT_MBYTE
if (has_mbyte)
{
int first, last;
int same = -1;
first = vim_iswordp(keys);
last = first;
p = keys + (*mb_ptr2len)(keys);
n = 1;
while (p < keys + len)
{
++n; /* nr of (multi-byte) chars */
last = vim_iswordp(p); /* type of last char */
if (same == -1 && last != first)
same = n - 1; /* count of same char type */
p += (*mb_ptr2len)(p);
}
if (last && n > 2 && same >= 0 && same < n - 1)
{
retval = 1;
goto theend;
}
}
else
#endif
if (vim_iswordc(keys[len - 1])) /* ends in keyword char */
for (n = 0; n < len - 2; ++n)
if (vim_iswordc(keys[n]) != vim_iswordc(keys[len - 2]))
{
retval = 1;
goto theend;
}
/* An abbreviation cannot contain white space. */
for (n = 0; n < len; ++n)
if (vim_iswhite(keys[n]))
{
retval = 1;
goto theend;
}
}
}
if (haskey && hasarg && abbrev) /* if we will add an abbreviation */
no_abbr = FALSE; /* reset flag that indicates there are
no abbreviations */
if (!haskey || (maptype != 1 && !hasarg))
msg_start();
#ifdef FEAT_LOCALMAP
/*
* Check if a new local mapping wasn't already defined globally.
*/
if (map_table == curbuf->b_maphash && haskey && hasarg && maptype != 1)
{
/* need to loop over all global hash lists */
for (hash = 0; hash < 256 && !got_int; ++hash)
{
if (abbrev)
{
if (hash != 0) /* there is only one abbreviation list */
break;
mp = first_abbr;
}
else
mp = maphash[hash];
for ( ; mp != NULL && !got_int; mp = mp->m_next)
{
/* check entries with the same mode */
if ((mp->m_mode & mode) != 0
&& mp->m_keylen == len
&& unique
&& STRNCMP(mp->m_keys, keys, (size_t)len) == 0)
{
if (abbrev)
EMSG2(_("E224: global abbreviation already exists for %s"),
mp->m_keys);
else
EMSG2(_("E225: global mapping already exists for %s"),
mp->m_keys);
retval = 5;
goto theend;
}
}
}
}
/*
* When listing global mappings, also list buffer-local ones here.
*/
if (map_table != curbuf->b_maphash && !hasarg && maptype != 1)
{
/* need to loop over all global hash lists */
for (hash = 0; hash < 256 && !got_int; ++hash)
{
if (abbrev)
{
if (hash != 0) /* there is only one abbreviation list */
break;
mp = curbuf->b_first_abbr;
}
else
mp = curbuf->b_maphash[hash];
for ( ; mp != NULL && !got_int; mp = mp->m_next)
{
/* check entries with the same mode */
if ((mp->m_mode & mode) != 0)
{
if (!haskey) /* show all entries */
{
showmap(mp, TRUE);
did_local = TRUE;
}
else
{
n = mp->m_keylen;
if (STRNCMP(mp->m_keys, keys,
(size_t)(n < len ? n : len)) == 0)
{
showmap(mp, TRUE);
did_local = TRUE;
}
}
}
}
}
}
#endif
/*
* Find an entry in the maphash[] list that matches.
* For :unmap we may loop two times: once to try to unmap an entry with a
* matching 'from' part, a second time, if the first fails, to unmap an
* entry with a matching 'to' part. This was done to allow ":ab foo bar"
* to be unmapped by typing ":unab foo", where "foo" will be replaced by
* "bar" because of the abbreviation.
*/
for (round = 0; (round == 0 || maptype == 1) && round <= 1
&& !did_it && !got_int; ++round)
{
/* need to loop over all hash lists */
for (hash = 0; hash < 256 && !got_int; ++hash)
{
if (abbrev)
{
if (hash > 0) /* there is only one abbreviation list */
break;
mpp = abbr_table;
}
else
mpp = &(map_table[hash]);
for (mp = *mpp; mp != NULL && !got_int; mp = *mpp)
{
if (!(mp->m_mode & mode)) /* skip entries with wrong mode */
{
mpp = &(mp->m_next);
continue;
}
if (!haskey) /* show all entries */
{
showmap(mp, map_table != maphash);
did_it = TRUE;
}
else /* do we have a match? */
{
if (round) /* second round: Try unmap "rhs" string */
{
n = (int)STRLEN(mp->m_str);
p = mp->m_str;
}
else
{
n = mp->m_keylen;
p = mp->m_keys;
}
if (STRNCMP(p, keys, (size_t)(n < len ? n : len)) == 0)
{
if (maptype == 1) /* delete entry */
{
/* Only accept a full match. For abbreviations we
* ignore trailing space when matching with the
* "lhs", since an abbreviation can't have
* trailing space. */
if (n != len && (!abbrev || round || n > len
|| *skipwhite(keys + n) != NUL))
{
mpp = &(mp->m_next);
continue;
}
/*
* We reset the indicated mode bits. If nothing is
* left the entry is deleted below.
*/
mp->m_mode &= ~mode;
did_it = TRUE; /* remember we did something */
}
else if (!hasarg) /* show matching entry */
{
showmap(mp, map_table != maphash);
did_it = TRUE;
}
else if (n != len) /* new entry is ambiguous */
{
mpp = &(mp->m_next);
continue;
}
else if (unique)
{
if (abbrev)
EMSG2(_("E226: abbreviation already exists for %s"),
p);
else
EMSG2(_("E227: mapping already exists for %s"), p);
retval = 5;
goto theend;
}
else /* new rhs for existing entry */
{
mp->m_mode &= ~mode; /* remove mode bits */
if (mp->m_mode == 0 && !did_it) /* reuse entry */
{
newstr = vim_strsave(rhs);
if (newstr == NULL)
{
retval = 4; /* no mem */
goto theend;
}
vim_free(mp->m_str);
mp->m_str = newstr;
vim_free(mp->m_orig_str);
mp->m_orig_str = vim_strsave(orig_rhs);
mp->m_noremap = noremap;
mp->m_nowait = nowait;
mp->m_silent = silent;
mp->m_mode = mode;
#ifdef FEAT_EVAL
mp->m_expr = expr;
mp->m_script_ID = current_SID;
#endif
did_it = TRUE;
}
}
if (mp->m_mode == 0) /* entry can be deleted */
{
map_free(mpp);
continue; /* continue with *mpp */
}
/*
* May need to put this entry into another hash list.
*/
new_hash = MAP_HASH(mp->m_mode, mp->m_keys[0]);
if (!abbrev && new_hash != hash)
{
*mpp = mp->m_next;
mp->m_next = map_table[new_hash];
map_table[new_hash] = mp;
continue; /* continue with *mpp */
}
}
}
mpp = &(mp->m_next);
}
}
}
if (maptype == 1) /* delete entry */
{
if (!did_it)
retval = 2; /* no match */
goto theend;
}
if (!haskey || !hasarg) /* print entries */
{
if (!did_it
#ifdef FEAT_LOCALMAP
&& !did_local
#endif
)
{
if (abbrev)
MSG(_("No abbreviation found"));
else
MSG(_("No mapping found"));
}
goto theend; /* listing finished */
}
if (did_it) /* have added the new entry already */
goto theend;
/*
* Get here when adding a new entry to the maphash[] list or abbrlist.
*/
mp = (mapblock_T *)alloc((unsigned)sizeof(mapblock_T));
if (mp == NULL)
{
retval = 4; /* no mem */
goto theend;
}
/* If CTRL-C has been mapped, don't always use it for Interrupting */
if (*keys == Ctrl_C)
mapped_ctrl_c = TRUE;
mp->m_keys = vim_strsave(keys);
mp->m_str = vim_strsave(rhs);
mp->m_orig_str = vim_strsave(orig_rhs);
if (mp->m_keys == NULL || mp->m_str == NULL)
{
vim_free(mp->m_keys);
vim_free(mp->m_str);
vim_free(mp->m_orig_str);
vim_free(mp);
retval = 4; /* no mem */
goto theend;
}
mp->m_keylen = (int)STRLEN(mp->m_keys);
mp->m_noremap = noremap;
mp->m_nowait = nowait;
mp->m_silent = silent;
mp->m_mode = mode;
#ifdef FEAT_EVAL
mp->m_expr = expr;
mp->m_script_ID = current_SID;
#endif
/* add the new entry in front of the abbrlist or maphash[] list */
if (abbrev)
{
mp->m_next = *abbr_table;
*abbr_table = mp;
}
else
{
n = MAP_HASH(mp->m_mode, mp->m_keys[0]);
mp->m_next = map_table[n];
map_table[n] = mp;
}
theend:
vim_free(keys_buf);
vim_free(arg_buf);
return retval;
}
/*
* Delete one entry from the abbrlist or maphash[].
* "mpp" is a pointer to the m_next field of the PREVIOUS entry!
*/
static void
map_free(mpp)
mapblock_T **mpp;
{
mapblock_T *mp;
mp = *mpp;
vim_free(mp->m_keys);
vim_free(mp->m_str);
vim_free(mp->m_orig_str);
*mpp = mp->m_next;
vim_free(mp);
}
/*
* Initialize maphash[] for first use.
*/
static void
validate_maphash()
{
if (!maphash_valid)
{
vim_memset(maphash, 0, sizeof(maphash));
maphash_valid = TRUE;
}
}
/*
* Get the mapping mode from the command name.
*/
int
get_map_mode(cmdp, forceit)
char_u **cmdp;
int forceit;
{
char_u *p;
int modec;
int mode;
p = *cmdp;
modec = *p++;
if (modec == 'i')
mode = INSERT; /* :imap */
else if (modec == 'l')
mode = LANGMAP; /* :lmap */
else if (modec == 'c')
mode = CMDLINE; /* :cmap */
else if (modec == 'n' && *p != 'o') /* avoid :noremap */
mode = NORMAL; /* :nmap */
else if (modec == 'v')
mode = VISUAL + SELECTMODE; /* :vmap */
else if (modec == 'x')
mode = VISUAL; /* :xmap */
else if (modec == 's')
mode = SELECTMODE; /* :smap */
else if (modec == 'o')
mode = OP_PENDING; /* :omap */
else
{
--p;
if (forceit)
mode = INSERT + CMDLINE; /* :map ! */
else
mode = VISUAL + SELECTMODE + NORMAL + OP_PENDING;/* :map */
}
*cmdp = p;
return mode;
}
/*
* Clear all mappings or abbreviations.
* 'abbr' should be FALSE for mappings, TRUE for abbreviations.
*/
void
map_clear(cmdp, arg, forceit, abbr)
char_u *cmdp;
char_u *arg UNUSED;
int forceit;
int abbr;
{
int mode;
#ifdef FEAT_LOCALMAP
int local;
local = (STRCMP(arg, "<buffer>") == 0);
if (!local && *arg != NUL)
{
EMSG(_(e_invarg));
return;
}
#endif
mode = get_map_mode(&cmdp, forceit);
map_clear_int(curbuf, mode,
#ifdef FEAT_LOCALMAP
local,
#else
FALSE,
#endif
abbr);
}
/*
* Clear all mappings in "mode".
*/
void
map_clear_int(buf, mode, local, abbr)
buf_T *buf UNUSED; /* buffer for local mappings */
int mode; /* mode in which to delete */
int local UNUSED; /* TRUE for buffer-local mappings */
int abbr; /* TRUE for abbreviations */
{
mapblock_T *mp, **mpp;
int hash;
int new_hash;
validate_maphash();
for (hash = 0; hash < 256; ++hash)
{
if (abbr)
{
if (hash > 0) /* there is only one abbrlist */
break;
#ifdef FEAT_LOCALMAP
if (local)
mpp = &buf->b_first_abbr;
else
#endif
mpp = &first_abbr;
}
else
{
#ifdef FEAT_LOCALMAP
if (local)
mpp = &buf->b_maphash[hash];
else
#endif
mpp = &maphash[hash];
}
while (*mpp != NULL)
{
mp = *mpp;
if (mp->m_mode & mode)
{
mp->m_mode &= ~mode;
if (mp->m_mode == 0) /* entry can be deleted */
{
map_free(mpp);
continue;
}
/*
* May need to put this entry into another hash list.
*/
new_hash = MAP_HASH(mp->m_mode, mp->m_keys[0]);
if (!abbr && new_hash != hash)
{
*mpp = mp->m_next;
#ifdef FEAT_LOCALMAP
if (local)
{
mp->m_next = buf->b_maphash[new_hash];
buf->b_maphash[new_hash] = mp;
}
else
#endif
{
mp->m_next = maphash[new_hash];
maphash[new_hash] = mp;
}
continue; /* continue with *mpp */
}
}
mpp = &(mp->m_next);
}
}
}
/*
* Return characters to represent the map mode in an allocated string.
* Returns NULL when out of memory.
*/
char_u *
map_mode_to_chars(mode)
int mode;
{
garray_T mapmode;
ga_init2(&mapmode, 1, 7);
if ((mode & (INSERT + CMDLINE)) == INSERT + CMDLINE)
ga_append(&mapmode, '!'); /* :map! */
else if (mode & INSERT)
ga_append(&mapmode, 'i'); /* :imap */
else if (mode & LANGMAP)
ga_append(&mapmode, 'l'); /* :lmap */
else if (mode & CMDLINE)
ga_append(&mapmode, 'c'); /* :cmap */
else if ((mode & (NORMAL + VISUAL + SELECTMODE + OP_PENDING))
== NORMAL + VISUAL + SELECTMODE + OP_PENDING)
ga_append(&mapmode, ' '); /* :map */
else
{
if (mode & NORMAL)
ga_append(&mapmode, 'n'); /* :nmap */
if (mode & OP_PENDING)
ga_append(&mapmode, 'o'); /* :omap */
if ((mode & (VISUAL + SELECTMODE)) == VISUAL + SELECTMODE)
ga_append(&mapmode, 'v'); /* :vmap */
else
{
if (mode & VISUAL)
ga_append(&mapmode, 'x'); /* :xmap */
if (mode & SELECTMODE)
ga_append(&mapmode, 's'); /* :smap */
}
}
ga_append(&mapmode, NUL);
return (char_u *)mapmode.ga_data;
}
static void
showmap(mp, local)
mapblock_T *mp;
int local; /* TRUE for buffer-local map */
{
int len = 1;
char_u *mapchars;
if (msg_didout || msg_silent != 0)
{
msg_putchar('\n');
if (got_int) /* 'q' typed at MORE prompt */
return;
}
mapchars = map_mode_to_chars(mp->m_mode);
if (mapchars != NULL)
{
msg_puts(mapchars);
len = (int)STRLEN(mapchars);
vim_free(mapchars);
}
while (++len <= 3)
msg_putchar(' ');
/* Display the LHS. Get length of what we write. */
len = msg_outtrans_special(mp->m_keys, TRUE);
do
{
msg_putchar(' '); /* padd with blanks */
++len;
} while (len < 12);
if (mp->m_noremap == REMAP_NONE)
msg_puts_attr((char_u *)"*", hl_attr(HLF_8));
else if (mp->m_noremap == REMAP_SCRIPT)
msg_puts_attr((char_u *)"&", hl_attr(HLF_8));
else
msg_putchar(' ');
if (local)
msg_putchar('@');
else
msg_putchar(' ');
/* Use FALSE below if we only want things like <Up> to show up as such on
* the rhs, and not M-x etc, TRUE gets both -- webb */
if (*mp->m_str == NUL)
msg_puts_attr((char_u *)"<Nop>", hl_attr(HLF_8));
else
{
/* Remove escaping of CSI, because "m_str" is in a format to be used
* as typeahead. */
char_u *s = vim_strsave(mp->m_str);
if (s != NULL)
{
vim_unescape_csi(s);
msg_outtrans_special(s, FALSE);
vim_free(s);
}
}
#ifdef FEAT_EVAL
if (p_verbose > 0)
last_set_msg(mp->m_script_ID);
#endif
out_flush(); /* show one line at a time */
}
#if defined(FEAT_EVAL) || defined(PROTO)
/*
* Return TRUE if a map exists that has "str" in the rhs for mode "modechars".
* Recognize termcap codes in "str".
* Also checks mappings local to the current buffer.
*/
int
map_to_exists(str, modechars, abbr)
char_u *str;
char_u *modechars;
int abbr;
{
int mode = 0;
char_u *rhs;
char_u *buf;
int retval;
rhs = replace_termcodes(str, &buf, FALSE, TRUE, FALSE);
if (vim_strchr(modechars, 'n') != NULL)
mode |= NORMAL;
if (vim_strchr(modechars, 'v') != NULL)
mode |= VISUAL + SELECTMODE;
if (vim_strchr(modechars, 'x') != NULL)
mode |= VISUAL;
if (vim_strchr(modechars, 's') != NULL)
mode |= SELECTMODE;
if (vim_strchr(modechars, 'o') != NULL)
mode |= OP_PENDING;
if (vim_strchr(modechars, 'i') != NULL)
mode |= INSERT;
if (vim_strchr(modechars, 'l') != NULL)
mode |= LANGMAP;
if (vim_strchr(modechars, 'c') != NULL)
mode |= CMDLINE;
retval = map_to_exists_mode(rhs, mode, abbr);
vim_free(buf);
return retval;
}
#endif
/*
* Return TRUE if a map exists that has "str" in the rhs for mode "mode".
* Also checks mappings local to the current buffer.
*/
int
map_to_exists_mode(rhs, mode, abbr)
char_u *rhs;
int mode;
int abbr;
{
mapblock_T *mp;
int hash;
# ifdef FEAT_LOCALMAP
int expand_buffer = FALSE;
validate_maphash();
/* Do it twice: once for global maps and once for local maps. */
for (;;)
{
# endif
for (hash = 0; hash < 256; ++hash)
{
if (abbr)
{
if (hash > 0) /* there is only one abbr list */
break;
#ifdef FEAT_LOCALMAP
if (expand_buffer)
mp = curbuf->b_first_abbr;
else
#endif
mp = first_abbr;
}
# ifdef FEAT_LOCALMAP
else if (expand_buffer)
mp = curbuf->b_maphash[hash];
# endif
else
mp = maphash[hash];
for (; mp; mp = mp->m_next)
{
if ((mp->m_mode & mode)
&& strstr((char *)mp->m_str, (char *)rhs) != NULL)
return TRUE;
}
}
# ifdef FEAT_LOCALMAP
if (expand_buffer)
break;
expand_buffer = TRUE;
}
# endif
return FALSE;
}
#if defined(FEAT_CMDL_COMPL) || defined(PROTO)
/*
* Used below when expanding mapping/abbreviation names.
*/
static int expand_mapmodes = 0;
static int expand_isabbrev = 0;
#ifdef FEAT_LOCALMAP
static int expand_buffer = FALSE;
#endif
/*
* Work out what to complete when doing command line completion of mapping
* or abbreviation names.
*/
char_u *
set_context_in_map_cmd(xp, cmd, arg, forceit, isabbrev, isunmap, cmdidx)
expand_T *xp;
char_u *cmd;
char_u *arg;
int forceit; /* TRUE if '!' given */
int isabbrev; /* TRUE if abbreviation */
int isunmap; /* TRUE if unmap/unabbrev command */
cmdidx_T cmdidx;
{
if (forceit && cmdidx != CMD_map && cmdidx != CMD_unmap)
xp->xp_context = EXPAND_NOTHING;
else
{
if (isunmap)
expand_mapmodes = get_map_mode(&cmd, forceit || isabbrev);
else
{
expand_mapmodes = INSERT + CMDLINE;
if (!isabbrev)
expand_mapmodes += VISUAL + SELECTMODE + NORMAL + OP_PENDING;
}
expand_isabbrev = isabbrev;
xp->xp_context = EXPAND_MAPPINGS;
#ifdef FEAT_LOCALMAP
expand_buffer = FALSE;
#endif
for (;;)
{
#ifdef FEAT_LOCALMAP
if (STRNCMP(arg, "<buffer>", 8) == 0)
{
expand_buffer = TRUE;
arg = skipwhite(arg + 8);
continue;
}
#endif
if (STRNCMP(arg, "<unique>", 8) == 0)
{
arg = skipwhite(arg + 8);
continue;
}
if (STRNCMP(arg, "<nowait>", 8) == 0)
{
arg = skipwhite(arg + 8);
continue;
}
if (STRNCMP(arg, "<silent>", 8) == 0)
{
arg = skipwhite(arg + 8);
continue;
}
#ifdef FEAT_EVAL
if (STRNCMP(arg, "<script>", 8) == 0)
{
arg = skipwhite(arg + 8);
continue;
}
if (STRNCMP(arg, "<expr>", 6) == 0)
{
arg = skipwhite(arg + 6);
continue;
}
#endif
break;
}
xp->xp_pattern = arg;
}
return NULL;
}
/*
* Find all mapping/abbreviation names that match regexp 'prog'.
* For command line expansion of ":[un]map" and ":[un]abbrev" in all modes.
* Return OK if matches found, FAIL otherwise.
*/
int
ExpandMappings(regmatch, num_file, file)
regmatch_T *regmatch;
int *num_file;
char_u ***file;
{
mapblock_T *mp;
int hash;
int count;
int round;
char_u *p;
int i;
validate_maphash();
*num_file = 0; /* return values in case of FAIL */
*file = NULL;
/*
* round == 1: Count the matches.
* round == 2: Build the array to keep the matches.
*/
for (round = 1; round <= 2; ++round)
{
count = 0;
for (i = 0; i < 6; ++i)
{
if (i == 0)
p = (char_u *)"<silent>";
else if (i == 1)
p = (char_u *)"<unique>";
#ifdef FEAT_EVAL
else if (i == 2)
p = (char_u *)"<script>";
else if (i == 3)
p = (char_u *)"<expr>";
#endif
#ifdef FEAT_LOCALMAP
else if (i == 4 && !expand_buffer)
p = (char_u *)"<buffer>";
#endif
else if (i == 5)
p = (char_u *)"<nowait>";
else
continue;
if (vim_regexec(regmatch, p, (colnr_T)0))
{
if (round == 1)
++count;
else
(*file)[count++] = vim_strsave(p);
}
}
for (hash = 0; hash < 256; ++hash)
{
if (expand_isabbrev)
{
if (hash > 0) /* only one abbrev list */
break; /* for (hash) */
mp = first_abbr;
}
#ifdef FEAT_LOCALMAP
else if (expand_buffer)
mp = curbuf->b_maphash[hash];
#endif
else
mp = maphash[hash];
for (; mp; mp = mp->m_next)
{
if (mp->m_mode & expand_mapmodes)
{
p = translate_mapping(mp->m_keys, TRUE);
if (p != NULL && vim_regexec(regmatch, p, (colnr_T)0))
{
if (round == 1)
++count;
else
{
(*file)[count++] = p;
p = NULL;
}
}
vim_free(p);
}
} /* for (mp) */
} /* for (hash) */
if (count == 0) /* no match found */
break; /* for (round) */
if (round == 1)
{
*file = (char_u **)alloc((unsigned)(count * sizeof(char_u *)));
if (*file == NULL)
return FAIL;
}
} /* for (round) */
if (count > 1)
{
char_u **ptr1;
char_u **ptr2;
char_u **ptr3;
/* Sort the matches */
sort_strings(*file, count);
/* Remove multiple entries */
ptr1 = *file;
ptr2 = ptr1 + 1;
ptr3 = ptr1 + count;
while (ptr2 < ptr3)
{
if (STRCMP(*ptr1, *ptr2))
*++ptr1 = *ptr2++;
else
{
vim_free(*ptr2++);
count--;
}
}
}
*num_file = count;
return (count == 0 ? FAIL : OK);
}
#endif /* FEAT_CMDL_COMPL */
/*
* Check for an abbreviation.
* Cursor is at ptr[col]. When inserting, mincol is where insert started.
* "c" is the character typed before check_abbr was called. It may have
* ABBR_OFF added to avoid prepending a CTRL-V to it.
*
* Historic vi practice: The last character of an abbreviation must be an id
* character ([a-zA-Z0-9_]). The characters in front of it must be all id
* characters or all non-id characters. This allows for abbr. "#i" to
* "#include".
*
* Vim addition: Allow for abbreviations that end in a non-keyword character.
* Then there must be white space before the abbr.
*
* return TRUE if there is an abbreviation, FALSE if not
*/
int
check_abbr(c, ptr, col, mincol)
int c;
char_u *ptr;
int col;
int mincol;
{
int len;
int scol; /* starting column of the abbr. */
int j;
char_u *s;
char_u tb[MB_MAXBYTES + 4];
mapblock_T *mp;
#ifdef FEAT_LOCALMAP
mapblock_T *mp2;
#endif
#ifdef FEAT_MBYTE
int clen = 0; /* length in characters */
#endif
int is_id = TRUE;
int vim_abbr;
if (typebuf.tb_no_abbr_cnt) /* abbrev. are not recursive */
return FALSE;
/* no remapping implies no abbreviation, except for CTRL-] */
if ((KeyNoremap & (RM_NONE|RM_SCRIPT)) != 0 && c != Ctrl_RSB)
return FALSE;
/*
* Check for word before the cursor: If it ends in a keyword char all
* chars before it must be keyword chars or non-keyword chars, but not
* white space. If it ends in a non-keyword char we accept any characters
* before it except white space.
*/
if (col == 0) /* cannot be an abbr. */
return FALSE;
#ifdef FEAT_MBYTE
if (has_mbyte)
{
char_u *p;
p = mb_prevptr(ptr, ptr + col);
if (!vim_iswordp(p))
vim_abbr = TRUE; /* Vim added abbr. */
else
{
vim_abbr = FALSE; /* vi compatible abbr. */
if (p > ptr)
is_id = vim_iswordp(mb_prevptr(ptr, p));
}
clen = 1;
while (p > ptr + mincol)
{
p = mb_prevptr(ptr, p);
if (vim_isspace(*p) || (!vim_abbr && is_id != vim_iswordp(p)))
{
p += (*mb_ptr2len)(p);
break;
}
++clen;
}
scol = (int)(p - ptr);
}
else
#endif
{
if (!vim_iswordc(ptr[col - 1]))
vim_abbr = TRUE; /* Vim added abbr. */
else
{
vim_abbr = FALSE; /* vi compatible abbr. */
if (col > 1)
is_id = vim_iswordc(ptr[col - 2]);
}
for (scol = col - 1; scol > 0 && !vim_isspace(ptr[scol - 1])
&& (vim_abbr || is_id == vim_iswordc(ptr[scol - 1])); --scol)
;
}
if (scol < mincol)
scol = mincol;
if (scol < col) /* there is a word in front of the cursor */
{
ptr += scol;
len = col - scol;
#ifdef FEAT_LOCALMAP
mp = curbuf->b_first_abbr;
mp2 = first_abbr;
if (mp == NULL)
{
mp = mp2;
mp2 = NULL;
}
#else
mp = first_abbr;
#endif
for ( ; mp;
#ifdef FEAT_LOCALMAP
mp->m_next == NULL ? (mp = mp2, mp2 = NULL) :
#endif
(mp = mp->m_next))
{
/* find entries with right mode and keys */
if ( (mp->m_mode & State)
&& mp->m_keylen == len
&& !STRNCMP(mp->m_keys, ptr, (size_t)len))
break;
}
if (mp != NULL)
{
/*
* Found a match:
* Insert the rest of the abbreviation in typebuf.tb_buf[].
* This goes from end to start.
*
* Characters 0x000 - 0x100: normal chars, may need CTRL-V,
* except K_SPECIAL: Becomes K_SPECIAL KS_SPECIAL KE_FILLER
* Characters where IS_SPECIAL() == TRUE: key codes, need
* K_SPECIAL. Other characters (with ABBR_OFF): don't use CTRL-V.
*
* Character CTRL-] is treated specially - it completes the
* abbreviation, but is not inserted into the input stream.
*/
j = 0;
if (c != Ctrl_RSB)
{
/* special key code, split up */
if (IS_SPECIAL(c) || c == K_SPECIAL)
{
tb[j++] = K_SPECIAL;
tb[j++] = K_SECOND(c);
tb[j++] = K_THIRD(c);
}
else
{
if (c < ABBR_OFF && (c < ' ' || c > '~'))
tb[j++] = Ctrl_V; /* special char needs CTRL-V */
#ifdef FEAT_MBYTE
if (has_mbyte)
{
/* if ABBR_OFF has been added, remove it here */
if (c >= ABBR_OFF)
c -= ABBR_OFF;
j += (*mb_char2bytes)(c, tb + j);
}
else
#endif
tb[j++] = c;
}
tb[j] = NUL;
/* insert the last typed char */
(void)ins_typebuf(tb, 1, 0, TRUE, mp->m_silent);
}
#ifdef FEAT_EVAL
if (mp->m_expr)
s = eval_map_expr(mp->m_str, c);
else
#endif
s = mp->m_str;
if (s != NULL)
{
/* insert the to string */
(void)ins_typebuf(s, mp->m_noremap, 0, TRUE, mp->m_silent);
/* no abbrev. for these chars */
typebuf.tb_no_abbr_cnt += (int)STRLEN(s) + j + 1;
#ifdef FEAT_EVAL
if (mp->m_expr)
vim_free(s);
#endif
}
tb[0] = Ctrl_H;
tb[1] = NUL;
#ifdef FEAT_MBYTE
if (has_mbyte)
len = clen; /* Delete characters instead of bytes */
#endif
while (len-- > 0) /* delete the from string */
(void)ins_typebuf(tb, 1, 0, TRUE, mp->m_silent);
return TRUE;
}
}
return FALSE;
}
#ifdef FEAT_EVAL
/*
* Evaluate the RHS of a mapping or abbreviations and take care of escaping
* special characters.
*/
static char_u *
eval_map_expr(str, c)
char_u *str;
int c; /* NUL or typed character for abbreviation */
{
char_u *res;
char_u *p;
char_u *expr;
char_u *save_cmd;
pos_T save_cursor;
int save_msg_col;
int save_msg_row;
/* Remove escaping of CSI, because "str" is in a format to be used as
* typeahead. */
expr = vim_strsave(str);
if (expr == NULL)
return NULL;
vim_unescape_csi(expr);
save_cmd = save_cmdline_alloc();
if (save_cmd == NULL)
{
vim_free(expr);
return NULL;
}
/* Forbid changing text or using ":normal" to avoid most of the bad side
* effects. Also restore the cursor position. */
++textlock;
#ifdef FEAT_EX_EXTRA
++ex_normal_lock;
#endif
set_vim_var_char(c); /* set v:char to the typed character */
save_cursor = curwin->w_cursor;
save_msg_col = msg_col;
save_msg_row = msg_row;
p = eval_to_string(expr, NULL, FALSE);
--textlock;
#ifdef FEAT_EX_EXTRA
--ex_normal_lock;
#endif
curwin->w_cursor = save_cursor;
msg_col = save_msg_col;
msg_row = save_msg_row;
restore_cmdline_alloc(save_cmd);
vim_free(expr);
if (p == NULL)
return NULL;
/* Escape CSI in the result to be able to use the string as typeahead. */
res = vim_strsave_escape_csi(p);
vim_free(p);
return res;
}
#endif
/*
* Copy "p" to allocated memory, escaping K_SPECIAL and CSI so that the result
* can be put in the typeahead buffer.
* Returns NULL when out of memory.
*/
char_u *
vim_strsave_escape_csi(p)
char_u *p;
{
char_u *res;
char_u *s, *d;
/* Need a buffer to hold up to three times as much. */
res = alloc((unsigned)(STRLEN(p) * 3) + 1);
if (res != NULL)
{
d = res;
for (s = p; *s != NUL; )
{
if (s[0] == K_SPECIAL && s[1] != NUL && s[2] != NUL)
{
/* Copy special key unmodified. */
*d++ = *s++;
*d++ = *s++;
*d++ = *s++;
}
else
{
#ifdef FEAT_MBYTE
int len = mb_char2len(PTR2CHAR(s));
int len2 = mb_ptr2len(s);
#endif
/* Add character, possibly multi-byte to destination, escaping
* CSI and K_SPECIAL. */
d = add_char2buf(PTR2CHAR(s), d);
#ifdef FEAT_MBYTE
while (len < len2)
{
/* add following combining char */
d = add_char2buf(PTR2CHAR(s + len), d);
len += mb_char2len(PTR2CHAR(s + len));
}
#endif
mb_ptr_adv(s);
}
}
*d = NUL;
}
return res;
}
/*
* Remove escaping from CSI and K_SPECIAL characters. Reverse of
* vim_strsave_escape_csi(). Works in-place.
*/
void
vim_unescape_csi(p)
char_u *p;
{
char_u *s = p, *d = p;
while (*s != NUL)
{
if (s[0] == K_SPECIAL && s[1] == KS_SPECIAL && s[2] == KE_FILLER)
{
*d++ = K_SPECIAL;
s += 3;
}
else if ((s[0] == K_SPECIAL || s[0] == CSI)
&& s[1] == KS_EXTRA && s[2] == (int)KE_CSI)
{
*d++ = CSI;
s += 3;
}
else
*d++ = *s++;
}
*d = NUL;
}
/*
* Write map commands for the current mappings to an .exrc file.
* Return FAIL on error, OK otherwise.
*/
int
makemap(fd, buf)
FILE *fd;
buf_T *buf; /* buffer for local mappings or NULL */
{
mapblock_T *mp;
char_u c1, c2, c3;
char_u *p;
char *cmd;
int abbr;
int hash;
int did_cpo = FALSE;
int i;
validate_maphash();
/*
* Do the loop twice: Once for mappings, once for abbreviations.
* Then loop over all map hash lists.
*/
for (abbr = 0; abbr < 2; ++abbr)
for (hash = 0; hash < 256; ++hash)
{
if (abbr)
{
if (hash > 0) /* there is only one abbr list */
break;
#ifdef FEAT_LOCALMAP
if (buf != NULL)
mp = buf->b_first_abbr;
else
#endif
mp = first_abbr;
}
else
{
#ifdef FEAT_LOCALMAP
if (buf != NULL)
mp = buf->b_maphash[hash];
else
#endif
mp = maphash[hash];
}
for ( ; mp; mp = mp->m_next)
{
/* skip script-local mappings */
if (mp->m_noremap == REMAP_SCRIPT)
continue;
/* skip mappings that contain a <SNR> (script-local thing),
* they probably don't work when loaded again */
for (p = mp->m_str; *p != NUL; ++p)
if (p[0] == K_SPECIAL && p[1] == KS_EXTRA
&& p[2] == (int)KE_SNR)
break;
if (*p != NUL)
continue;
/* It's possible to create a mapping and then ":unmap" certain
* modes. We recreate this here by mapping the individual
* modes, which requires up to three of them. */
c1 = NUL;
c2 = NUL;
c3 = NUL;
if (abbr)
cmd = "abbr";
else
cmd = "map";
switch (mp->m_mode)
{
case NORMAL + VISUAL + SELECTMODE + OP_PENDING:
break;
case NORMAL:
c1 = 'n';
break;
case VISUAL:
c1 = 'x';
break;
case SELECTMODE:
c1 = 's';
break;
case OP_PENDING:
c1 = 'o';
break;
case NORMAL + VISUAL:
c1 = 'n';
c2 = 'x';
break;
case NORMAL + SELECTMODE:
c1 = 'n';
c2 = 's';
break;
case NORMAL + OP_PENDING:
c1 = 'n';
c2 = 'o';
break;
case VISUAL + SELECTMODE:
c1 = 'v';
break;
case VISUAL + OP_PENDING:
c1 = 'x';
c2 = 'o';
break;
case SELECTMODE + OP_PENDING:
c1 = 's';
c2 = 'o';
break;
case NORMAL + VISUAL + SELECTMODE:
c1 = 'n';
c2 = 'v';
break;
case NORMAL + VISUAL + OP_PENDING:
c1 = 'n';
c2 = 'x';
c3 = 'o';
break;
case NORMAL + SELECTMODE + OP_PENDING:
c1 = 'n';
c2 = 's';
c3 = 'o';
break;
case VISUAL + SELECTMODE + OP_PENDING:
c1 = 'v';
c2 = 'o';
break;
case CMDLINE + INSERT:
if (!abbr)
cmd = "map!";
break;
case CMDLINE:
c1 = 'c';
break;
case INSERT:
c1 = 'i';
break;
case LANGMAP:
c1 = 'l';
break;
default:
EMSG(_("E228: makemap: Illegal mode"));
return FAIL;
}
do /* do this twice if c2 is set, 3 times with c3 */
{
/* When outputting <> form, need to make sure that 'cpo'
* is set to the Vim default. */
if (!did_cpo)
{
if (*mp->m_str == NUL) /* will use <Nop> */
did_cpo = TRUE;
else
for (i = 0; i < 2; ++i)
for (p = (i ? mp->m_str : mp->m_keys); *p; ++p)
if (*p == K_SPECIAL || *p == NL)
did_cpo = TRUE;
if (did_cpo)
{
if (fprintf(fd, "let s:cpo_save=&cpo") < 0
|| put_eol(fd) < 0
|| fprintf(fd, "set cpo&vim") < 0
|| put_eol(fd) < 0)
return FAIL;
}
}
if (c1 && putc(c1, fd) < 0)
return FAIL;
if (mp->m_noremap != REMAP_YES && fprintf(fd, "nore") < 0)
return FAIL;
if (fputs(cmd, fd) < 0)
return FAIL;
if (buf != NULL && fputs(" <buffer>", fd) < 0)
return FAIL;
if (mp->m_nowait && fputs(" <nowait>", fd) < 0)
return FAIL;
if (mp->m_silent && fputs(" <silent>", fd) < 0)
return FAIL;
#ifdef FEAT_EVAL
if (mp->m_noremap == REMAP_SCRIPT
&& fputs("<script>", fd) < 0)
return FAIL;
if (mp->m_expr && fputs(" <expr>", fd) < 0)
return FAIL;
#endif
if ( putc(' ', fd) < 0
|| put_escstr(fd, mp->m_keys, 0) == FAIL
|| putc(' ', fd) < 0
|| put_escstr(fd, mp->m_str, 1) == FAIL
|| put_eol(fd) < 0)
return FAIL;
c1 = c2;
c2 = c3;
c3 = NUL;
} while (c1 != NUL);
}
}
if (did_cpo)
if (fprintf(fd, "let &cpo=s:cpo_save") < 0
|| put_eol(fd) < 0
|| fprintf(fd, "unlet s:cpo_save") < 0
|| put_eol(fd) < 0)
return FAIL;
return OK;
}
/*
* write escape string to file
* "what": 0 for :map lhs, 1 for :map rhs, 2 for :set
*
* return FAIL for failure, OK otherwise
*/
int
put_escstr(fd, strstart, what)
FILE *fd;
char_u *strstart;
int what;
{
char_u *str = strstart;
int c;
int modifiers;
/* :map xx <Nop> */
if (*str == NUL && what == 1)
{
if (fprintf(fd, "<Nop>") < 0)
return FAIL;
return OK;
}
for ( ; *str != NUL; ++str)
{
#ifdef FEAT_MBYTE
char_u *p;
/* Check for a multi-byte character, which may contain escaped
* K_SPECIAL and CSI bytes */
p = mb_unescape(&str);
if (p != NULL)
{
while (*p != NUL)
if (fputc(*p++, fd) < 0)
return FAIL;
--str;
continue;
}
#endif
c = *str;
/*
* Special key codes have to be translated to be able to make sense
* when they are read back.
*/
if (c == K_SPECIAL && what != 2)
{
modifiers = 0x0;
if (str[1] == KS_MODIFIER)
{
modifiers = str[2];
str += 3;
c = *str;
}
if (c == K_SPECIAL)
{
c = TO_SPECIAL(str[1], str[2]);
str += 2;
}
if (IS_SPECIAL(c) || modifiers) /* special key */
{
if (fputs((char *)get_special_key_name(c, modifiers), fd) < 0)
return FAIL;
continue;
}
}
/*
* A '\n' in a map command should be written as <NL>.
* A '\n' in a set command should be written as \^V^J.
*/
if (c == NL)
{
if (what == 2)
{
if (fprintf(fd, IF_EB("\\\026\n", "\\" CTRL_V_STR "\n")) < 0)
return FAIL;
}
else
{
if (fprintf(fd, "<NL>") < 0)
return FAIL;
}
continue;
}
/*
* Some characters have to be escaped with CTRL-V to
* prevent them from misinterpreted in DoOneCmd().
* A space, Tab and '"' has to be escaped with a backslash to
* prevent it to be misinterpreted in do_set().
* A space has to be escaped with a CTRL-V when it's at the start of a
* ":map" rhs.
* A '<' has to be escaped with a CTRL-V to prevent it being
* interpreted as the start of a special key name.
* A space in the lhs of a :map needs a CTRL-V.
*/
if (what == 2 && (vim_iswhite(c) || c == '"' || c == '\\'))
{
if (putc('\\', fd) < 0)
return FAIL;
}
else if (c < ' ' || c > '~' || c == '|'
|| (what == 0 && c == ' ')
|| (what == 1 && str == strstart && c == ' ')
|| (what != 2 && c == '<'))
{
if (putc(Ctrl_V, fd) < 0)
return FAIL;
}
if (putc(c, fd) < 0)
return FAIL;
}
return OK;
}
/*
* Check all mappings for the presence of special key codes.
* Used after ":set term=xxx".
*/
void
check_map_keycodes()
{
mapblock_T *mp;
char_u *p;
int i;
char_u buf[3];
char_u *save_name;
int abbr;
int hash;
#ifdef FEAT_LOCALMAP
buf_T *bp;
#endif
validate_maphash();
save_name = sourcing_name;
sourcing_name = (char_u *)"mappings"; /* avoids giving error messages */
#ifdef FEAT_LOCALMAP
/* This this once for each buffer, and then once for global
* mappings/abbreviations with bp == NULL */
for (bp = firstbuf; ; bp = bp->b_next)
{
#endif
/*
* Do the loop twice: Once for mappings, once for abbreviations.
* Then loop over all map hash lists.
*/
for (abbr = 0; abbr <= 1; ++abbr)
for (hash = 0; hash < 256; ++hash)
{
if (abbr)
{
if (hash) /* there is only one abbr list */
break;
#ifdef FEAT_LOCALMAP
if (bp != NULL)
mp = bp->b_first_abbr;
else
#endif
mp = first_abbr;
}
else
{
#ifdef FEAT_LOCALMAP
if (bp != NULL)
mp = bp->b_maphash[hash];
else
#endif
mp = maphash[hash];
}
for ( ; mp != NULL; mp = mp->m_next)
{
for (i = 0; i <= 1; ++i) /* do this twice */
{
if (i == 0)
p = mp->m_keys; /* once for the "from" part */
else
p = mp->m_str; /* and once for the "to" part */
while (*p)
{
if (*p == K_SPECIAL)
{
++p;
if (*p < 128) /* for "normal" tcap entries */
{
buf[0] = p[0];
buf[1] = p[1];
buf[2] = NUL;
(void)add_termcap_entry(buf, FALSE);
}
++p;
}
++p;
}
}
}
}
#ifdef FEAT_LOCALMAP
if (bp == NULL)
break;
}
#endif
sourcing_name = save_name;
}
#if defined(FEAT_EVAL) || defined(PROTO)
/*
* Check the string "keys" against the lhs of all mappings.
* Return pointer to rhs of mapping (mapblock->m_str).
* NULL when no mapping found.
*/
char_u *
check_map(keys, mode, exact, ign_mod, abbr, mp_ptr, local_ptr)
char_u *keys;
int mode;
int exact; /* require exact match */
int ign_mod; /* ignore preceding modifier */
int abbr; /* do abbreviations */
mapblock_T **mp_ptr; /* return: pointer to mapblock or NULL */
int *local_ptr; /* return: buffer-local mapping or NULL */
{
int hash;
int len, minlen;
mapblock_T *mp;
char_u *s;
#ifdef FEAT_LOCALMAP
int local;
#endif
validate_maphash();
len = (int)STRLEN(keys);
#ifdef FEAT_LOCALMAP
for (local = 1; local >= 0; --local)
#endif
/* loop over all hash lists */
for (hash = 0; hash < 256; ++hash)
{
if (abbr)
{
if (hash > 0) /* there is only one list. */
break;
#ifdef FEAT_LOCALMAP
if (local)
mp = curbuf->b_first_abbr;
else
#endif
mp = first_abbr;
}
#ifdef FEAT_LOCALMAP
else if (local)
mp = curbuf->b_maphash[hash];
#endif
else
mp = maphash[hash];
for ( ; mp != NULL; mp = mp->m_next)
{
/* skip entries with wrong mode, wrong length and not matching
* ones */
if ((mp->m_mode & mode) && (!exact || mp->m_keylen == len))
{
if (len > mp->m_keylen)
minlen = mp->m_keylen;
else
minlen = len;
s = mp->m_keys;
if (ign_mod && s[0] == K_SPECIAL && s[1] == KS_MODIFIER
&& s[2] != NUL)
{
s += 3;
if (len > mp->m_keylen - 3)
minlen = mp->m_keylen - 3;
}
if (STRNCMP(s, keys, minlen) == 0)
{
if (mp_ptr != NULL)
*mp_ptr = mp;
if (local_ptr != NULL)
#ifdef FEAT_LOCALMAP
*local_ptr = local;
#else
*local_ptr = 0;
#endif
return mp->m_str;
}
}
}
}
return NULL;
}
#endif
#if defined(MSDOS) || defined(MSWIN) || defined(OS2) || defined(MACOS)
#define VIS_SEL (VISUAL+SELECTMODE) /* abbreviation */
/*
* Default mappings for some often used keys.
*/
static struct initmap
{
char_u *arg;
int mode;
} initmappings[] =
{
#if defined(MSDOS) || defined(MSWIN) || defined(OS2)
/* Use the Windows (CUA) keybindings. */
# ifdef FEAT_GUI
/* paste, copy and cut */
{(char_u *)"<S-Insert> \"*P", NORMAL},
{(char_u *)"<S-Insert> \"-d\"*P", VIS_SEL},
{(char_u *)"<S-Insert> <C-R><C-O>*", INSERT+CMDLINE},
{(char_u *)"<C-Insert> \"*y", VIS_SEL},
{(char_u *)"<S-Del> \"*d", VIS_SEL},
{(char_u *)"<C-Del> \"*d", VIS_SEL},
{(char_u *)"<C-X> \"*d", VIS_SEL},
/* Missing: CTRL-C (cancel) and CTRL-V (block selection) */
# else
{(char_u *)"\316w <C-Home>", NORMAL+VIS_SEL},
{(char_u *)"\316w <C-Home>", INSERT+CMDLINE},
{(char_u *)"\316u <C-End>", NORMAL+VIS_SEL},
{(char_u *)"\316u <C-End>", INSERT+CMDLINE},
/* paste, copy and cut */
# ifdef FEAT_CLIPBOARD
# ifdef DJGPP
{(char_u *)"\316\122 \"*P", NORMAL}, /* SHIFT-Insert is "*P */
{(char_u *)"\316\122 \"-d\"*P", VIS_SEL}, /* SHIFT-Insert is "-d"*P */
{(char_u *)"\316\122 \022\017*", INSERT}, /* SHIFT-Insert is ^R^O* */
{(char_u *)"\316\222 \"*y", VIS_SEL}, /* CTRL-Insert is "*y */
# if 0 /* Shift-Del produces the same code as Del */
{(char_u *)"\316\123 \"*d", VIS_SEL}, /* SHIFT-Del is "*d */
# endif
{(char_u *)"\316\223 \"*d", VIS_SEL}, /* CTRL-Del is "*d */
{(char_u *)"\030 \"-d", VIS_SEL}, /* CTRL-X is "-d */
# else
{(char_u *)"\316\324 \"*P", NORMAL}, /* SHIFT-Insert is "*P */
{(char_u *)"\316\324 \"-d\"*P", VIS_SEL}, /* SHIFT-Insert is "-d"*P */
{(char_u *)"\316\324 \022\017*", INSERT}, /* SHIFT-Insert is ^R^O* */
{(char_u *)"\316\325 \"*y", VIS_SEL}, /* CTRL-Insert is "*y */
{(char_u *)"\316\327 \"*d", VIS_SEL}, /* SHIFT-Del is "*d */
{(char_u *)"\316\330 \"*d", VIS_SEL}, /* CTRL-Del is "*d */
{(char_u *)"\030 \"-d", VIS_SEL}, /* CTRL-X is "-d */
# endif
# else
{(char_u *)"\316\324 P", NORMAL}, /* SHIFT-Insert is P */
{(char_u *)"\316\324 \"-dP", VIS_SEL}, /* SHIFT-Insert is "-dP */
{(char_u *)"\316\324 \022\017\"", INSERT}, /* SHIFT-Insert is ^R^O" */
{(char_u *)"\316\325 y", VIS_SEL}, /* CTRL-Insert is y */
{(char_u *)"\316\327 d", VIS_SEL}, /* SHIFT-Del is d */
{(char_u *)"\316\330 d", VIS_SEL}, /* CTRL-Del is d */
# endif
# endif
#endif
#if defined(MACOS)
/* Use the Standard MacOS binding. */
/* paste, copy and cut */
{(char_u *)"<D-v> \"*P", NORMAL},
{(char_u *)"<D-v> \"-d\"*P", VIS_SEL},
{(char_u *)"<D-v> <C-R>*", INSERT+CMDLINE},
{(char_u *)"<D-c> \"*y", VIS_SEL},
{(char_u *)"<D-x> \"*d", VIS_SEL},
{(char_u *)"<Backspace> \"-d", VIS_SEL},
#endif
};
# undef VIS_SEL
#endif
/*
* Set up default mappings.
*/
void
init_mappings()
{
#if defined(MSDOS) || defined(MSWIN) || defined(OS2) || defined(MACOS)
int i;
for (i = 0; i < sizeof(initmappings) / sizeof(struct initmap); ++i)
add_map(initmappings[i].arg, initmappings[i].mode);
#endif
}
#if defined(MSDOS) || defined(MSWIN) || defined(OS2) \
|| defined(FEAT_CMDWIN) || defined(MACOS) || defined(PROTO)
/*
* Add a mapping "map" for mode "mode".
* Need to put string in allocated memory, because do_map() will modify it.
*/
void
add_map(map, mode)
char_u *map;
int mode;
{
char_u *s;
char_u *cpo_save = p_cpo;
p_cpo = (char_u *)""; /* Allow <> notation */
s = vim_strsave(map);
if (s != NULL)
{
(void)do_map(0, s, mode, FALSE);
vim_free(s);
}
p_cpo = cpo_save;
}
#endif