/* vi:set ts=8 sts=4 sw=4 noet:

*

* 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};

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 + TERMINAL)) ? (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 int read_readbuf(buffheader_T *buf, int advance);

static void init_typebuf(void);

static void may_sync_undo(void);

static void closescript(void);

static int vgetorpeek(int);

static void map_free(mapblock_T **);

static void validate_maphash(void);

static void showmap(mapblock_T *mp, int local);

static int inchar(char_u *buf, int maxlen, long wait_time);

#ifdef FEAT_EVAL

static char_u *eval_map_expr(char_u *str, int c);

#endif

/*

* Free and clear a buffer.

*/

void

free_buff(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(

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(void)

{

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(void)

{

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(

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 */

{

iemsg(_("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(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(buffheader_T *buf, int c)

{

char_u bytes[MB_MAXBYTES + 1];

int len;

int i;

char_u temp[4];

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];

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);

}

}

/* 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(int advance)

{

int c;

c = read_readbuf(&readbuf1, advance);

if (c == NUL)

c = read_readbuf(&readbuf2, advance);

return c;

}

static int

read_readbuf(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(void)

{

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(void)

{

return (readbuf1.bh_first.b_next == NULL

&& readbuf2.bh_first.b_next == NULL);

}

#if defined(FEAT_EVAL) || defined(PROTO)

/*

* Return TRUE if readbuf1 is empty. There may still be redo characters in

* redbuf2.

*/

int

readbuf1_empty(void)

{

return (readbuf1.bh_first.b_next == NULL);

}

#endif

/*

* Set a typeahead character that won't be flushed.

*/

void

typeahead_noflush(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_buffers_T flush_typeahead)

{

init_typebuf();

start_stuff();

while (read_readbuffers(TRUE) != NUL)

;

if (flush_typeahead == FLUSH_MINIMAL)

{

// remove mapped characters at the start only

typebuf.tb_off += typebuf.tb_maplen;

typebuf.tb_len -= typebuf.tb_maplen;

}

else

{

// remove typeahead

if (flush_typeahead == FLUSH_INPUT)

// 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) != 0)

;

typebuf.tb_off = MAXMAPLEN;

typebuf.tb_len = 0;

#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

}

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(void)

{

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(void)

{

if (!block_redo)

{

free_buff(&redobuff);

redobuff = old_redobuff;

old_redobuff.bh_first.b_next = NULL;

start_stuff();

while (read_readbuffers(TRUE) != NUL)

;

}

}

/*

* Save redobuff and old_redobuff to save_redobuff and save_old_redobuff.

* Used before executing autocommands and user functions.

*/

void

saveRedobuff(save_redo_T *save_redo)

{

char_u *s;

save_redo->sr_redobuff = redobuff;

redobuff.bh_first.b_next = NULL;

save_redo->sr_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_redo->sr_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(save_redo_T *save_redo)

{

free_buff(&redobuff);

redobuff = save_redo->sr_redobuff;

free_buff(&old_redobuff);

old_redobuff = save_redo->sr_old_redobuff;

}

/*

* Append "s" to the redo buffer.

* K_SPECIAL and CSI should already have been escaped.

*/

void

AppendToRedobuff(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(

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. */

if (has_mbyte)

/* Handle composing chars separately. */

c = mb_cptr2char_adv(&s);

else

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(int c)

{

if (!block_redo)

add_char_buff(&redobuff, c);

}

/*

* Append a number to the redo buffer.

*/

void

AppendNumberToRedobuff(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(char_u *s)

{

add_buff(&readbuf1, s, -1L);

}

/*

* Append string "s" to the redo stuff buffer.

* CSI and K_SPECIAL must already have been escaped.

*/

void

stuffRedoReadbuff(char_u *s)

{

add_buff(&readbuf2, s, -1L);

}

void

stuffReadbuffLen(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(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

{

c = mb_ptr2char_adv(&s);

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(int c)

{

add_char_buff(&readbuf1, c);

}

/*

* Append a number to the stuff buffer.

*/

void

stuffnumReadbuff(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(int init, int old_redo)

{

static buffblock_T *bp;

static char_u *p;

int c;

int n;

char_u buf[MB_MAXBYTES + 1];

int i;

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() */

/* 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)

{

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;

}

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;

}

}

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(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(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);

/* the expression register should be re-evaluated */

if (c == '=')

{

add_char_buff(&readbuf2, CAR);

cmd_silent = TRUE;

}

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(void)

{

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(void)

{

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(void)

{

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 = MAXMAPLEN + 4;

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(

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);

if (offset == 0 && addlen <= typebuf.tb_off)

{

/*

* Easy case: there is room in front of typebuf.tb_buf[typebuf.tb_off]

*/

typebuf.tb_off -= addlen;

mch_memmove(typebuf.tb_buf + typebuf.tb_off, str, (size_t)addlen);

}

else if (typebuf.tb_len == 0 && typebuf.tb_buflen

>= addlen + 3 * (MAXMAPLEN + 4))

{

/*

* Buffer is empty and string fits in the existing buffer.

* Leave some space before and after, if possible.

*/

typebuf.tb_off = (typebuf.tb_buflen - addlen - 3 * (MAXMAPLEN + 4)) / 2;

mch_memmove(typebuf.tb_buf + typebuf.tb_off, str, (size_t)addlen);

}

else

{

/*

* 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.

*/

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 */