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

*/

/*

* edit.c: functions for Insert mode

*/

#include "vim.h"

#ifdef FEAT_INS_EXPAND

/*

* definitions used for CTRL-X submode

*/

#define CTRL_X_WANT_IDENT 0x100

#define CTRL_X_NOT_DEFINED_YET 1

#define CTRL_X_SCROLL 2

#define CTRL_X_WHOLE_LINE 3

#define CTRL_X_FILES 4

#define CTRL_X_TAGS (5 + CTRL_X_WANT_IDENT)

#define CTRL_X_PATH_PATTERNS (6 + CTRL_X_WANT_IDENT)

#define CTRL_X_PATH_DEFINES (7 + CTRL_X_WANT_IDENT)

#define CTRL_X_FINISHED 8

#define CTRL_X_DICTIONARY (9 + CTRL_X_WANT_IDENT)

#define CTRL_X_THESAURUS (10 + CTRL_X_WANT_IDENT)

#define CTRL_X_CMDLINE 11

#define CTRL_X_FUNCTION 12

#define CTRL_X_OMNI 13

#define CTRL_X_SPELL 14

#define CTRL_X_LOCAL_MSG 15 /* only used in "ctrl_x_msgs" */

#define CTRL_X_MSG(i) ctrl_x_msgs[(i) & ~CTRL_X_WANT_IDENT]

static char *ctrl_x_msgs[] =

{

N_(" Keyword completion (^N^P)"), /* ctrl_x_mode == 0, ^P/^N compl. */

N_(" ^X mode (^]^D^E^F^I^K^L^N^O^Ps^U^V^Y)"),

NULL,

N_(" Whole line completion (^L^N^P)"),

N_(" File name completion (^F^N^P)"),

N_(" Tag completion (^]^N^P)"),

N_(" Path pattern completion (^N^P)"),

N_(" Definition completion (^D^N^P)"),

NULL,

N_(" Dictionary completion (^K^N^P)"),

N_(" Thesaurus completion (^T^N^P)"),

N_(" Command-line completion (^V^N^P)"),

N_(" User defined completion (^U^N^P)"),

N_(" Omni completion (^O^N^P)"),

N_(" Spelling suggestion (s^N^P)"),

N_(" Keyword Local completion (^N^P)"),

};

static char_u e_hitend[] = N_("Hit end of paragraph");

/*

* Structure used to store one match for insert completion.

*/

typedef struct compl_S compl_T;

struct compl_S

{

compl_T *cp_next;

compl_T *cp_prev;

char_u *cp_str; /* matched text */

char cp_icase; /* TRUE or FALSE: ignore case */

char_u *(cp_text[CPT_COUNT]); /* text for the menu */

char_u *cp_fname; /* file containing the match, allocated when

* cp_flags has FREE_FNAME */

int cp_flags; /* ORIGINAL_TEXT, CONT_S_IPOS or FREE_FNAME */

int cp_number; /* sequence number */

};

#define ORIGINAL_TEXT (1) /* the original text when the expansion begun */

#define FREE_FNAME (2)

/*

* All the current matches are stored in a list.

* "compl_first_match" points to the start of the list.

* "compl_curr_match" points to the currently selected entry.

* "compl_shown_match" is different from compl_curr_match during

* ins_compl_get_exp().

*/

static compl_T *compl_first_match = NULL;

static compl_T *compl_curr_match = NULL;

static compl_T *compl_shown_match = NULL;

/* After using a cursor key <Enter> selects a match in the popup menu,

* otherwise it inserts a line break. */

static int compl_enter_selects = FALSE;

/* When "compl_leader" is not NULL only matches that start with this string

* are used. */

static char_u *compl_leader = NULL;

static int compl_get_longest = FALSE; /* put longest common string

in compl_leader */

static int compl_used_match; /* Selected one of the matches. When

FALSE the match was edited or using

the longest common string. */

static int compl_was_interrupted = FALSE; /* didn't finish finding

completions. */

static int compl_restarting = FALSE; /* don't insert match */

/* When the first completion is done "compl_started" is set. When it's

* FALSE the word to be completed must be located. */

static int compl_started = FALSE;

static int compl_matches = 0;

static char_u *compl_pattern = NULL;

static int compl_direction = FORWARD;

static int compl_shows_dir = FORWARD;

static int compl_pending = 0; /* > 1 for postponed CTRL-N */

static pos_T compl_startpos;

static colnr_T compl_col = 0; /* column where the text starts

* that is being completed */

static char_u *compl_orig_text = NULL; /* text as it was before

* completion started */

static int compl_cont_mode = 0;

static expand_T compl_xp;

static void ins_ctrl_x __ARGS((void));

static int has_compl_option __ARGS((int dict_opt));

static int ins_compl_accept_char __ARGS((int c));

static int ins_compl_add __ARGS((char_u *str, int len, int icase, char_u *fname, char_u **cptext, int cdir, int flags, int adup));

static int ins_compl_equal __ARGS((compl_T *match, char_u *str, int len));

static void ins_compl_longest_match __ARGS((compl_T *match));

static void ins_compl_add_matches __ARGS((int num_matches, char_u **matches, int icase));

static int ins_compl_make_cyclic __ARGS((void));

static void ins_compl_upd_pum __ARGS((void));

static void ins_compl_del_pum __ARGS((void));

static int pum_wanted __ARGS((void));

static int pum_enough_matches __ARGS((void));

static void ins_compl_dictionaries __ARGS((char_u *dict, char_u *pat, int flags, int thesaurus));

static void ins_compl_files __ARGS((int count, char_u **files, int thesaurus, int flags, regmatch_T *regmatch, char_u *buf, int *dir));

static char_u *find_line_end __ARGS((char_u *ptr));

static void ins_compl_free __ARGS((void));

static void ins_compl_clear __ARGS((void));

static int ins_compl_bs __ARGS((void));

static void ins_compl_new_leader __ARGS((void));

static void ins_compl_addleader __ARGS((int c));

static void ins_compl_restart __ARGS((void));

static void ins_compl_set_original_text __ARGS((char_u *str));

static void ins_compl_addfrommatch __ARGS((void));

static int ins_compl_prep __ARGS((int c));

static buf_T *ins_compl_next_buf __ARGS((buf_T *buf, int flag));

#if defined(FEAT_COMPL_FUNC) || defined(FEAT_EVAL)

static void ins_compl_add_list __ARGS((list_T *list));

#endif

static int ins_compl_get_exp __ARGS((pos_T *ini));

static void ins_compl_delete __ARGS((void));

static void ins_compl_insert __ARGS((void));

static int ins_compl_next __ARGS((int allow_get_expansion, int count, int insert_match));

static int ins_compl_key2dir __ARGS((int c));

static int ins_compl_pum_key __ARGS((int c));

static int ins_compl_key2count __ARGS((int c));

static int ins_compl_use_match __ARGS((int c));

static int ins_complete __ARGS((int c));

static int quote_meta __ARGS((char_u *dest, char_u *str, int len));

#endif /* FEAT_INS_EXPAND */

#define BACKSPACE_CHAR 1

#define BACKSPACE_WORD 2

#define BACKSPACE_WORD_NOT_SPACE 3

#define BACKSPACE_LINE 4

static void ins_redraw __ARGS((int ready));

static void ins_ctrl_v __ARGS((void));

static void undisplay_dollar __ARGS((void));

static void insert_special __ARGS((int, int, int));

static void internal_format __ARGS((int textwidth, int second_indent, int flags, int format_only));

static void check_auto_format __ARGS((int));

static void redo_literal __ARGS((int c));

static void start_arrow __ARGS((pos_T *end_insert_pos));

#ifdef FEAT_SPELL

static void check_spell_redraw __ARGS((void));

static void spell_back_to_badword __ARGS((void));

static int spell_bad_len = 0; /* length of located bad word */

#endif

static void stop_insert __ARGS((pos_T *end_insert_pos, int esc));

static int echeck_abbr __ARGS((int));

#if 0

static void replace_push_off __ARGS((int c));

#endif

static int replace_pop __ARGS((void));

static void replace_join __ARGS((int off));

static void replace_pop_ins __ARGS((void));

#ifdef FEAT_MBYTE

static void mb_replace_pop_ins __ARGS((int cc));

#endif

static void replace_flush __ARGS((void));

static void replace_do_bs __ARGS((void));

#ifdef FEAT_CINDENT

static int cindent_on __ARGS((void));

#endif

static void ins_reg __ARGS((void));

static void ins_ctrl_g __ARGS((void));

static void ins_ctrl_hat __ARGS((void));

static int ins_esc __ARGS((long *count, int cmdchar, int nomove));

#ifdef FEAT_RIGHTLEFT

static void ins_ctrl_ __ARGS((void));

#endif

#ifdef FEAT_VISUAL

static int ins_start_select __ARGS((int c));

#endif

static void ins_insert __ARGS((int replaceState));

static void ins_ctrl_o __ARGS((void));

static void ins_shift __ARGS((int c, int lastc));

static void ins_del __ARGS((void));

static int ins_bs __ARGS((int c, int mode, int *inserted_space_p));

#ifdef FEAT_MOUSE

static void ins_mouse __ARGS((int c));

static void ins_mousescroll __ARGS((int up));

#endif

#if defined(FEAT_GUI_TABLINE) || defined(PROTO)

static void ins_tabline __ARGS((int c));

#endif

static void ins_left __ARGS((void));

static void ins_home __ARGS((int c));

static void ins_end __ARGS((int c));

static void ins_s_left __ARGS((void));

static void ins_right __ARGS((void));

static void ins_s_right __ARGS((void));

static void ins_up __ARGS((int startcol));

static void ins_pageup __ARGS((void));

static void ins_down __ARGS((int startcol));

static void ins_pagedown __ARGS((void));

#ifdef FEAT_DND

static void ins_drop __ARGS((void));

#endif

static int ins_tab __ARGS((void));

static int ins_eol __ARGS((int c));

#ifdef FEAT_DIGRAPHS

static int ins_digraph __ARGS((void));

#endif

static int ins_copychar __ARGS((linenr_T lnum));

static int ins_ctrl_ey __ARGS((int tc));

#ifdef FEAT_SMARTINDENT

static void ins_try_si __ARGS((int c));

#endif

static colnr_T get_nolist_virtcol __ARGS((void));

static colnr_T Insstart_textlen; /* length of line when insert started */

static colnr_T Insstart_blank_vcol; /* vcol for first inserted blank */

static char_u *last_insert = NULL; /* the text of the previous insert,

K_SPECIAL and CSI are escaped */

static int last_insert_skip; /* nr of chars in front of previous insert */

static int new_insert_skip; /* nr of chars in front of current insert */

static int did_restart_edit; /* "restart_edit" when calling edit() */

#ifdef FEAT_CINDENT

static int can_cindent; /* may do cindenting on this line */

#endif

static int old_indent = 0; /* for ^^D command in insert mode */

#ifdef FEAT_RIGHTLEFT

static int revins_on; /* reverse insert mode on */

static int revins_chars; /* how much to skip after edit */

static int revins_legal; /* was the last char 'legal'? */

static int revins_scol; /* start column of revins session */

#endif

static int ins_need_undo; /* call u_save() before inserting a

char. Set when edit() is called.

after that arrow_used is used. */

static int did_add_space = FALSE; /* auto_format() added an extra space

under the cursor */

/*

* edit(): Start inserting text.

*

* "cmdchar" can be:

* 'i' normal insert command

* 'a' normal append command

* 'R' replace command

* 'r' "r<CR>" command: insert one <CR>. Note: count can be > 1, for redo,

* but still only one <CR> is inserted. The <Esc> is not used for redo.

* 'g' "gI" command.

* 'V' "gR" command for Virtual Replace mode.

* 'v' "gr" command for single character Virtual Replace mode.

*

* This function is not called recursively. For CTRL-O commands, it returns

* and lets the caller handle the Normal-mode command.

*

* Return TRUE if a CTRL-O command caused the return (insert mode pending).

*/

int

edit(cmdchar, startln, count)

int cmdchar;

int startln; /* if set, insert at start of line */

long count;

{

int c = 0;

char_u *ptr;

int lastc;

colnr_T mincol;

static linenr_T o_lnum = 0;

int i;

int did_backspace = TRUE; /* previous char was backspace */

#ifdef FEAT_CINDENT

int line_is_white = FALSE; /* line is empty before insert */

#endif

linenr_T old_topline = 0; /* topline before insertion */

#ifdef FEAT_DIFF

int old_topfill = -1;

#endif

int inserted_space = FALSE; /* just inserted a space */

int replaceState = REPLACE;

int nomove = FALSE; /* don't move cursor on return */

/* Remember whether editing was restarted after CTRL-O. */

did_restart_edit = restart_edit;

/* sleep before redrawing, needed for "CTRL-O :" that results in an

* error message */

check_for_delay(TRUE);

#ifdef HAVE_SANDBOX

/* Don't allow inserting in the sandbox. */

if (sandbox != 0)

{

EMSG(_(e_sandbox));

return FALSE;

}

#endif

/* Don't allow changes in the buffer while editing the cmdline. The

* caller of getcmdline() may get confused. */

if (textlock != 0)

{

EMSG(_(e_secure));

return FALSE;

}

#ifdef FEAT_INS_EXPAND

/* Don't allow recursive insert mode when busy with completion. */

if (compl_started || pum_visible())

{

EMSG(_(e_secure));

return FALSE;

}

ins_compl_clear(); /* clear stuff for CTRL-X mode */

#endif

#ifdef FEAT_AUTOCMD

/*

* Trigger InsertEnter autocommands. Do not do this for "r<CR>" or "grx".

*/

if (cmdchar != 'r' && cmdchar != 'v')

{

# ifdef FEAT_EVAL

if (cmdchar == 'R')

ptr = (char_u *)"r";

else if (cmdchar == 'V')

ptr = (char_u *)"v";

else

ptr = (char_u *)"i";

set_vim_var_string(VV_INSERTMODE, ptr, 1);

# endif

apply_autocmds(EVENT_INSERTENTER, NULL, NULL, FALSE, curbuf);

}

#endif

#ifdef FEAT_MOUSE

/*

* When doing a paste with the middle mouse button, Insstart is set to

* where the paste started.

*/

if (where_paste_started.lnum != 0)

Insstart = where_paste_started;

else

#endif

{

Insstart = curwin->w_cursor;

if (startln)

Insstart.col = 0;

}

Insstart_textlen = linetabsize(ml_get_curline());

Insstart_blank_vcol = MAXCOL;

if (!did_ai)

ai_col = 0;

if (cmdchar != NUL && restart_edit == 0)

{

ResetRedobuff();

AppendNumberToRedobuff(count);

#ifdef FEAT_VREPLACE

if (cmdchar == 'V' || cmdchar == 'v')

{

/* "gR" or "gr" command */

AppendCharToRedobuff('g');

AppendCharToRedobuff((cmdchar == 'v') ? 'r' : 'R');

}

else

#endif

{

AppendCharToRedobuff(cmdchar);

if (cmdchar == 'g') /* "gI" command */

AppendCharToRedobuff('I');

else if (cmdchar == 'r') /* "r<CR>" command */

count = 1; /* insert only one <CR> */

}

}

if (cmdchar == 'R')

{

#ifdef FEAT_FKMAP

if (p_fkmap && p_ri)

{

beep_flush();

EMSG(farsi_text_3); /* encoded in Farsi */

State = INSERT;

}

else

#endif

State = REPLACE;

}

#ifdef FEAT_VREPLACE

else if (cmdchar == 'V' || cmdchar == 'v')

{

State = VREPLACE;

replaceState = VREPLACE;

orig_line_count = curbuf->b_ml.ml_line_count;

vr_lines_changed = 1;

}

#endif

else

State = INSERT;

stop_insert_mode = FALSE;

/*

* Need to recompute the cursor position, it might move when the cursor is

* on a TAB or special character.

*/

curs_columns(TRUE);

/*

* Enable langmap or IME, indicated by 'iminsert'.

* Note that IME may enabled/disabled without us noticing here, thus the

* 'iminsert' value may not reflect what is actually used. It is updated

* when hitting <Esc>.

*/

if (curbuf->b_p_iminsert == B_IMODE_LMAP)

State |= LANGMAP;

#ifdef USE_IM_CONTROL

im_set_active(curbuf->b_p_iminsert == B_IMODE_IM);

#endif

#ifdef FEAT_MOUSE

setmouse();

#endif

#ifdef FEAT_CMDL_INFO

clear_showcmd();

#endif

#ifdef FEAT_RIGHTLEFT

/* there is no reverse replace mode */

revins_on = (State == INSERT && p_ri);

if (revins_on)

undisplay_dollar();

revins_chars = 0;

revins_legal = 0;

revins_scol = -1;

#endif

/*

* Handle restarting Insert mode.

* Don't do this for "CTRL-O ." (repeat an insert): we get here with

* restart_edit non-zero, and something in the stuff buffer.

*/

if (restart_edit != 0 && stuff_empty())

{

#ifdef FEAT_MOUSE

/*

* After a paste we consider text typed to be part of the insert for

* the pasted text. You can backspace over the pasted text too.

*/

if (where_paste_started.lnum)

arrow_used = FALSE;

else

#endif

arrow_used = TRUE;

restart_edit = 0;

/*

* If the cursor was after the end-of-line before the CTRL-O and it is

* now at the end-of-line, put it after the end-of-line (this is not

* correct in very rare cases).

* Also do this if curswant is greater than the current virtual

* column. Eg after "^O$" or "^O80|".

*/

validate_virtcol();

update_curswant();

if (((ins_at_eol && curwin->w_cursor.lnum == o_lnum)

|| curwin->w_curswant > curwin->w_virtcol)

&& *(ptr = ml_get_curline() + curwin->w_cursor.col) != NUL)

{

if (ptr[1] == NUL)

++curwin->w_cursor.col;

#ifdef FEAT_MBYTE

else if (has_mbyte)

{

i = (*mb_ptr2len)(ptr);

if (ptr[i] == NUL)

curwin->w_cursor.col += i;

}

#endif

}

ins_at_eol = FALSE;

}

else

arrow_used = FALSE;

/* we are in insert mode now, don't need to start it anymore */

need_start_insertmode = FALSE;

/* Need to save the line for undo before inserting the first char. */

ins_need_undo = TRUE;

#ifdef FEAT_MOUSE

where_paste_started.lnum = 0;

#endif

#ifdef FEAT_CINDENT

can_cindent = TRUE;

#endif

#ifdef FEAT_FOLDING

/* The cursor line is not in a closed fold, unless 'insertmode' is set or

* restarting. */

if (!p_im && did_restart_edit == 0)

foldOpenCursor();

#endif

/*

* If 'showmode' is set, show the current (insert/replace/..) mode.

* A warning message for changing a readonly file is given here, before

* actually changing anything. It's put after the mode, if any.

*/

i = 0;

if (p_smd && msg_silent == 0)

i = showmode();

if (!p_im && did_restart_edit == 0)

change_warning(i == 0 ? 0 : i + 1);

#ifdef CURSOR_SHAPE

ui_cursor_shape(); /* may show different cursor shape */

#endif

#ifdef FEAT_DIGRAPHS

do_digraph(-1); /* clear digraphs */

#endif

/*

* Get the current length of the redo buffer, those characters have to be

* skipped if we want to get to the inserted characters.

*/

ptr = get_inserted();

if (ptr == NULL)

new_insert_skip = 0;

else

{

new_insert_skip = (int)STRLEN(ptr);

vim_free(ptr);

}

old_indent = 0;

/*

* Main loop in Insert mode: repeat until Insert mode is left.

*/

for (;;)

{

#ifdef FEAT_RIGHTLEFT

if (!revins_legal)

revins_scol = -1; /* reset on illegal motions */

else

revins_legal = 0;

#endif

if (arrow_used) /* don't repeat insert when arrow key used */

count = 0;

if (stop_insert_mode)

{

/* ":stopinsert" used or 'insertmode' reset */

count = 0;

goto doESCkey;

}

/* set curwin->w_curswant for next K_DOWN or K_UP */

if (!arrow_used)

curwin->w_set_curswant = TRUE;

/* If there is no typeahead may check for timestamps (e.g., for when a

* menu invoked a shell command). */

if (stuff_empty())

{

did_check_timestamps = FALSE;

if (need_check_timestamps)

check_timestamps(FALSE);

}

/*

* When emsg() was called msg_scroll will have been set.

*/

msg_scroll = FALSE;

#ifdef FEAT_GUI

/* When 'mousefocus' is set a mouse movement may have taken us to

* another window. "need_mouse_correct" may then be set because of an

* autocommand. */

if (need_mouse_correct)

gui_mouse_correct();

#endif

#ifdef FEAT_FOLDING

/* Open fold at the cursor line, according to 'foldopen'. */

if (fdo_flags & FDO_INSERT)

foldOpenCursor();

/* Close folds where the cursor isn't, according to 'foldclose' */

if (!char_avail())

foldCheckClose();

#endif

/*

* If we inserted a character at the last position of the last line in

* the window, scroll the window one line up. This avoids an extra

* redraw.

* This is detected when the cursor column is smaller after inserting

* something.

* Don't do this when the topline changed already, it has

* already been adjusted (by insertchar() calling open_line())).

*/

if (curbuf->b_mod_set

&& curwin->w_p_wrap

&& !did_backspace

&& curwin->w_topline == old_topline

#ifdef FEAT_DIFF

&& curwin->w_topfill == old_topfill

#endif

)

{

mincol = curwin->w_wcol;

validate_cursor_col();

if ((int)curwin->w_wcol < (int)mincol - curbuf->b_p_ts

&& curwin->w_wrow == W_WINROW(curwin)

+ curwin->w_height - 1 - p_so

&& (curwin->w_cursor.lnum != curwin->w_topline

#ifdef FEAT_DIFF

|| curwin->w_topfill > 0

#endif

))

{

#ifdef FEAT_DIFF

if (curwin->w_topfill > 0)

--curwin->w_topfill;

else

#endif

#ifdef FEAT_FOLDING

if (hasFolding(curwin->w_topline, NULL, &old_topline))

set_topline(curwin, old_topline + 1);

else

#endif

set_topline(curwin, curwin->w_topline + 1);

}

}

/* May need to adjust w_topline to show the cursor. */

update_topline();

did_backspace = FALSE;

validate_cursor(); /* may set must_redraw */

/*

* Redraw the display when no characters are waiting.

* Also shows mode, ruler and positions cursor.

*/

ins_redraw(TRUE);

#ifdef FEAT_SCROLLBIND

if (curwin->w_p_scb)

do_check_scrollbind(TRUE);

#endif

update_curswant();

old_topline = curwin->w_topline;

#ifdef FEAT_DIFF

old_topfill = curwin->w_topfill;

#endif

#ifdef USE_ON_FLY_SCROLL

dont_scroll = FALSE; /* allow scrolling here */

#endif

/*

* Get a character for Insert mode. Ignore K_IGNORE.

*/

lastc = c; /* remember previous char for CTRL-D */

do

{

c = safe_vgetc();

} while (c == K_IGNORE);

#ifdef FEAT_AUTOCMD

/* Don't want K_CURSORHOLD for the second key, e.g., after CTRL-V. */

did_cursorhold = TRUE;

#endif

#ifdef FEAT_RIGHTLEFT

if (p_hkmap && KeyTyped)

c = hkmap(c); /* Hebrew mode mapping */

#endif

#ifdef FEAT_FKMAP

if (p_fkmap && KeyTyped)

c = fkmap(c); /* Farsi mode mapping */

#endif

#ifdef FEAT_INS_EXPAND

/*

* Special handling of keys while the popup menu is visible or wanted

* and the cursor is still in the completed word. Only when there is

* a match, skip this when no matches were found.

*/

if (compl_started

&& pum_wanted()

&& curwin->w_cursor.col >= compl_col

&& (compl_shown_match == NULL

|| compl_shown_match != compl_shown_match->cp_next))

{

/* BS: Delete one character from "compl_leader". */

if ((c == K_BS || c == Ctrl_H)

&& curwin->w_cursor.col > compl_col

&& (c = ins_compl_bs()) == NUL)

continue;

/* When no match was selected or it was edited. */

if (!compl_used_match)

{

/* CTRL-L: Add one character from the current match to

* "compl_leader". Except when at the original match and

* there is nothing to add, CTRL-L works like CTRL-P then. */

if (c == Ctrl_L

&& (ctrl_x_mode != CTRL_X_WHOLE_LINE

|| STRLEN(compl_shown_match->cp_str)

> curwin->w_cursor.col - compl_col))

{

ins_compl_addfrommatch();

continue;

}

/* A non-white character that fits in with the current

* completion: Add to "compl_leader". */

if (ins_compl_accept_char(c))

{

ins_compl_addleader(c);

continue;

}

/* Pressing CTRL-Y selects the current match. When

* compl_enter_selects is set the Enter key does the same. */

if (c == Ctrl_Y || (compl_enter_selects

&& (c == CAR || c == K_KENTER || c == NL)))

{

ins_compl_delete();

ins_compl_insert();

}

}

}

/* Prepare for or stop CTRL-X mode. This doesn't do completion, but

* it does fix up the text when finishing completion. */

compl_get_longest = FALSE;

if (ins_compl_prep(c))

continue;

#endif

/* CTRL-\ CTRL-N goes to Normal mode,

* CTRL-\ CTRL-G goes to mode selected with 'insertmode',

* CTRL-\ CTRL-O is like CTRL-O but without moving the cursor. */

if (c == Ctrl_BSL)

{

/* may need to redraw when no more chars available now */

ins_redraw(FALSE);

++no_mapping;

++allow_keys;

c = plain_vgetc();

--no_mapping;

--allow_keys;

if (c != Ctrl_N && c != Ctrl_G && c != Ctrl_O)

{

/* it's something else */

vungetc(c);

c = Ctrl_BSL;

}

else if (c == Ctrl_G && p_im)

continue;

else

{

if (c == Ctrl_O)

{

ins_ctrl_o();

ins_at_eol = FALSE; /* cursor keeps its column */

nomove = TRUE;

}

count = 0;

goto doESCkey;

}

}

#ifdef FEAT_DIGRAPHS

c = do_digraph(c);

#endif

#ifdef FEAT_INS_EXPAND

if ((c == Ctrl_V || c == Ctrl_Q) && ctrl_x_mode == CTRL_X_CMDLINE)

goto docomplete;

#endif

if (c == Ctrl_V || c == Ctrl_Q)

{

ins_ctrl_v();

c = Ctrl_V; /* pretend CTRL-V is last typed character */

continue;

}

#ifdef FEAT_CINDENT

if (cindent_on()

# ifdef FEAT_INS_EXPAND

&& ctrl_x_mode == 0

# endif

)

{

/* A key name preceded by a bang means this key is not to be

* inserted. Skip ahead to the re-indenting below.

* A key name preceded by a star means that indenting has to be

* done before inserting the key. */

line_is_white = inindent(0);

if (in_cinkeys(c, '!', line_is_white))

goto force_cindent;

if (can_cindent && in_cinkeys(c, '*', line_is_white)

&& stop_arrow() == OK)

do_c_expr_indent();

}

#endif

#ifdef FEAT_RIGHTLEFT

if (curwin->w_p_rl)

switch (c)

{

case K_LEFT: c = K_RIGHT; break;

case K_S_LEFT: c = K_S_RIGHT; break;

case K_C_LEFT: c = K_C_RIGHT; break;

case K_RIGHT: c = K_LEFT; break;

case K_S_RIGHT: c = K_S_LEFT; break;

case K_C_RIGHT: c = K_C_LEFT; break;

}

#endif

#ifdef FEAT_VISUAL

/*

* If 'keymodel' contains "startsel", may start selection. If it

* does, a CTRL-O and c will be stuffed, we need to get these

* characters.

*/

if (ins_start_select(c))

continue;

#endif

/*

* The big switch to handle a character in insert mode.

*/

switch (c)

{

case ESC: /* End input mode */

if (echeck_abbr(ESC + ABBR_OFF))

break;

/*FALLTHROUGH*/

case Ctrl_C: /* End input mode */

#ifdef FEAT_CMDWIN

if (c == Ctrl_C && cmdwin_type != 0)

{

/* Close the cmdline window. */

cmdwin_result = K_IGNORE;

got_int = FALSE; /* don't stop executing autocommands et al. */

nomove = TRUE;

goto doESCkey;

}

#endif

#ifdef UNIX

do_intr:

#endif

/* when 'insertmode' set, and not halfway a mapping, don't leave

* Insert mode */

if (goto_im())

{

if (got_int)

{

(void)vgetc(); /* flush all buffers */

got_int = FALSE;

}

else

vim_beep();

break;

}

doESCkey:

/*

* This is the ONLY return from edit()!

*/

/* Always update o_lnum, so that a "CTRL-O ." that adds a line

* still puts the cursor back after the inserted text. */

if (ins_at_eol && gchar_cursor() == NUL)

o_lnum = curwin->w_cursor.lnum;

if (ins_esc(&count, cmdchar, nomove))

{

#ifdef FEAT_AUTOCMD

if (cmdchar != 'r' && cmdchar != 'v')

apply_autocmds(EVENT_INSERTLEAVE, NULL, NULL,

FALSE, curbuf);

did_cursorhold = FALSE;

#endif

return (c == Ctrl_O);

}

continue;

case Ctrl_Z: /* suspend when 'insertmode' set */

if (!p_im)

goto normalchar; /* insert CTRL-Z as normal char */

stuffReadbuff((char_u *)":st\r");

c = Ctrl_O;

/*FALLTHROUGH*/

case Ctrl_O: /* execute one command */

#ifdef FEAT_COMPL_FUNC

if (ctrl_x_mode == CTRL_X_OMNI)

goto docomplete;

#endif

if (echeck_abbr(Ctrl_O + ABBR_OFF))

break;

ins_ctrl_o();

#ifdef FEAT_VIRTUALEDIT

/* don't move the cursor left when 'virtualedit' has "onemore". */

if (ve_flags & VE_ONEMORE)

{

ins_at_eol = FALSE;

nomove = TRUE;

}

#endif

count = 0;

goto doESCkey;

case K_INS: /* toggle insert/replace mode */

case K_KINS:

ins_insert(replaceState);

break;

case K_SELECT: /* end of Select mode mapping - ignore */

break;

#ifdef FEAT_SNIFF

case K_SNIFF: /* Sniff command received */

stuffcharReadbuff(K_SNIFF);

goto doESCkey;

#endif

case K_HELP: /* Help key works like <ESC> <Help> */

case K_F1:

case K_XF1:

stuffcharReadbuff(K_HELP);

if (p_im)

need_start_insertmode = TRUE;

goto doESCkey;

#ifdef FEAT_NETBEANS_INTG

case K_F21: /* NetBeans command */

++no_mapping; /* don't map the next key hits */

i = plain_vgetc();

--no_mapping;

netbeans_keycommand(i);

break;

#endif

case K_ZERO: /* Insert the previously inserted text. */

case NUL:

case Ctrl_A:

/* For ^@ the trailing ESC will end the insert, unless there is an

* error. */

if (stuff_inserted(NUL, 1L, (c == Ctrl_A)) == FAIL