diff options
Diffstat (limited to 'src/edit.c')
| -rw-r--r-- | src/edit.c | 7614 |
1 files changed, 7614 insertions, 0 deletions
diff --git a/src/edit.c b/src/edit.c new file mode 100644 index 000000000..9a42f5ae8 --- /dev/null +++ b/src/edit.c @@ -0,0 +1,7614 @@ +/* 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 CHECK_KEYS_TIME 30 + +#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 (^E^Y^L^]^F^I^K^D^V^N^P)"), + /* Scroll has it's own msgs, in it's place there is the msg for local + * ctrl_x_mode = 0 (eg continue_status & CONT_LOCAL) -- Acevedo */ + N_(" Keyword Local completion (^N^P)"), + 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)") +}; + +static char_u e_hitend[] = N_("Hit end of paragraph"); + +/* + * Structure used to store one match for insert completion. + */ +struct Completion +{ + struct Completion *next; + struct Completion *prev; + char_u *str; /* matched text */ + char_u *fname; /* file containing the match */ + int original; /* ORIGINAL_TEXT, CONT_S_IPOS or FREE_FNAME */ + int number; /* sequence number */ +}; + +/* the original text when the expansion begun */ +#define ORIGINAL_TEXT (1) +#define FREE_FNAME (2) + +/* + * All the current matches are stored in a list. + * "first_match" points to the start of the list. + * "curr_match" points to the currently selected entry. + * "shown_match" is different from curr_match during ins_compl_get_exp(). + */ +static struct Completion *first_match = NULL; +static struct Completion *curr_match = NULL; +static struct Completion *shown_match = NULL; + +static int started_completion = FALSE; +static int completion_matches = 0; +static char_u *complete_pat = NULL; +static int complete_direction = FORWARD; +static int shown_direction = FORWARD; +static int completion_pending = FALSE; +static pos_T initial_pos; +static colnr_T complete_col = 0; /* column where the text starts + that is being completed */ +static int save_sm; +static char_u *original_text = NULL; /* text before completion */ +static int continue_mode = 0; +static expand_T complete_xp; + +static int ins_compl_add __ARGS((char_u *str, int len, char_u *, int dir, int reuse)); +static void ins_compl_add_matches __ARGS((int num_matches, char_u **matches, int dir)); +static int ins_compl_make_cyclic __ARGS((void)); +static void ins_compl_dictionaries __ARGS((char_u *dict, char_u *pat, int dir, int flags, int thesaurus)); +static void ins_compl_free __ARGS((void)); +static void ins_compl_clear __ARGS((void)); +static void ins_compl_prep __ARGS((int c)); +static buf_T *ins_compl_next_buf __ARGS((buf_T *buf, int flag)); +static int ins_compl_get_exp __ARGS((pos_T *ini, int dir)); +static void ins_compl_delete __ARGS((void)); +static void ins_compl_insert __ARGS((void)); +static int ins_compl_next __ARGS((int allow_get_expansion)); +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((void)); +static void ins_ctrl_v __ARGS((void)); +static void undisplay_dollar __ARGS((void)); +static void insert_special __ARGS((int, int, int)); +static void check_auto_format __ARGS((int)); +static void redo_literal __ARGS((int c)); +static void start_arrow __ARGS((pos_T *end_insert_pos)); +static void stop_insert __ARGS((pos_T *end_insert_pos, int esc)); +static int echeck_abbr __ARGS((int)); +static void replace_push_off __ARGS((int c)); +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 int ins_esc __ARGS((long *count, int cmdchar)); +#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_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 +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)); +#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 */ + +#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 +int revins_on; /* reverse insert mode on */ +int revins_chars; /* how much to skip after edit */ +int revins_legal; /* was the last char 'legal'? */ +int revins_scol; /* start column of revins session */ +#endif + +#if defined(FEAT_MBYTE) && defined(MACOS_CLASSIC) +static short previous_script = smRoman; +#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; + static int o_eol = FALSE; + 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 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 + +#ifdef FEAT_INS_EXPAND + ins_compl_clear(); /* clear stuff for CTRL-X mode */ +#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 + +#if defined(FEAT_MBYTE) && defined(MACOS_CLASSIC) + KeyScript(previous_script); +#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 (((o_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_check)(ptr); + if (ptr[i] == NUL) + curwin->w_cursor.col += i; + } +#endif + } + o_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) + i = showmode(); + + if (!p_im && did_restart_edit == 0) + change_warning(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(); + +#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. + */ + lastc = c; /* remember previous char for CTRL-D */ + c = safe_vgetc(); + +#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 + /* Prepare for or stop CTRL-X mode. This doesn't do completion, but + * it does fix up the text when finishing completion. */ + ins_compl_prep(c); +#endif + + /* CTRL-\ CTRL-N goes to Normal mode, CTRL-\ CTRL-G goes to mode + * selected with 'insertmode'. */ + if (c == Ctrl_BSL) + { + /* may need to redraw when no more chars available now */ + ins_redraw(); + ++no_mapping; + ++allow_keys; + c = safe_vgetc(); + --no_mapping; + --allow_keys; + if (c != Ctrl_N && c != Ctrl_G) /* it's something else */ + { + vungetc(c); + c = Ctrl_BSL; + } + else if (c == Ctrl_G && p_im) + continue; + else + { + 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) + { + /* toggle insert/replace mode */ + case K_INS: + case K_KINS: +#ifdef FEAT_FKMAP + if (p_fkmap && p_ri) + { + beep_flush(); + EMSG(farsi_text_3); /* encoded in Farsi */ + break; + } +#endif + if (State & REPLACE_FLAG) + State = INSERT | (State & LANGMAP); + else + State = replaceState | (State & LANGMAP); + AppendCharToRedobuff(K_INS); + showmode(); +#ifdef CURSOR_SHAPE + ui_cursor_shape(); /* may show different cursor shape */ +#endif + break; + +#ifdef FEAT_INS_EXPAND + /* Enter CTRL-X mode */ + case Ctrl_X: + /* CTRL-X after CTRL-V CTRL-X doesn't do anything, so that CTRL-X + * CTRL-V works like CTRL-N */ + if (ctrl_x_mode != CTRL_X_CMDLINE) + { + /* if the next ^X<> won't ADD nothing, then reset + * continue_status */ + if (continue_status & CONT_N_ADDS) + continue_status = (continue_status | CONT_INTRPT); + else + continue_status = 0; + /* We're not sure which CTRL-X mode it will be yet */ + ctrl_x_mode = CTRL_X_NOT_DEFINED_YET; + edit_submode = (char_u *)_(CTRL_X_MSG(ctrl_x_mode)); + edit_submode_pre = NULL; + showmode(); + } + break; +#endif + + /* end of Select mode mapping - ignore */ + case K_SELECT: + break; + + /* suspend when 'insertmode' set */ + case Ctrl_Z: + if (!p_im) + goto normalchar; /* insert CTRL-Z as normal char */ + stuffReadbuff((char_u *)":st\r"); + c = Ctrl_O; + /*FALLTHROUGH*/ + + /* execute one command */ + case Ctrl_O: + if (echeck_abbr(Ctrl_O + ABBR_OFF)) + break; + count = 0; +#ifdef FEAT_VREPLACE + if (State & VREPLACE_FLAG) + restart_edit = 'V'; + else +#endif + if (State & REPLACE_FLAG) + restart_edit = 'R'; + else + restart_edit = 'I'; +#ifdef FEAT_VIRTUALEDIT + if (virtual_active()) + o_eol = FALSE; /* cursor always keeps its column */ + else +#endif + o_eol = (gchar_cursor() == NUL); + goto doESCkey; + +#ifdef FEAT_SNIFF + case K_SNIFF: + stuffcharReadbuff(K_SNIFF); + goto doESCkey; +#endif + + /* Hitting the help key in insert mode is like <ESC> <Help> */ + case K_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: + ++no_mapping; /* don't map the next key hits */ + i = safe_vgetc(); + --no_mapping; + netbeans_keycommand(i); + break; +#endif + + /* an escape ends input mode */ + case ESC: + if (echeck_abbr(ESC + ABBR_OFF)) + break; + /*FALLTHROUGH*/ + + case Ctrl_C: +#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. */ + 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 (o_eol && gchar_cursor() == NUL) + o_lnum = curwin->w_cursor.lnum; + + if (ins_esc(&count, cmdchar)) + return (c == Ctrl_O); + continue; + + /* + * Insert the previously inserted text. + * For ^@ the trailing ESC will end the insert, unless there is an + * error. + */ + case K_ZERO: + case NUL: + case Ctrl_A: + if (stuff_inserted(NUL, 1L, (c == Ctrl_A)) == FAIL + && c != Ctrl_A && !p_im) + goto doESCkey; /* quit insert mode */ + inserted_space = FALSE; + break; + + /* insert the contents of a register */ + case Ctrl_R: + ins_reg(); + auto_format(FALSE, TRUE); + inserted_space = FALSE; + break; + + case Ctrl_G: + ins_ctrl_g(); + break; + + case Ctrl_HAT: + if (map_to_exists_mode((char_u *)"", LANGMAP)) + { + /* ":lmap" mappings exists, Toggle use of ":lmap" mappings. */ + if (State & LANGMAP) + { + curbuf->b_p_iminsert = B_IMODE_NONE; + State &= ~LANGMAP; + } + else + { + curbuf->b_p_iminsert = B_IMODE_LMAP; + State |= LANGMAP; +#ifdef USE_IM_CONTROL + im_set_active(FALSE); +#endif + } + } +#ifdef USE_IM_CONTROL + else + { + /* There are no ":lmap" mappings, toggle IM */ + if (im_get_status()) + { + curbuf->b_p_iminsert = B_IMODE_NONE; + im_set_active(FALSE); + } + else + { + curbuf->b_p_iminsert = B_IMODE_IM; + State &= ~LANGMAP; + im_set_active(TRUE); + } + } +#endif + set_iminsert_global(); + showmode(); +#ifdef FEAT_GUI + /* may show different cursor shape or color */ + if (gui.in_use) + gui_update_cursor(TRUE, FALSE); +#endif +#if defined(FEAT_WINDOWS) && defined(FEAT_KEYMAP) + /* Show/unshow value of 'keymap' in status lines. */ + status_redraw_curbuf(); +#endif + break; + +#ifdef FEAT_RIGHTLEFT + case Ctrl__: + if (!p_ari) + goto normalchar; + ins_ctrl_(); + break; +#endif + + /* Make indent one shiftwidth smaller. */ + case Ctrl_D: +#if defined(FEAT_INS_EXPAND) && defined(FEAT_FIND_ID) + if (ctrl_x_mode == CTRL_X_PATH_DEFINES) + goto docomplete; +#endif + /* FALLTHROUGH */ + + /* Make indent one shiftwidth greater. */ + case Ctrl_T: +# ifdef FEAT_INS_EXPAND + if (c == Ctrl_T && ctrl_x_mode == CTRL_X_THESAURUS) + { + if (*curbuf->b_p_tsr == NUL && *p_tsr == NUL) + { + ctrl_x_mode = 0; + msg_attr((char_u *)_("'thesaurus' option is empty"), + hl_attr(HLF_E)); + if (emsg_silent == 0) + { + vim_beep(); + setcursor(); + out_flush(); + ui_delay(2000L, FALSE); + } + break; + } + goto docomplete; + } +# endif + ins_shift(c, lastc); + auto_format(FALSE, TRUE); + inserted_space = FALSE; + break; + + /* delete character under the cursor */ + case K_DEL: + case K_KDEL: + ins_del(); + auto_format(FALSE, TRUE); + break; + + /* delete character before the cursor */ + case K_BS: + case Ctrl_H: + did_backspace = ins_bs(c, BACKSPACE_CHAR, &inserted_space); + auto_format(FALSE, TRUE); + break; + + /* delete word before the cursor */ + case Ctrl_W: + did_backspace = ins_bs(c, BACKSPACE_WORD, &inserted_space); + auto_format(FALSE, TRUE); + break; + + /* delete all inserted text in current line */ + case Ctrl_U: + did_backspace = ins_bs(c, BACKSPACE_LINE, &inserted_space); + auto_format(FALSE, TRUE); + inserted_space = FALSE; + break; + +#ifdef FEAT_MOUSE + case K_LEFTMOUSE: + case K_LEFTMOUSE_NM: + case K_LEFTDRAG: + case K_LEFTRELEASE: + case K_LEFTRELEASE_NM: + case K_MIDDLEMOUSE: + case K_MIDDLEDRAG: + case K_MIDDLERELEASE: + case K_RIGHTMOUSE: + case K_RIGHTDRAG: + case K_RIGHTRELEASE: + case K_X1MOUSE: + case K_X1DRAG: + case K_X1RELEASE: + case K_X2MOUSE: + case K_X2DRAG: + case K_X2RELEASE: + ins_mouse(c); + break; + + /* Default action for scroll wheel up: scroll up */ + case K_MOUSEDOWN: + ins_mousescroll(FALSE); + break; + + /* Default action for scroll wheel down: scroll down */ + case K_MOUSEUP: + ins_mousescroll(TRUE); + break; +#endif + + case K_IGNORE: + break; + +#ifdef FEAT_GUI + case K_VER_SCROLLBAR: + ins_scroll(); + break; + + case K_HOR_SCROLLBAR: + ins_horscroll(); + break; +#endif + + case K_HOME: + case K_KHOME: + case K_XHOME: + case K_S_HOME: + case K_C_HOME: + ins_home(c); + break; + + case K_END: + case K_KEND: + case K_XEND: + case K_S_END: + case K_C_END: + ins_end(c); + break; + + case K_LEFT: + ins_left(); + break; + + case K_S_LEFT: + case K_C_LEFT: + ins_s_left(); + break; + + case K_RIGHT: + ins_right(); + break; + + case K_S_RIGHT: + case K_C_RIGHT: + ins_s_right(); + break; + + case K_UP: + ins_up(FALSE); + break; + + case K_S_UP: + case K_PAGEUP: + case K_KPAGEUP: + ins_pageup(); + break; + + case K_DOWN: + ins_down(FALSE); + break; + + case K_S_DOWN: + case K_PAGEDOWN: + case K_KPAGEDOWN: + ins_pagedown(); + break; + +#ifdef FEAT_DND + case K_DROP: + ins_drop(); + break; +#endif + + /* When <S-Tab> isn't mapped, use it like a normal TAB */ + case K_S_TAB: + c = TAB; + /* FALLTHROUGH */ + + /* TAB or Complete patterns along path */ + case TAB: +#if defined(FEAT_INS_EXPAND) && defined(FEAT_FIND_ID) + if (ctrl_x_mode == CTRL_X_PATH_PATTERNS) + goto docomplete; +#endif + inserted_space = FALSE; + if (ins_tab()) + goto normalchar; /* insert TAB as a normal char */ + auto_format(FALSE, TRUE); + break; + + case K_KENTER: + c = CAR; + /* FALLTHROUGH */ + case CAR: + case NL: +#if defined(FEAT_WINDOWS) && defined(FEAT_QUICKFIX) + /* In a quickfix window a <CR> jumps to the error under the + * cursor. */ + if (bt_quickfix(curbuf) && c == CAR) + { + do_cmdline_cmd((char_u *)".cc"); + break; + } +#endif +#ifdef FEAT_CMDWIN + if (cmdwin_type != 0) + { + /* Execute the command in the cmdline window. */ + cmdwin_result = CAR; + goto doESCkey; + } +#endif + if (ins_eol(c) && !p_im) + goto doESCkey; /* out of memory */ + auto_format(FALSE, FALSE); + inserted_space = FALSE; + break; + +#if defined(FEAT_DIGRAPHS) || defined (FEAT_INS_EXPAND) + case Ctrl_K: +# ifdef FEAT_INS_EXPAND + if (ctrl_x_mode == CTRL_X_DICTIONARY) + { + if (*curbuf->b_p_dict == NUL && *p_dict == NUL) + { + ctrl_x_mode = 0; + msg_attr((char_u *)_("'dictionary' option is empty"), + hl_attr(HLF_E)); + if (emsg_silent == 0) + { + vim_beep(); + setcursor(); + out_flush(); + ui_delay(2000L, FALSE); + } + break; + } + goto docomplete; + } +# endif +# ifdef FEAT_DIGRAPHS + c = ins_digraph(); + if (c == NUL) + break; +# endif + goto normalchar; +#endif /* FEAT_DIGRAPHS || FEAT_INS_EXPAND */ + +#ifdef FEAT_INS_EXPAND + case Ctrl_RSB: /* Tag name completion after ^X */ + if (ctrl_x_mode != CTRL_X_TAGS) + goto normalchar; + goto docomplete; + + case Ctrl_F: /* File name completion after ^X */ + if (ctrl_x_mode != CTRL_X_FILES) + goto normalchar; + goto docomplete; +#endif + + case Ctrl_L: /* Whole line completion after ^X */ +#ifdef FEAT_INS_EXPAND + if (ctrl_x_mode != CTRL_X_WHOLE_LINE) +#endif + { + /* CTRL-L with 'insertmode' set: Leave Insert mode */ + if (p_im) + { + if (echeck_abbr(Ctrl_L + ABBR_OFF)) + break; + goto doESCkey; + } + goto normalchar; + } +#ifdef FEAT_INS_EXPAND + /* FALLTHROUGH */ + + /* Do previous/next pattern completion */ + case Ctrl_P: + case Ctrl_N: + /* if 'complete' is empty then plain ^P is no longer special, + * but it is under other ^X modes */ + if (*curbuf->b_p_cpt == NUL + && ctrl_x_mode != 0 + && !(continue_status & CONT_LOCAL)) + goto normalchar; + +docomplete: + if (ins_complete(c) == FAIL) + continue_status = 0; + break; +#endif /* FEAT_INS_EXPAND */ + + case Ctrl_Y: /* copy from previous line or scroll down */ + case Ctrl_E: /* copy from next line or scroll up */ +#ifdef FEAT_INS_EXPAND + if (ctrl_x_mode == CTRL_X_SCROLL) + { + if (c == Ctrl_Y) + scrolldown_clamp(); + else + scrollup_clamp(); + redraw_later(VALID); + } + else +#endif + { + c = ins_copychar(curwin->w_cursor.lnum + + (c == Ctrl_Y ? -1 : 1)); + if (c != NUL) + { + long tw_save; + + /* The character must be taken literally, insert like it + * was typed after a CTRL-V, and pretend 'textwidth' + * wasn't set. Digits, 'o' and 'x' are special after a + * CTRL-V, don't use it for these. */ + if (c < 256 && !isalnum(c)) + AppendToRedobuff((char_u *)CTRL_V_STR); /* CTRL-V */ + tw_save = curbuf->b_p_tw; + curbuf->b_p_tw = -1; + insert_special(c, TRUE, FALSE); + curbuf->b_p_tw = tw_save; +#ifdef FEAT_RIGHTLEFT + revins_chars++; + revins_legal++; +#endif + c = Ctrl_V; /* pretend CTRL-V is last character */ + auto_format(FALSE, TRUE); + } + } + break; + + default: +#ifdef UNIX + if (c == intr_char) /* special interrupt char */ + goto do_intr; +#endif + + /* + * Insert a nomal character. + */ +normalchar: +#ifdef FEAT_SMARTINDENT + /* Try to perform smart-indenting. */ + ins_try_si(c); +#endif + + if (c == ' ') + { + inserted_space = TRUE; +#ifdef FEAT_CINDENT + if (inindent(0)) + can_cindent = FALSE; +#endif + if (Insstart_blank_vcol == MAXCOL + && curwin->w_cursor.lnum == Insstart.lnum) + Insstart_blank_vcol = get_nolist_virtcol(); + } + + if (vim_iswordc(c) || !echeck_abbr( +#ifdef FEAT_MBYTE + /* Add ABBR_OFF for characters above 0x100, this is + * what check_abbr() expects. */ + (has_mbyte && c >= 0x100) ? (c + ABBR_OFF) : +#endif + c)) + { + insert_special(c, FALSE, FALSE); +#ifdef FEAT_RIGHTLEFT + revins_legal++; + revins_chars++; +#endif + } + + auto_format(FALSE, TRUE); + +#ifdef FEAT_FOLDING + /* When inserting a character the cursor line must never be in a + * closed fold. */ + foldOpenCursor(); +#endif + break; + } /* end of switch (c) */ + + /* If the cursor was moved we didn't just insert a space */ + if (arrow_used) + inserted_space = FALSE; + +#ifdef FEAT_CINDENT + if (can_cindent && cindent_on() +# ifdef FEAT_INS_EXPAND + && ctrl_x_mode == 0 +# endif + ) + { +force_cindent: + /* + * Indent now if a key was typed that is in 'cinkeys'. + */ + if (in_cinkeys(c, ' ', line_is_white)) + { + if (stop_arrow() == OK) + /* re-indent the current line */ + do_c_expr_indent(); + } + } +#endif /* FEAT_CINDENT */ + + } /* for (;;) */ + /* NOTREACHED */ +} + +/* + * Redraw for Insert mode. + * This is postponed until getting the next character to make '$' in the 'cpo' + * option work correctly. + * Only redraw when there are no characters available. This speeds up + * inserting sequences of characters (e.g., for CTRL-R). + */ + static void +ins_redraw() +{ + if (!char_avail()) + { + if (must_redraw) + update_screen(0); + else if (clear_cmdline || redraw_cmdline) + showmode(); /* clear cmdline and show mode */ + showruler(FALSE); + setcursor(); + emsg_on_display = FALSE; /* may remove error message now */ + } +} + +/* + * Handle a CTRL-V or CTRL-Q typed in Insert mode. + */ + static void +ins_ctrl_v() +{ + int c; + + /* may need to redraw when no more chars available now */ + ins_redraw(); + + if (redrawing() && !char_avail()) + edit_putchar('^', TRUE); + AppendToRedobuff((char_u *)CTRL_V_STR); /* CTRL-V */ + +#ifdef FEAT_CMDL_INFO + add_to_showcmd_c(Ctrl_V); +#endif + + c = get_literal(); +#ifdef FEAT_CMDL_INFO + clear_showcmd(); +#endif + insert_special(c, FALSE, TRUE); +#ifdef FEAT_RIGHTLEFT + revins_chars++; + revins_legal++; +#endif +} + +/* + * Put a character directly onto the screen. It's not stored in a buffer. + * Used while handling CTRL-K, CTRL-V, etc. in Insert mode. + */ +static int pc_status; +#define PC_STATUS_UNSET 0 /* pc_bytes was not set */ +#define PC_STATUS_RIGHT 1 /* right halve of double-wide char */ +#define PC_STATUS_LEFT 2 /* left halve of double-wide char */ +#define PC_STATUS_SET 3 /* pc_bytes was filled */ +#ifdef FEAT_MBYTE +static char_u pc_bytes[MB_MAXBYTES + 1]; /* saved bytes */ +#else +static char_u pc_bytes[2]; /* saved bytes */ +#endif +static int pc_attr; +static int pc_row; +static int pc_col; + + void +edit_putchar(c, highlight) + int c; + int highlight; +{ + int attr; + + if (ScreenLines != NULL) + { + update_topline(); /* just in case w_topline isn't valid */ + validate_cursor(); + if (highlight) + attr = hl_attr(HLF_8); + else + attr = 0; + pc_row = W_WINROW(curwin) + curwin->w_wrow; + pc_col = W_WINCOL(curwin); +#if defined(FEAT_RIGHTLEFT) || defined(FEAT_MBYTE) + pc_status = PC_STATUS_UNSET; +#endif +#ifdef FEAT_RIGHTLEFT + if (curwin->w_p_rl) + { + pc_col += W_WIDTH(curwin) - 1 - curwin->w_wcol; +# ifdef FEAT_MBYTE + if (has_mbyte) + { + int fix_col = mb_fix_col(pc_col, pc_row); + + if (fix_col != pc_col) + { + screen_putchar(' ', pc_row, fix_col, attr); + --curwin->w_wcol; + pc_status = PC_STATUS_RIGHT; + } + } +# endif + } + else +#endif + { + pc_col += curwin->w_wcol; +#ifdef FEAT_MBYTE + if (mb_lefthalve(pc_row, pc_col)) + pc_status = PC_STATUS_LEFT; +#endif + } + + /* save the character to be able to put it back */ +#if defined(FEAT_RIGHTLEFT) || defined(FEAT_MBYTE) + if (pc_status == PC_STATUS_UNSET) +#endif + { + screen_getbytes(pc_row, pc_col, pc_bytes, &pc_attr); + pc_status = PC_STATUS_SET; + } + screen_putchar(c, pc_row, pc_col, attr); + } +} + +/* + * Undo the previous edit_putchar(). + */ + void +edit_unputchar() +{ + if (pc_status != PC_STATUS_UNSET && pc_row >= msg_scrolled) + { +#if defined(FEAT_MBYTE) + if (pc_status == PC_STATUS_RIGHT) + ++curwin->w_wcol; + if (pc_status == PC_STATUS_RIGHT || pc_status == PC_STATUS_LEFT) + redrawWinline(curwin->w_cursor.lnum, FALSE); + else +#endif + screen_puts(pc_bytes, pc_row - msg_scrolled, pc_col, pc_attr); + } +} + +/* + * Called when p_dollar is set: display a '$' at the end of the changed text + * Only works when cursor is in the line that changes. + */ + void +display_dollar(col) + colnr_T col; +{ + colnr_T save_col; + + if (!redrawing()) + return; + + cursor_off(); + save_col = curwin->w_cursor.col; + curwin->w_cursor.col = col; +#ifdef FEAT_MBYTE + if (has_mbyte) + { + char_u *p; + + /* If on the last byte of a multi-byte move to the first byte. */ + p = ml_get_curline(); + curwin->w_cursor.col -= (*mb_head_off)(p, p + col); + } +#endif + curs_columns(FALSE); /* recompute w_wrow and w_wcol */ + if (curwin->w_wcol < W_WIDTH(curwin)) + { + edit_putchar('$', FALSE); + dollar_vcol = curwin->w_virtcol; + } + curwin->w_cursor.col = save_col; +} + +/* + * Call this function before moving the cursor from the normal insert position + * in insert mode. + */ + static void +undisplay_dollar() +{ + if (dollar_vcol) + { + dollar_vcol = 0; + redrawWinline(curwin->w_cursor.lnum, FALSE); + } +} + +/* + * Insert an indent (for <Tab> or CTRL-T) or delete an indent (for CTRL-D). + * Keep the cursor on the same character. + * type == INDENT_INC increase indent (for CTRL-T or <Tab>) + * type == INDENT_DEC decrease indent (for CTRL-D) + * type == INDENT_SET set indent to "amount" + * if round is TRUE, round the indent to 'shiftwidth' (only with _INC and _Dec). + */ + void +change_indent(type, amount, round, replaced) + int type; + int amount; + int round; + int replaced; /* replaced character, put on replace stack */ +{ + int vcol; + int last_vcol; + int insstart_less; /* reduction for Insstart.col */ + int new_cursor_col; + int i; + char_u *ptr; + int save_p_list; + int start_col; + colnr_T vc; +#ifdef FEAT_VREPLACE + colnr_T orig_col = 0; /* init for GCC */ + char_u *new_line, *orig_line = NULL; /* init for GCC */ + + /* VREPLACE mode needs to know what the line was like before changing */ + if (State & VREPLACE_FLAG) + { + orig_line = vim_strsave(ml_get_curline()); /* Deal with NULL below */ + orig_col = curwin->w_cursor.col; + } +#endif + + /* for the following tricks we don't want list mode */ + save_p_list = curwin->w_p_list; + curwin->w_p_list = FALSE; + vc = getvcol_nolist(&curwin->w_cursor); + vcol = vc; + + /* + * For Replace mode we need to fix the replace stack later, which is only + * possible when the cursor is in the indent. Remember the number of + * characters before the cursor if it's possible. + */ + start_col = curwin->w_cursor.col; + + /* determine offset from first non-blank */ + new_cursor_col = curwin->w_cursor.col; + beginline(BL_WHITE); + new_cursor_col -= curwin->w_cursor.col; + + insstart_less = curwin->w_cursor.col; + + /* + * If the cursor is in the indent, compute how many screen columns the + * cursor is to the left of the first non-blank. + */ + if (new_cursor_col < 0) + vcol = get_indent() - vcol; + + if (new_cursor_col > 0) /* can't fix replace stack */ + start_col = -1; + + /* + * Set the new indent. The cursor will be put on the first non-blank. + */ + if (type == INDENT_SET) + (void)set_indent(amount, SIN_CHANGED); + else + { +#ifdef FEAT_VREPLACE + int save_State = State; + + /* Avoid being called recursively. */ + if (State & VREPLACE_FLAG) + State = INSERT; +#endif + shift_line(type == INDENT_DEC, round, 1); +#ifdef FEAT_VREPLACE + State = save_State; +#endif + } + insstart_less -= curwin->w_cursor.col; + + /* + * Try to put cursor on same character. + * If the cursor is at or after the first non-blank in the line, + * compute the cursor column relative to the column of the first + * non-blank character. + * If we are not in insert mode, leave the cursor on the first non-blank. + * If the cursor is before the first non-blank, position it relative + * to the first non-blank, counted in screen columns. + */ + if (new_cursor_col >= 0) + { + /* + * When changing the indent while the cursor is touching it, reset + * Insstart_col to 0. + */ + if (new_cursor_col == 0) + insstart_less = MAXCOL; + new_cursor_col += curwin->w_cursor.col; + } + else if (!(State & INSERT)) + new_cursor_col = curwin->w_cursor.col; + else + { + /* + * Compute the screen column where the cursor should be. + */ + vcol = get_indent() - vcol; + curwin->w_virtcol = (vcol < 0) ? 0 : vcol; + + /* + * Advance the cursor until we reach the right screen column. + */ + vcol = last_vcol = 0; + new_cursor_col = -1; + ptr = ml_get_curline(); + while (vcol <= (int)curwin->w_virtcol) + { + last_vcol = vcol; +#ifdef FEAT_MBYTE + if (has_mbyte && new_cursor_col >= 0) + new_cursor_col += (*mb_ptr2len_check)(ptr + new_cursor_col); + else +#endif + ++new_cursor_col; + vcol += lbr_chartabsize(ptr + new_cursor_col, (colnr_T)vcol); + } + vcol = last_vcol; + + /* + * May need to insert spaces to be able to position the cursor on + * the right screen column. + */ + if (vcol != (int)curwin->w_virtcol) + { + curwin->w_cursor.col = new_cursor_col; + i = (int)curwin->w_virtcol - vcol; + ptr = alloc(i + 1); + if (ptr != NULL) + { + new_cursor_col += i; + ptr[i] = NUL; + while (--i >= 0) + ptr[i] = ' '; + ins_str(ptr); + vim_free(ptr); + } + } + + /* + * When changing the indent while the cursor is in it, reset + * Insstart_col to 0. + */ + insstart_less = MAXCOL; + } + + curwin->w_p_list = save_p_list; + + if (new_cursor_col <= 0) + curwin->w_cursor.col = 0; + else + curwin->w_cursor.col = new_cursor_col; + curwin->w_set_curswant = TRUE; + changed_cline_bef_curs(); + + /* + * May have to adjust the start of the insert. + */ + if (State & INSERT) + { + if (curwin->w_cursor.lnum == Insstart.lnum && Insstart.col != 0) + { + if ((int)Insstart.col <= insstart_less) + Insstart.col = 0; + else + Insstart.col -= insstart_less; + } + if ((int)ai_col <= insstart_less) + ai_col = 0; + else + ai_col -= insstart_less; + } + + /* + * For REPLACE mode, may have to fix the replace stack, if it's possible. + * If the number of characters before the cursor decreased, need to pop a + * few characters from the replace stack. + * If the number of characters before the cursor increased, need to push a + * few NULs onto the replace stack. + */ + if (REPLACE_NORMAL(State) && start_col >= 0) + { + while (start_col > (int)curwin->w_cursor.col) + { + replace_join(0); /* remove a NUL from the replace stack */ + --start_col; + } + while (start_col < (int)curwin->w_cursor.col || replaced) + { + replace_push(NUL); + if (replaced) + { + replace_push(replaced); + replaced = NUL; + } + ++start_col; + } + } + +#ifdef FEAT_VREPLACE + /* + * For VREPLACE mode, we also have to fix the replace stack. In this case + * it is always possible because we backspace over the whole line and then + * put it back again the way we wanted it. + */ + if (State & VREPLACE_FLAG) + { + /* If orig_line didn't allocate, just return. At least we did the job, + * even if you can't backspace. */ + if (orig_line == NULL) + return; + + /* Save new line */ + new_line = vim_strsave(ml_get_curline()); + if (new_line == NULL) + return; + + /* We only put back the new line up to the cursor */ + new_line[curwin->w_cursor.col] = NUL; + + /* Put back original line */ + ml_replace(curwin->w_cursor.lnum, orig_line, FALSE); + curwin->w_cursor.col = orig_col; + + /* Backspace from cursor to start of line */ + backspace_until_column(0); + + /* Insert new stuff into line again */ + ins_bytes(new_line); + + vim_free(new_line); + } +#endif +} + +/* + * Truncate the space at the end of a line. This is to be used only in an + * insert mode. It handles fixing the replace stack for REPLACE and VREPLACE + * modes. + */ + void +truncate_spaces(line) + char_u *line; +{ + int i; + + /* find start of trailing white space */ + for (i = (int)STRLEN(line) - 1; i >= 0 && vim_iswhite(line[i]); i--) + { + if (State & REPLACE_FLAG) + replace_join(0); /* remove a NUL from the replace stack */ + } + line[i + 1] = NUL; +} + +#if defined(FEAT_VREPLACE) || defined(FEAT_INS_EXPAND) \ + || defined(FEAT_COMMENTS) || defined(PROTO) +/* + * Backspace the cursor until the given column. Handles REPLACE and VREPLACE + * modes correctly. May also be used when not in insert mode at all. + */ + void +backspace_until_column(col) + int col; +{ + while ((int)curwin->w_cursor.col > col) + { + curwin->w_cursor.col--; + if (State & REPLACE_FLAG) + replace_do_bs(); + else + (void)del_char(FALSE); + } +} +#endif + +#if defined(FEAT_INS_EXPAND) || defined(PROTO) +/* + * Is the character 'c' a valid key to go to or keep us in CTRL-X mode? + * This depends on the current mode. + */ + int +vim_is_ctrl_x_key(c) + int c; +{ + /* Always allow ^R - let it's results then be checked */ + if (c == Ctrl_R) + return TRUE; + + switch (ctrl_x_mode) + { + case 0: /* Not in any CTRL-X mode */ + return (c == Ctrl_N || c == Ctrl_P || c == Ctrl_X); + case CTRL_X_NOT_DEFINED_YET: + return ( c == Ctrl_X || c == Ctrl_Y || c == Ctrl_E + || c == Ctrl_L || c == Ctrl_F || c == Ctrl_RSB + || c == Ctrl_I || c == Ctrl_D || c == Ctrl_P + || c == Ctrl_N || c == Ctrl_T || c == Ctrl_V + || c == Ctrl_Q); + case CTRL_X_SCROLL: + return (c == Ctrl_Y || c == Ctrl_E); + case CTRL_X_WHOLE_LINE: + return (c == Ctrl_L || c == Ctrl_P || c == Ctrl_N); + case CTRL_X_FILES: + return (c == Ctrl_F || c == Ctrl_P || c == Ctrl_N); + case CTRL_X_DICTIONARY: + return (c == Ctrl_K || c == Ctrl_P || c == Ctrl_N); + case CTRL_X_THESAURUS: + return (c == Ctrl_T || c == Ctrl_P || c == Ctrl_N); + case CTRL_X_TAGS: + return (c == Ctrl_RSB || c == Ctrl_P || c == Ctrl_N); +#ifdef FEAT_FIND_ID + case CTRL_X_PATH_PATTERNS: + return (c == Ctrl_P || c == Ctrl_N); + case CTRL_X_PATH_DEFINES: + return (c == Ctrl_D || c == Ctrl_P || c == Ctrl_N); +#endif + case CTRL_X_CMDLINE: + return (c == Ctrl_V || c == Ctrl_Q || c == Ctrl_P || c == Ctrl_N + || c == Ctrl_X); + } + EMSG(_(e_internal)); + return FALSE; +} + +/* + * This is like ins_compl_add(), but if ic and inf are set, then the + * case of the originally typed text is used, and the case of the completed + * text is infered, ie this tries to work out what case you probably wanted + * the rest of the word to be in -- webb + */ + int +ins_compl_add_infercase(str, len, fname, dir, reuse) + char_u *str; + int len; + char_u *fname; + int dir; + int reuse; +{ + int has_lower = FALSE; + int was_letter = FALSE; + int idx; + + if (p_ic && curbuf->b_p_inf && len < IOSIZE) + { + /* Infer case of completed part -- webb */ + /* Use IObuff, str would change text in buffer! */ + STRNCPY(IObuff, str, len); + IObuff[len] = NUL; + + /* Rule 1: Were any chars converted to lower? */ + for (idx = 0; idx < completion_length; ++idx) + { + if (islower(original_text[idx])) + { + has_lower = TRUE; + if (isupper(IObuff[idx])) + { + /* Rule 1 is satisfied */ + for (idx = completion_length; idx < len; ++idx) + IObuff[idx] = TOLOWER_LOC(IObuff[idx]); + break; + } + } + } + + /* + * Rule 2: No lower case, 2nd consecutive letter converted to + * upper case. + */ + if (!has_lower) + { + for (idx = 0; idx < completion_length; ++idx) + { + if (was_letter && isupper(original_text[idx]) + && islower(IObuff[idx])) + { + /* Rule 2 is satisfied */ + for (idx = completion_length; idx < len; ++idx) + IObuff[idx] = TOUPPER_LOC(IObuff[idx]); + break; + } + was_letter = isalpha(original_text[idx]); + } + } + + /* Copy the original case of the part we typed */ + STRNCPY(IObuff, original_text, completion_length); + + return ins_compl_add(IObuff, len, fname, dir, reuse); + } + return ins_compl_add(str, len, fname, dir, reuse); +} + +/* + * Add a match to the list of matches. + * If the given string is already in the list of completions, then return + * FAIL, otherwise add it to the list and return OK. If there is an error, + * maybe because alloc returns NULL, then RET_ERROR is returned -- webb. + */ + static int +ins_compl_add(str, len, fname, dir, reuse) + char_u *str; + int len; + char_u *fname; + int dir; + int reuse; +{ + struct Completion *match; + + ui_breakcheck(); + if (got_int) + return RET_ERROR; + if (len < 0) + len = (int)STRLEN(str); + + /* + * If the same match is already present, don't add it. + */ + if (first_match != NULL) + { + match = first_match; + do + { + if ( !(match->original & ORIGINAL_TEXT) + && STRNCMP(match->str, str, (size_t)len) == 0 + && match->str[len] == NUL) + return FAIL; + match = match->next; + } while (match != NULL && match != first_match); + } + + /* + * Allocate a new match structure. + * Copy the values to the new match structure. + */ + match = (struct Completion *)alloc((unsigned)sizeof(struct Completion)); + if (match == NULL) + return RET_ERROR; + match->number = -1; + if (reuse & ORIGINAL_TEXT) + { + match->number = 0; + match->str = original_text; + } + else if ((match->str = vim_strnsave(str, len)) == NULL) + { + vim_free(match); + return RET_ERROR; + } + /* match-fname is: + * - curr_match->fname if it is a string equal to fname. + * - a copy of fname, FREE_FNAME is set to free later THE allocated mem. + * - NULL otherwise. --Acevedo */ + if (fname && curr_match && curr_match->fname + && STRCMP(fname, curr_match->fname) == 0) + match->fname = curr_match->fname; + else if (fname && (match->fname = vim_strsave(fname)) != NULL) + reuse |= FREE_FNAME; + else + match->fname = NULL; + match->original = reuse; + + /* + * Link the new match structure in the list of matches. + */ + if (first_match == NULL) + match->next = match->prev = NULL; + else if (dir == FORWARD) + { + match->next = curr_match->next; + match->prev = curr_match; + } + else /* BACKWARD */ + { + match->next = curr_match; + match->prev = curr_match->prev; + } + if (match->next) + match->next->prev = match; + if (match->prev) + match->prev->next = match; + else /* if there's nothing before, it is the first match */ + first_match = match; + curr_match = match; + + return OK; +} + +/* + * Add an array of matches to the list of matches. + * Frees matches[]. + */ + static void +ins_compl_add_matches(num_matches, matches, dir) + int num_matches; + char_u **matches; + int dir; +{ + int i; + int add_r = OK; + int ldir = dir; + + for (i = 0; i < num_matches && add_r != RET_ERROR; i++) + if ((add_r = ins_compl_add(matches[i], -1, NULL, ldir, 0)) == OK) + /* if dir was BACKWARD then honor it just once */ + ldir = FORWARD; + FreeWild(num_matches, matches); +} + +/* Make the completion list cyclic. + * Return the number of matches (excluding the original). + */ + static int +ins_compl_make_cyclic() +{ + struct Completion *match; + int count = 0; + + if (first_match != NULL) + { + /* + * Find the end of the list. + */ + match = first_match; + /* there's always an entry for the original_text, it doesn't count. */ + while (match->next != NULL && match->next != first_match) + { + match = match->next; + ++count; + } + match->next = first_match; + first_match->prev = match; + } + return count; +} + +#define DICT_FIRST (1) /* use just first element in "dict" */ +#define DICT_EXACT (2) /* "dict" is the exact name of a file */ +/* + * Add any identifiers that match the given pattern to the list of + * completions. + */ + static void +ins_compl_dictionaries(dict, pat, dir, flags, thesaurus) + char_u *dict; + char_u *pat; + int dir; + int flags; + int thesaurus; +{ + char_u *ptr; + char_u *buf; + FILE *fp; + regmatch_T regmatch; + int add_r; + char_u **files; + int count; + int i; + int save_p_scs; + + buf = alloc(LSIZE); + /* If 'infercase' is set, don't use 'smartcase' here */ + save_p_scs = p_scs; + if (curbuf->b_p_inf) + p_scs = FALSE; + regmatch.regprog = vim_regcomp(pat, p_magic ? RE_MAGIC : 0); + /* ignore case depends on 'ignorecase', 'smartcase' and "pat" */ + regmatch.rm_ic = ignorecase(pat); + while (buf != NULL && regmatch.regprog != NULL && *dict != NUL + && !got_int && !completion_interrupted) + { + /* copy one dictionary file name into buf */ + if (flags == DICT_EXACT) + { + count = 1; + files = &dict; + } + else + { + /* Expand wildcards in the dictionary name, but do not allow + * backticks (for security, the 'dict' option may have been set in + * a modeline). */ + copy_option_part(&dict, buf, LSIZE, ","); + if (vim_strchr(buf, '`') != NULL + || expand_wildcards(1, &buf, &count, &files, + EW_FILE|EW_SILENT) != OK) + count = 0; + } + + for (i = 0; i < count && !got_int && !completion_interrupted; i++) + { + fp = mch_fopen((char *)files[i], "r"); /* open dictionary file */ + if (flags != DICT_EXACT) + { + sprintf((char*)IObuff, _("Scanning dictionary: %s"), + (char *)files[i]); + msg_trunc_attr(IObuff, TRUE, hl_attr(HLF_R)); + } + + if (fp != NULL) + { + /* + * Read dictionary file line by line. + * Check each line for a match. + */ + while (!got_int && !completion_interrupted + && !vim_fgets(buf, LSIZE, fp)) + { + ptr = buf; + while (vim_regexec(®match, buf, (colnr_T)(ptr - buf))) + { + ptr = regmatch.startp[0]; + ptr = find_word_end(ptr); + add_r = ins_compl_add_infercase(regmatch.startp[0], + (int)(ptr - regmatch.startp[0]), + files[i], dir, 0); + if (thesaurus) + { + char_u *wstart; + + /* + * Add the other matches on the line + */ + while (!got_int) + { + /* Find start of the next word. Skip white + * space and punctuation. */ + ptr = find_word_start(ptr); + if (*ptr == NUL || *ptr == NL) + break; + wstart = ptr; + + /* Find end of the word and add it. */ +#ifdef FEAT_MBYTE + if (has_mbyte) + /* Japanese words may have characters in + * different classes, only separate words + * with single-byte non-word characters. */ + while (*ptr != NUL) + { + int l = (*mb_ptr2len_check)(ptr); + + if (l < 2 && !vim_iswordc(*ptr)) + break; + ptr += l; + } + else +#endif + ptr = find_word_end(ptr); + add_r = ins_compl_add_infercase(wstart, + (int)(ptr - wstart), files[i], dir, 0); + } + } + if (add_r == OK) + /* if dir was BACKWARD then honor it just once */ + dir = FORWARD; + else if (add_r == RET_ERROR) + break; + /* avoid expensive call to vim_regexec() when at end + * of line */ + if (*ptr == '\n' || got_int) + break; + } + line_breakcheck(); + ins_compl_check_keys(); + } + fclose(fp); + } + } + if (flags != DICT_EXACT) + FreeWild(count, files); + if (flags) + break; + } + p_scs = save_p_scs; + vim_free(regmatch.regprog); + vim_free(buf); +} + +/* + * Find the start of the next word. + * Returns a pointer to the first char of the word. Also stops at a NUL. + */ + char_u * +find_word_start(ptr) + char_u *ptr; +{ +#ifdef FEAT_MBYTE + if (has_mbyte) + while (*ptr != NUL && *ptr != '\n' && mb_get_class(ptr) <= 1) + ptr += (*mb_ptr2len_check)(ptr); + else +#endif + while (*ptr != NUL && *ptr != '\n' && !vim_iswordc(*ptr)) + ++ptr; + return ptr; +} + +/* + * Find the end of the word. Assumes it starts inside a word. + * Returns a pointer to just after the word. + */ + char_u * +find_word_end(ptr) + char_u *ptr; +{ +#ifdef FEAT_MBYTE + int start_class; + + if (has_mbyte) + { + start_class = mb_get_class(ptr); + if (start_class > 1) + while (*ptr != NUL) + { + ptr += (*mb_ptr2len_check)(ptr); + if (mb_get_class(ptr) != start_class) + break; + } + } + else +#endif + while (vim_iswordc(*ptr)) + ++ptr; + return ptr; +} + +/* + * Free the list of completions + */ + static void +ins_compl_free() +{ + struct Completion *match; + + vim_free(complete_pat); + complete_pat = NULL; + + if (first_match == NULL) + return; + curr_match = first_match; + do + { + match = curr_match; + curr_match = curr_match->next; + vim_free(match->str); + /* several entries may use the same fname, free it just once. */ + if (match->original & FREE_FNAME) + vim_free(match->fname); + vim_free(match); + } while (curr_match != NULL && curr_match != first_match); + first_match = curr_match = NULL; +} + + static void +ins_compl_clear() +{ + continue_status = 0; + started_completion = FALSE; + completion_matches = 0; + vim_free(complete_pat); + complete_pat = NULL; + save_sm = -1; + edit_submode_extra = NULL; +} + +/* + * Prepare for Insert mode completion, or stop it. + */ + static void +ins_compl_prep(c) + int c; +{ + char_u *ptr; + char_u *tmp_ptr; + int temp; + int want_cindent; + + /* Forget any previous 'special' messages if this is actually + * a ^X mode key - bar ^R, in which case we wait to see what it gives us. + */ + if (c != Ctrl_R && vim_is_ctrl_x_key(c)) + edit_submode_extra = NULL; + + /* Ignore end of Select mode mapping */ + if (c == K_SELECT) + return; + + if (ctrl_x_mode == CTRL_X_NOT_DEFINED_YET) + { + /* + * We have just typed CTRL-X and aren't quite sure which CTRL-X mode + * it will be yet. Now we decide. + */ + switch (c) + { + case Ctrl_E: + case Ctrl_Y: + ctrl_x_mode = CTRL_X_SCROLL; + if (!(State & REPLACE_FLAG)) + edit_submode = (char_u *)_(" (insert) Scroll (^E/^Y)"); + else + edit_submode = (char_u *)_(" (replace) Scroll (^E/^Y)"); + edit_submode_pre = NULL; + showmode(); + break; + case Ctrl_L: + ctrl_x_mode = CTRL_X_WHOLE_LINE; + break; + case Ctrl_F: + ctrl_x_mode = CTRL_X_FILES; + break; + case Ctrl_K: + ctrl_x_mode = CTRL_X_DICTIONARY; + break; + case Ctrl_R: + /* Simply allow ^R to happen without affecting ^X mode */ + break; + case Ctrl_T: + ctrl_x_mode = CTRL_X_THESAURUS; + break; + case Ctrl_RSB: + ctrl_x_mode = CTRL_X_TAGS; + break; +#ifdef FEAT_FIND_ID + case Ctrl_I: + case K_S_TAB: + ctrl_x_mode = CTRL_X_PATH_PATTERNS; + break; + case Ctrl_D: + ctrl_x_mode = CTRL_X_PATH_DEFINES; + break; +#endif + case Ctrl_V: + case Ctrl_Q: + ctrl_x_mode = CTRL_X_CMDLINE; + break; + case Ctrl_P: + case Ctrl_N: + /* ^X^P means LOCAL expansion if nothing interrupted (eg we + * just started ^X mode, or there were enough ^X's to cancel + * the previous mode, say ^X^F^X^X^P or ^P^X^X^X^P, see below) + * do normal expansion when interrupting a different mode (say + * ^X^F^X^P or ^P^X^X^P, see below) + * nothing changes if interrupting mode 0, (eg, the flag + * doesn't change when going to ADDING mode -- Acevedo */ + if (!(continue_status & CONT_INTRPT)) + continue_status |= CONT_LOCAL; + else if (continue_mode != 0) + continue_status &= ~CONT_LOCAL; + /* FALLTHROUGH */ + default: + /* if we have typed at least 2 ^X's... for modes != 0, we set + * continue_status = 0 (eg, as if we had just started ^X mode) + * for mode 0, we set continue_mode to an impossible value, in + * both cases ^X^X can be used to restart the same mode + * (avoiding ADDING mode). Undocumented feature: + * In a mode != 0 ^X^P and ^X^X^P start 'complete' and local + * ^P expansions respectively. In mode 0 an extra ^X is + * needed since ^X^P goes to ADDING mode -- Acevedo */ + if (c == Ctrl_X) + { + if (continue_mode != 0) + continue_status = 0; + else + continue_mode = CTRL_X_NOT_DEFINED_YET; + } + ctrl_x_mode = 0; + edit_submode = NULL; + showmode(); + break; + } + } + else if (ctrl_x_mode != 0) + { + /* We're already in CTRL-X mode, do we stay in it? */ + if (!vim_is_ctrl_x_key(c)) + { + if (ctrl_x_mode == CTRL_X_SCROLL) + ctrl_x_mode = 0; + else + ctrl_x_mode = CTRL_X_FINISHED; + edit_submode = NULL; + } + showmode(); + } + + if (started_completion || ctrl_x_mode == CTRL_X_FINISHED) + { + /* Show error message from attempted keyword completion (probably + * 'Pattern not found') until another key is hit, then go back to + * showing what mode we are in. + */ + showmode(); + if ((ctrl_x_mode == 0 && c != Ctrl_N && c != Ctrl_P && c != Ctrl_R) + || ctrl_x_mode == CTRL_X_FINISHED) + { + /* Get here when we have finished typing a sequence of ^N and + * ^P or other completion characters in CTRL-X mode. Free up + * memory that was used, and make sure we can redo the insert. + */ + if (curr_match != NULL) + { + /* + * If any of the original typed text has been changed, + * eg when ignorecase is set, we must add back-spaces to + * the redo buffer. We add as few as necessary to delete + * just the part of the original text that has changed. + */ + ptr = curr_match->str; + tmp_ptr = original_text; + while (*tmp_ptr && *tmp_ptr == *ptr) + { + ++tmp_ptr; + ++ptr; + } + for (temp = 0; tmp_ptr[temp]; ++temp) + AppendCharToRedobuff(K_BS); + AppendToRedobuffLit(ptr); + } + +#ifdef FEAT_CINDENT + want_cindent = (can_cindent && cindent_on()); +#endif + /* + * When completing whole lines: fix indent for 'cindent'. + * Otherwise, break line if it's too long. + */ + if (continue_mode == CTRL_X_WHOLE_LINE) + { +#ifdef FEAT_CINDENT + /* re-indent the current line */ + if (want_cindent) + { + do_c_expr_indent(); + want_cindent = FALSE; /* don't do it again */ + } +#endif + } + else + { + /* put the cursor on the last char, for 'tw' formatting */ + curwin->w_cursor.col--; + if (stop_arrow() == OK) + insertchar(NUL, 0, -1); + curwin->w_cursor.col++; + } + + auto_format(FALSE, TRUE); + + ins_compl_free(); + started_completion = FALSE; + completion_matches = 0; + msg_clr_cmdline(); /* necessary for "noshowmode" */ + ctrl_x_mode = 0; + p_sm = save_sm; + if (edit_submode != NULL) + { + edit_submode = NULL; + showmode(); + } + +#ifdef FEAT_CINDENT + /* + * Indent now if a key was typed that is in 'cinkeys'. + */ + if (want_cindent && in_cinkeys(KEY_COMPLETE, ' ', inindent(0))) + do_c_expr_indent(); +#endif + } + } + + /* reset continue_* if we left expansion-mode, if we stay they'll be + * (re)set properly in ins_complete() */ + if (!vim_is_ctrl_x_key(c)) + { + continue_status = 0; + continue_mode = 0; + } +} + +/* + * Loops through the list of windows, loaded-buffers or non-loaded-buffers + * (depending on flag) starting from buf and looking for a non-scanned + * buffer (other than curbuf). curbuf is special, if it is called with + * buf=curbuf then it has to be the first call for a given flag/expansion. + * + * Returns the buffer to scan, if any, otherwise returns curbuf -- Acevedo + */ + static buf_T * +ins_compl_next_buf(buf, flag) + buf_T *buf; + int flag; +{ +#ifdef FEAT_WINDOWS + static win_T *wp; +#endif + + if (flag == 'w') /* just windows */ + { +#ifdef FEAT_WINDOWS + if (buf == curbuf) /* first call for this flag/expansion */ + wp = curwin; + while ((wp = wp->w_next != NULL ? wp->w_next : firstwin) != curwin + && wp->w_buffer->b_scanned) + ; + buf = wp->w_buffer; +#else + buf = curbuf; +#endif + } + else + /* 'b' (just loaded buffers), 'u' (just non-loaded buffers) or 'U' + * (unlisted buffers) + * When completing whole lines skip unloaded buffers. */ + while ((buf = buf->b_next != NULL ? buf->b_next : firstbuf) != curbuf + && ((flag == 'U' + ? buf->b_p_bl + : (!buf->b_p_bl + || (buf->b_ml.ml_mfp == NULL) != (flag == 'u'))) + || buf->b_scanned + || (buf->b_ml.ml_mfp == NULL + && ctrl_x_mode == CTRL_X_WHOLE_LINE))) + ; + return buf; +} + +/* + * Get the next expansion(s) for the text starting at the initial curbuf + * position "ini" and in the direction dir. + * Return the total of matches or -1 if still unknown -- Acevedo + */ + static int +ins_compl_get_exp(ini, dir) + pos_T *ini; + int dir; +{ + static pos_T first_match_pos; + static pos_T last_match_pos; + static char_u *e_cpt = (char_u *)""; /* curr. entry in 'complete' */ + static int found_all = FALSE; /* Found all matches. */ + static buf_T *ins_buf = NULL; + + pos_T *pos; + char_u **matches; + int save_p_scs; + int save_p_ws; + int save_p_ic; + int i; + int num_matches; + int len; + int found_new_match; + int type = ctrl_x_mode; + char_u *ptr; + char_u *tmp_ptr; + char_u *dict = NULL; + int dict_f = 0; + struct Completion *old_match; + + if (!started_completion) + { + for (ins_buf = firstbuf; ins_buf != NULL; ins_buf = ins_buf->b_next) + ins_buf->b_scanned = 0; + found_all = FALSE; + ins_buf = curbuf; + e_cpt = continue_status & CONT_LOCAL ? (char_u *)"." : curbuf->b_p_cpt; + last_match_pos = first_match_pos = *ini; + } + + old_match = curr_match; /* remember the last current match */ + pos = (dir == FORWARD) ? &last_match_pos : &first_match_pos; + /* For ^N/^P loop over all the flags/windows/buffers in 'complete' */ + for (;;) + { + found_new_match = FAIL; + + /* For ^N/^P pick a new entry from e_cpt if started_completion is off, + * or if found_all says this entry is done. For ^X^L only use the + * entries from 'complete' that look in loaded buffers. */ + if ((ctrl_x_mode == 0 || ctrl_x_mode == CTRL_X_WHOLE_LINE) + && (!started_completion || found_all)) + { + found_all = FALSE; + while (*e_cpt == ',' || *e_cpt == ' ') + e_cpt++; + if (*e_cpt == '.' && !curbuf->b_scanned) + { + ins_buf = curbuf; + first_match_pos = *ini; + /* So that ^N can match word immediately after cursor */ + if (ctrl_x_mode == 0) + dec(&first_match_pos); + last_match_pos = first_match_pos; + type = 0; + } + else if (vim_strchr((char_u *)"buwU", *e_cpt) != NULL + && (ins_buf = ins_compl_next_buf(ins_buf, *e_cpt)) != curbuf) + { + /* Scan a buffer, but not the current one. */ + if (ins_buf->b_ml.ml_mfp != NULL) /* loaded buffer */ + { + started_completion = TRUE; + first_match_pos.col = last_match_pos.col = 0; + first_match_pos.lnum = ins_buf->b_ml.ml_line_count + 1; + last_match_pos.lnum = 0; + type = 0; + } + else /* unloaded buffer, scan like dictionary */ + { + found_all = TRUE; + if (ins_buf->b_fname == NULL) + continue; + type = CTRL_X_DICTIONARY; + dict = ins_buf->b_fname; + dict_f = DICT_EXACT; + } + sprintf((char *)IObuff, _("Scanning: %s"), + ins_buf->b_fname == NULL + ? buf_spname(ins_buf) + : ins_buf->b_sfname == NULL + ? (char *)ins_buf->b_fname + : (char *)ins_buf->b_sfname); + msg_trunc_attr(IObuff, TRUE, hl_attr(HLF_R)); + } + else if (*e_cpt == NUL) + break; + else + { + if (ctrl_x_mode == CTRL_X_WHOLE_LINE) + type = -1; + else if (*e_cpt == 'k' || *e_cpt == 's') + { + if (*e_cpt == 'k') + type = CTRL_X_DICTIONARY; + else + type = CTRL_X_THESAURUS; + if (*++e_cpt != ',' && *e_cpt != NUL) + { + dict = e_cpt; + dict_f = DICT_FIRST; + } + } +#ifdef FEAT_FIND_ID + else if (*e_cpt == 'i') + type = CTRL_X_PATH_PATTERNS; + else if (*e_cpt == 'd') + type = CTRL_X_PATH_DEFINES; +#endif + else if (*e_cpt == ']' || *e_cpt == 't') + { + type = CTRL_X_TAGS; + sprintf((char*)IObuff, _("Scanning tags.")); + msg_trunc_attr(IObuff, TRUE, hl_attr(HLF_R)); + } + else + type = -1; + + /* in any case e_cpt is advanced to the next entry */ + (void)copy_option_part(&e_cpt, IObuff, IOSIZE, ","); + + found_all = TRUE; + if (type == -1) + continue; + } + } + + switch (type) + { + case -1: + break; +#ifdef FEAT_FIND_ID + case CTRL_X_PATH_PATTERNS: + case CTRL_X_PATH_DEFINES: + find_pattern_in_path(complete_pat, dir, + (int)STRLEN(complete_pat), FALSE, FALSE, + (type == CTRL_X_PATH_DEFINES + && !(continue_status & CONT_SOL)) + ? FIND_DEFINE : FIND_ANY, 1L, ACTION_EXPAND, + (linenr_T)1, (linenr_T)MAXLNUM); + break; +#endif + + case CTRL_X_DICTIONARY: + case CTRL_X_THESAURUS: + ins_compl_dictionaries( + dict ? dict + : (type == CTRL_X_THESAURUS + ? (*curbuf->b_p_tsr == NUL + ? p_tsr + : curbuf->b_p_tsr) + : (*curbuf->b_p_dict == NUL + ? p_dict + : curbuf->b_p_dict)), + complete_pat, dir, + dict ? dict_f : 0, type == CTRL_X_THESAURUS); + dict = NULL; + break; + + case CTRL_X_TAGS: + /* set p_ic according to p_ic, p_scs and pat for find_tags(). */ + save_p_ic = p_ic; + p_ic = ignorecase(complete_pat); + + /* Find up to TAG_MANY matches. Avoids that an enourmous number + * of matches is found when complete_pat is empty */ + if (find_tags(complete_pat, &num_matches, &matches, + TAG_REGEXP | TAG_NAMES | TAG_NOIC | + TAG_INS_COMP | (ctrl_x_mode ? TAG_VERBOSE : 0), + TAG_MANY, curbuf->b_ffname) == OK && num_matches > 0) + { + ins_compl_add_matches(num_matches, matches, dir); + } + p_ic = save_p_ic; + break; + + case CTRL_X_FILES: + if (expand_wildcards(1, &complete_pat, &num_matches, &matches, + EW_FILE|EW_DIR|EW_ADDSLASH|EW_SILENT) == OK) + { + + /* May change home directory back to "~". */ + tilde_replace(complete_pat, num_matches, matches); + ins_compl_add_matches(num_matches, matches, dir); + } + break; + + case CTRL_X_CMDLINE: + if (expand_cmdline(&complete_xp, complete_pat, + (int)STRLEN(complete_pat), + &num_matches, &matches) == EXPAND_OK) + ins_compl_add_matches(num_matches, matches, dir); + break; + + default: /* normal ^P/^N and ^X^L */ + /* + * If 'infercase' is set, don't use 'smartcase' here + */ + save_p_scs = p_scs; + if (ins_buf->b_p_inf) + p_scs = FALSE; + /* buffers other than curbuf are scanned from the beginning or the + * end but never from the middle, thus setting nowrapscan in this + * buffers is a good idea, on the other hand, we always set + * wrapscan for curbuf to avoid missing matches -- Acevedo,Webb */ + save_p_ws = p_ws; + if (ins_buf != curbuf) + p_ws = FALSE; + else if (*e_cpt == '.') + p_ws = TRUE; + for (;;) + { + int reuse = 0; + + /* ctrl_x_mode == CTRL_X_WHOLE_LINE || word-wise search that has + * added a word that was at the beginning of the line */ + if ( ctrl_x_mode == CTRL_X_WHOLE_LINE + || (continue_status & CONT_SOL)) + found_new_match = search_for_exact_line(ins_buf, pos, + dir, complete_pat); + else + found_new_match = searchit(NULL, ins_buf, pos, dir, + complete_pat, 1L, SEARCH_KEEP + SEARCH_NFMSG, + RE_LAST); + if (!started_completion) + { + /* set started_completion even on fail */ + started_completion = TRUE; + first_match_pos = *pos; + last_match_pos = *pos; + } + else if (first_match_pos.lnum == last_match_pos.lnum + && first_match_pos.col == last_match_pos.col) + found_new_match = FAIL; + if (found_new_match == FAIL) + { + if (ins_buf == curbuf) + found_all = TRUE; + break; + } + + /* when ADDING, the text before the cursor matches, skip it */ + if ( (continue_status & CONT_ADDING) && ins_buf == curbuf + && ini->lnum == pos->lnum + && ini->col == pos->col) + continue; + ptr = ml_get_buf(ins_buf, pos->lnum, FALSE) + pos->col; + if (ctrl_x_mode == CTRL_X_WHOLE_LINE) + { + if (continue_status & CONT_ADDING) + { + if (pos->lnum >= ins_buf->b_ml.ml_line_count) + continue; + ptr = ml_get_buf(ins_buf, pos->lnum + 1, FALSE); + if (!p_paste) + ptr = skipwhite(ptr); + } + len = (int)STRLEN(ptr); + } + else + { + tmp_ptr = ptr; + if (continue_status & CONT_ADDING) + { + tmp_ptr += completion_length; + /* Skip if already inside a word. */ + if (vim_iswordp(tmp_ptr)) + continue; + /* Find start of next word. */ + tmp_ptr = find_word_start(tmp_ptr); + } + /* Find end of this word. */ + tmp_ptr = find_word_end(tmp_ptr); + len = (int)(tmp_ptr - ptr); + + if ((continue_status & CONT_ADDING) + && len == completion_length) + { + if (pos->lnum < ins_buf->b_ml.ml_line_count) + { + /* Try next line, if any. the new word will be + * "join" as if the normal command "J" was used. + * IOSIZE is always greater than + * completion_length, so the next STRNCPY always + * works -- Acevedo */ + STRNCPY(IObuff, ptr, len); + ptr = ml_get_buf(ins_buf, pos->lnum + 1, FALSE); + tmp_ptr = ptr = skipwhite(ptr); + /* Find start of next word. */ + tmp_ptr = find_word_start(tmp_ptr); + /* Find end of next word. */ + tmp_ptr = find_word_end(tmp_ptr); + if (tmp_ptr > ptr) + { + if (*ptr != ')' && IObuff[len-1] != TAB) + { + if (IObuff[len-1] != ' ') + IObuff[len++] = ' '; + /* IObuf =~ "\k.* ", thus len >= 2 */ + if (p_js + && (IObuff[len-2] == '.' + || (vim_strchr(p_cpo, CPO_JOINSP) + == NULL + && (IObuff[len-2] == '?' + || IObuff[len-2] == '!')))) + IObuff[len++] = ' '; + } + /* copy as much as posible of the new word */ + if (tmp_ptr - ptr >= IOSIZE - len) + tmp_ptr = ptr + IOSIZE - len - 1; + STRNCPY(IObuff + len, ptr, tmp_ptr - ptr); + len += (int)(tmp_ptr - ptr); + reuse |= CONT_S_IPOS; + } + IObuff[len] = NUL; + ptr = IObuff; + } + if (len == completion_length) + continue; + } + } + if (ins_compl_add_infercase(ptr, len, + ins_buf == curbuf ? NULL : ins_buf->b_sfname, + dir, reuse) != FAIL) + { + found_new_match = OK; + break; + } + } + p_scs = save_p_scs; + p_ws = save_p_ws; + } + /* check if curr_match has changed, (e.g. other type of expansion + * added somenthing) */ + if (curr_match != old_match) + found_new_match = OK; + + /* break the loop for specialized modes (use 'complete' just for the + * generic ctrl_x_mode == 0) or when we've found a new match */ + if ((ctrl_x_mode != 0 && ctrl_x_mode != CTRL_X_WHOLE_LINE) + || found_new_match != FAIL) + break; + + /* Mark a buffer scanned when it has been scanned completely */ + if (type == 0 || type == CTRL_X_PATH_PATTERNS) + ins_buf->b_scanned = TRUE; + + started_completion = FALSE; + } + started_completion = TRUE; + + if ((ctrl_x_mode == 0 || ctrl_x_mode == CTRL_X_WHOLE_LINE) + && *e_cpt == NUL) /* Got to end of 'complete' */ + found_new_match = FAIL; + + i = -1; /* total of matches, unknown */ + if (found_new_match == FAIL + || (ctrl_x_mode != 0 && ctrl_x_mode != CTRL_X_WHOLE_LINE)) + i = ins_compl_make_cyclic(); + + /* If several matches were added (FORWARD) or the search failed and has + * just been made cyclic then we have to move curr_match to the next or + * previous entry (if any) -- Acevedo */ + curr_match = dir == FORWARD ? old_match->next : old_match->prev; + if (curr_match == NULL) + curr_match = old_match; + return i; +} + +/* Delete the old text being completed. */ + static void +ins_compl_delete() +{ + int i; + + /* + * In insert mode: Delete the typed part. + * In replace mode: Put the old characters back, if any. + */ + i = complete_col + (continue_status & CONT_ADDING ? completion_length : 0); + backspace_until_column(i); + changed_cline_bef_curs(); +} + +/* Insert the new text being completed. */ + static void +ins_compl_insert() +{ + ins_bytes(shown_match->str + curwin->w_cursor.col - complete_col); +} + +/* + * Fill in the next completion in the current direction. + * If allow_get_expansion is TRUE, then we may call ins_compl_get_exp() to get + * more completions. If it is FALSE, then we just do nothing when there are + * no more completions in a given direction. The latter case is used when we + * are still in the middle of finding completions, to allow browsing through + * the ones found so far. + * Return the total number of matches, or -1 if still unknown -- webb. + * + * curr_match is currently being used by ins_compl_get_exp(), so we use + * shown_match here. + * + * Note that this function may be called recursively once only. First with + * allow_get_expansion TRUE, which calls ins_compl_get_exp(), which in turn + * calls this function with allow_get_expansion FALSE. + */ + static int +ins_compl_next(allow_get_expansion) + int allow_get_expansion; +{ + int num_matches = -1; + int i; + + if (allow_get_expansion) + { + /* Delete old text to be replaced */ + ins_compl_delete(); + } + completion_pending = FALSE; + if (shown_direction == FORWARD && shown_match->next != NULL) + shown_match = shown_match->next; + else if (shown_direction == BACKWARD && shown_match->prev != NULL) + shown_match = shown_match->prev; + else + { + completion_pending = TRUE; + if (allow_get_expansion) + { + num_matches = ins_compl_get_exp(&initial_pos, complete_direction); + if (completion_pending) + { + if (complete_direction == shown_direction) + shown_match = curr_match; + } + } + else + return -1; + } + + /* Insert the text of the new completion */ + ins_compl_insert(); + + if (!allow_get_expansion) + { + /* Display the current match. */ + update_screen(0); + + /* Delete old text to be replaced, since we're still searching and + * don't want to match ourselves! */ + ins_compl_delete(); + } + + /* + * Show the file name for the match (if any) + * Truncate the file name to avoid a wait for return. + */ + if (shown_match->fname != NULL) + { + STRCPY(IObuff, "match in file "); + i = (vim_strsize(shown_match->fname) + 16) - sc_col; + if (i <= 0) + i = 0; + else + STRCAT(IObuff, "<"); + STRCAT(IObuff, shown_match->fname + i); + msg(IObuff); + redraw_cmdline = FALSE; /* don't overwrite! */ + } + + return num_matches; +} + +/* + * Call this while finding completions, to check whether the user has hit a key + * that should change the currently displayed completion, or exit completion + * mode. Also, when completion_pending is TRUE, show a completion as soon as + * possible. -- webb + */ + void +ins_compl_check_keys() +{ + static int count = 0; + + int c; + + /* Don't check when reading keys from a script. That would break the test + * scripts */ + if (using_script()) + return; + + /* Only do this at regular intervals */ + if (++count < CHECK_KEYS_TIME) + return; + count = 0; + + ++no_mapping; + c = vpeekc_any(); + --no_mapping; + if (c != NUL) + { + if (vim_is_ctrl_x_key(c) && c != Ctrl_X && c != Ctrl_R) + { + c = safe_vgetc(); /* Eat the character */ + if (c == Ctrl_P || c == Ctrl_L) + shown_direction = BACKWARD; + else + shown_direction = FORWARD; + (void)ins_compl_next(FALSE); + } + else if (c != Ctrl_R) + completion_interrupted = TRUE; + } + if (completion_pending && !got_int) + (void)ins_compl_next(FALSE); +} + +/* + * Do Insert mode completion. + * Called when character "c" was typed, which has a meaning for completion. + * Returns OK if completion was done, FAIL if something failed (out of mem). + */ + static int +ins_complete(c) + int c; +{ + char_u *line; + char_u *tmp_ptr = NULL; /* init for gcc */ + int temp = 0; + + if (c == Ctrl_P || c == Ctrl_L) + complete_direction = BACKWARD; + else + complete_direction = FORWARD; + if (!started_completion) + { + /* First time we hit ^N or ^P (in a row, I mean) */ + + /* Turn off 'sm' so we don't show matches with ^X^L */ + save_sm = p_sm; + p_sm = FALSE; + + did_ai = FALSE; +#ifdef FEAT_SMARTINDENT + did_si = FALSE; + can_si = FALSE; + can_si_back = FALSE; +#endif + if (stop_arrow() == FAIL) + return FAIL; + + line = ml_get(curwin->w_cursor.lnum); + complete_col = curwin->w_cursor.col; + + /* if this same ctrl_x_mode has been interrupted use the text from + * "initial_pos" to the cursor as a pattern to add a new word instead + * of expand the one before the cursor, in word-wise if "initial_pos" + * is not in the same line as the cursor then fix it (the line has + * been split because it was longer than 'tw'). if SOL is set then + * skip the previous pattern, a word at the beginning of the line has + * been inserted, we'll look for that -- Acevedo. */ + if ((continue_status & CONT_INTRPT) && continue_mode == ctrl_x_mode) + { + /* + * it is a continued search + */ + continue_status &= ~CONT_INTRPT; /* remove INTRPT */ + if (ctrl_x_mode == 0 || ctrl_x_mode == CTRL_X_PATH_PATTERNS + || ctrl_x_mode == CTRL_X_PATH_DEFINES) + { + if (initial_pos.lnum != curwin->w_cursor.lnum) + { + /* line (probably) wrapped, set initial_pos to the first + * non_blank in the line, if it is not a wordchar include + * it to get a better pattern, but then we don't want the + * "\\<" prefix, check it bellow */ + tmp_ptr = skipwhite(line); + initial_pos.col = (colnr_T) (tmp_ptr - line); + initial_pos.lnum = curwin->w_cursor.lnum; + continue_status &= ~CONT_SOL; /* clear SOL if present */ + } + else + { + /* S_IPOS was set when we inserted a word that was at the + * beginning of the line, which means that we'll go to SOL + * mode but first we need to redefine initial_pos */ + if (continue_status & CONT_S_IPOS) + { + continue_status |= CONT_SOL; + initial_pos.col = (colnr_T) (skipwhite(line + completion_length + + initial_pos.col) - line); + } + tmp_ptr = line + initial_pos.col; + } + temp = curwin->w_cursor.col - (int)(tmp_ptr - line); + /* IObuf is used to add a "word from the next line" would we + * have enough space? just being paranoic */ +#define MIN_SPACE 75 + if (temp > (IOSIZE - MIN_SPACE)) + { + continue_status &= ~CONT_SOL; + temp = (IOSIZE - MIN_SPACE); + tmp_ptr = line + curwin->w_cursor.col - temp; + } + continue_status |= CONT_ADDING | CONT_N_ADDS; + if (temp < 1) + continue_status &= CONT_LOCAL; + } + else if (ctrl_x_mode == CTRL_X_WHOLE_LINE) + continue_status = CONT_ADDING | CONT_N_ADDS; + else + continue_status = 0; + } + else + continue_status &= CONT_LOCAL; + + if (!(continue_status & CONT_ADDING)) /* normal expansion */ + { + continue_mode = ctrl_x_mode; + if (ctrl_x_mode != 0) /* Remove LOCAL if ctrl_x_mode != 0 */ + continue_status = 0; + continue_status |= CONT_N_ADDS; + initial_pos = curwin->w_cursor; + temp = (int)complete_col; + tmp_ptr = line; + } + + /* Work out completion pattern and original text -- webb */ + if (ctrl_x_mode == 0 || (ctrl_x_mode & CTRL_X_WANT_IDENT)) + { + if ( (continue_status & CONT_SOL) + || ctrl_x_mode == CTRL_X_PATH_DEFINES) + { + if (!(continue_status & CONT_ADDING)) + { + while (--temp >= 0 && vim_isIDc(line[temp])) + ; + tmp_ptr += ++temp; + temp = complete_col - temp; + } + if (p_ic) + complete_pat = str_foldcase(tmp_ptr, temp); + else + complete_pat = vim_strnsave(tmp_ptr, temp); + if (complete_pat == NULL) + return FAIL; + } + else if (continue_status & CONT_ADDING) + { + char_u *prefix = (char_u *)"\\<"; + + /* we need 3 extra chars, 1 for the NUL and + * 2 >= strlen(prefix) -- Acevedo */ + complete_pat = alloc(quote_meta(NULL, tmp_ptr, temp) + 3); + if (complete_pat == NULL) + return FAIL; + if (!vim_iswordp(tmp_ptr) + || (tmp_ptr > line + && ( +#ifdef FEAT_MBYTE + vim_iswordp(mb_prevptr(line, tmp_ptr)) +#else + vim_iswordc(*(tmp_ptr - 1)) +#endif + ))) + prefix = (char_u *)""; + STRCPY((char *)complete_pat, prefix); + (void)quote_meta(complete_pat + STRLEN(prefix), tmp_ptr, temp); + } + else if ( +#ifdef FEAT_MBYTE + --temp < 0 || !vim_iswordp(mb_prevptr(line, + line + temp + 1)) +#else + --temp < 0 || !vim_iswordc(line[temp]) +#endif + ) + { + /* Match any word of at least two chars */ + complete_pat = vim_strsave((char_u *)"\\<\\k\\k"); + if (complete_pat == NULL) + return FAIL; + tmp_ptr += complete_col; + temp = 0; + } + else + { +#ifdef FEAT_MBYTE + /* Search the point of change class of multibyte character + * or not a word single byte character backward. */ + if (has_mbyte) + { + int base_class; + int head_off; + + temp -= (*mb_head_off)(line, line + temp); + base_class = mb_get_class(line + temp); + while (--temp >= 0) + { + head_off = (*mb_head_off)(line, line + temp); + if (base_class != mb_get_class(line + temp - head_off)) + break; + temp -= head_off; + } + } + else +#endif + while (--temp >= 0 && vim_iswordc(line[temp])) + ; + tmp_ptr += ++temp; + if ((temp = (int)complete_col - temp) == 1) + { + /* Only match word with at least two chars -- webb + * there's no need to call quote_meta, + * alloc(7) is enough -- Acevedo + */ + complete_pat = alloc(7); + if (complete_pat == NULL) + return FAIL; + STRCPY((char *)complete_pat, "\\<"); + (void)quote_meta(complete_pat + 2, tmp_ptr, 1); + STRCAT((char *)complete_pat, "\\k"); + } + else + { + complete_pat = alloc(quote_meta(NULL, tmp_ptr, temp) + 3); + if (complete_pat == NULL) + return FAIL; + STRCPY((char *)complete_pat, "\\<"); + (void)quote_meta(complete_pat + 2, tmp_ptr, temp); + } + } + } + else if (ctrl_x_mode == CTRL_X_WHOLE_LINE) + { + tmp_ptr = skipwhite(line); + temp = (int)complete_col - (int)(tmp_ptr - line); + if (temp < 0) /* cursor in indent: empty pattern */ + temp = 0; + if (p_ic) + complete_pat = str_foldcase(tmp_ptr, temp); + else + complete_pat = vim_strnsave(tmp_ptr, temp); + if (complete_pat == NULL) + return FAIL; + } + else if (ctrl_x_mode == CTRL_X_FILES) + { + while (--temp >= 0 && vim_isfilec(line[temp])) + ; + tmp_ptr += ++temp; + temp = (int)complete_col - temp; + complete_pat = addstar(tmp_ptr, temp, EXPAND_FILES); + if (complete_pat == NULL) + return FAIL; + } + else if (ctrl_x_mode == CTRL_X_CMDLINE) + { + complete_pat = vim_strnsave(line, complete_col); + if (complete_pat == NULL) + return FAIL; + set_cmd_context(&complete_xp, complete_pat, + (int)STRLEN(complete_pat), complete_col); + if (complete_xp.xp_context == EXPAND_UNSUCCESSFUL + || complete_xp.xp_context == EXPAND_NOTHING) + return FAIL; + temp = (int)(complete_xp.xp_pattern - complete_pat); + tmp_ptr = line + temp; + temp = complete_col - temp; + } + complete_col = (colnr_T) (tmp_ptr - line); + + if (continue_status & CONT_ADDING) + { + edit_submode_pre = (char_u *)_(" Adding"); + if (ctrl_x_mode == CTRL_X_WHOLE_LINE) + { + /* Insert a new line, keep indentation but ignore 'comments' */ +#ifdef FEAT_COMMENTS + char_u *old = curbuf->b_p_com; + + curbuf->b_p_com = (char_u *)""; +#endif + initial_pos.lnum = curwin->w_cursor.lnum; + initial_pos.col = complete_col; + ins_eol('\r'); +#ifdef FEAT_COMMENTS + curbuf->b_p_com = old; +#endif + tmp_ptr = (char_u *)""; + temp = 0; + complete_col = curwin->w_cursor.col; + } + } + else + { + edit_submode_pre = NULL; + initial_pos.col = complete_col; + } + + if (continue_status & CONT_LOCAL) + edit_submode = (char_u *)_(ctrl_x_msgs[2]); + else + edit_submode = (char_u *)_(CTRL_X_MSG(ctrl_x_mode)); + + completion_length = temp; + + /* Always add completion for the original text. Note that + * "original_text" itself (not a copy) is added, it will be freed when + * the list of matches is freed. */ + if ((original_text = vim_strnsave(tmp_ptr, temp)) == NULL + || ins_compl_add(original_text, -1, NULL, 0, ORIGINAL_TEXT) != OK) + { + vim_free(complete_pat); + complete_pat = NULL; + vim_free(original_text); + return FAIL; + } + + /* showmode might reset the internal line pointers, so it must + * be called before line = ml_get(), or when this address is no + * longer needed. -- Acevedo. + */ + edit_submode_extra = (char_u *)_("-- Searching..."); + edit_submode_highl = HLF_COUNT; + showmode(); + edit_submode_extra = NULL; + out_flush(); + } + + shown_match = curr_match; + shown_direction = complete_direction; + + /* + * Find next match. + */ + temp = ins_compl_next(TRUE); + + if (temp > 1) /* all matches have been found */ + completion_matches = temp; + curr_match = shown_match; + complete_direction = shown_direction; + completion_interrupted = FALSE; + + /* eat the ESC to avoid leaving insert mode */ + if (got_int && !global_busy) + { + (void)vgetc(); + got_int = FALSE; + } + + /* we found no match if the list has only the original_text-entry */ + if (first_match == first_match->next) + { + edit_submode_extra = (continue_status & CONT_ADDING) + && completion_length > 1 + ? (char_u *)_(e_hitend) : (char_u *)_(e_patnotf); + edit_submode_highl = HLF_E; + /* remove N_ADDS flag, so next ^X<> won't try to go to ADDING mode, + * because we couldn't expand anything at first place, but if we used + * ^P, ^N, ^X^I or ^X^D we might want to add-expand a single-char-word + * (such as M in M'exico) if not tried already. -- Acevedo */ + if ( completion_length > 1 + || (continue_status & CONT_ADDING) + || (ctrl_x_mode != 0 + && ctrl_x_mode != CTRL_X_PATH_PATTERNS + && ctrl_x_mode != CTRL_X_PATH_DEFINES)) + continue_status &= ~CONT_N_ADDS; + } + + if (curr_match->original & CONT_S_IPOS) + continue_status |= CONT_S_IPOS; + else + continue_status &= ~CONT_S_IPOS; + + if (edit_submode_extra == NULL) + { + if (curr_match->original & ORIGINAL_TEXT) + { + edit_submode_extra = (char_u *)_("Back at original"); + edit_submode_highl = HLF_W; + } + else if (continue_status & CONT_S_IPOS) + { + edit_submode_extra = (char_u *)_("Word from other line"); + edit_submode_highl = HLF_COUNT; + } + else if (curr_match->next == curr_match->prev) + { + edit_submode_extra = (char_u *)_("The only match"); + edit_submode_highl = HLF_COUNT; + } + else + { + /* Update completion sequence number when needed. */ + if (curr_match->number == -1) + { + int number = 0; + struct Completion *match; + + if (complete_direction == FORWARD) + { + /* search backwards for the first valid (!= -1) number. + * This should normally succeed already at the first loop + * cycle, so it's fast! */ + for (match = curr_match->prev; match != NULL + && match != first_match; match = match->prev) + if (match->number != -1) + { + number = match->number; + break; + } + if (match != NULL) + /* go up and assign all numbers which are not assigned + * yet */ + for (match = match->next; match + && match->number == -1; match = match->next) + match->number = ++number; + } + else /* BACKWARD */ + { + /* search forwards (upwards) for the first valid (!= -1) + * number. This should normally succeed already at the + * first loop cycle, so it's fast! */ + for (match = curr_match->next; match != NULL + && match != first_match; match = match->next) + if (match->number != -1) + { + number = match->number; + break; + } + if (match != NULL) + /* go down and assign all numbers which are not + * assigned yet */ + for (match = match->prev; match + && match->number == -1; match = match->prev) + match->number = ++number; + } + } + + /* The match should always have a sequnce number now, this is just + * a safety check. */ + if (curr_match->number != -1) + { + /* Space for 10 text chars. + 2x10-digit no.s */ + static char_u match_ref[31]; + + if (completion_matches > 0) + sprintf((char *)IObuff, _("match %d of %d"), + curr_match->number, completion_matches); + else + sprintf((char *)IObuff, _("match %d"), curr_match->number); + STRNCPY(match_ref, IObuff, 30 ); + match_ref[30] = '\0'; + edit_submode_extra = match_ref; + edit_submode_highl = HLF_R; + if (dollar_vcol) + curs_columns(FALSE); + } + } + } + + /* Show a message about what (completion) mode we're in. */ + showmode(); + if (edit_submode_extra != NULL) + { + if (!p_smd) + msg_attr(edit_submode_extra, + edit_submode_highl < HLF_COUNT + ? hl_attr(edit_submode_highl) : 0); + } + else + msg_clr_cmdline(); /* necessary for "noshowmode" */ + + return OK; +} + +/* + * Looks in the first "len" chars. of "src" for search-metachars. + * If dest is not NULL the chars. are copied there quoting (with + * a backslash) the metachars, and dest would be NUL terminated. + * Returns the length (needed) of dest + */ + static int +quote_meta(dest, src, len) + char_u *dest; + char_u *src; + int len; +{ + int m; + + for (m = len; --len >= 0; src++) + { + switch (*src) + { + case '.': + case '*': + case '[': + if (ctrl_x_mode == CTRL_X_DICTIONARY + || ctrl_x_mode == CTRL_X_THESAURUS) + break; + case '~': + if (!p_magic) /* quote these only if magic is set */ + break; + case '\\': + if (ctrl_x_mode == CTRL_X_DICTIONARY + || ctrl_x_mode == CTRL_X_THESAURUS) + break; + case '^': /* currently it's not needed. */ + case '$': + m++; + if (dest != NULL) + *dest++ = '\\'; + break; + } + if (dest != NULL) + *dest++ = *src; +#ifdef FEAT_MBYTE + /* Copy remaining bytes of a multibyte character. */ + if (has_mbyte) + { + int i, mb_len; + + mb_len = (*mb_ptr2len_check)(src) - 1; + if (mb_len > 0 && len >= mb_len) + for (i = 0; i < mb_len; ++i) + { + --len; + ++src; + if (dest != NULL) + *dest++ = *src; + } + } +#endif + } + if (dest != NULL) + *dest = NUL; + + return m; +} +#endif /* FEAT_INS_EXPAND */ + +/* + * Next character is interpreted literally. + * A one, two or three digit decimal number is interpreted as its byte value. + * If one or two digits are entered, the next character is given to vungetc(). + * For Unicode a character > 255 may be returned. + */ + int +get_literal() +{ + int cc; + int nc; + int i; + int hex = FALSE; + int octal = FALSE; +#ifdef FEAT_MBYTE + int unicode = 0; +#endif + + if (got_int) + return Ctrl_C; + +#ifdef FEAT_GUI + /* + * In GUI there is no point inserting the internal code for a special key. + * It is more useful to insert the string "<KEY>" instead. This would + * probably be useful in a text window too, but it would not be + * vi-compatible (maybe there should be an option for it?) -- webb + */ + if (gui.in_use) + ++allow_keys; +#endif +#ifdef USE_ON_FLY_SCROLL + dont_scroll = TRUE; /* disallow scrolling here */ +#endif + ++no_mapping; /* don't map the next key hits */ + cc = 0; + i = 0; + for (;;) + { + do + nc = safe_vgetc(); + while (nc == K_IGNORE || nc == K_VER_SCROLLBAR + || nc == K_HOR_SCROLLBAR); +#ifdef FEAT_CMDL_INFO + if (!(State & CMDLINE) +# ifdef FEAT_MBYTE + && MB_BYTE2LEN_CHECK(nc) == 1 +# endif + ) + add_to_showcmd(nc); +#endif + if (nc == 'x' || nc == 'X') + hex = TRUE; + else if (nc == 'o' || nc == 'O') + octal = TRUE; +#ifdef FEAT_MBYTE + else if (nc == 'u' || nc == 'U') + unicode = nc; +#endif + else + { + if (hex +#ifdef FEAT_MBYTE + || unicode != 0 +#endif + ) + { + if (!vim_isxdigit(nc)) + break; + cc = cc * 16 + hex2nr(nc); + } + else if (octal) + { + if (nc < '0' || nc > '7') + break; + cc = cc * 8 + nc - '0'; + } + else + { + if (!VIM_ISDIGIT(nc)) + break; + cc = cc * 10 + nc - '0'; + } + + ++i; + } + + if (cc > 255 +#ifdef FEAT_MBYTE + && unicode == 0 +#endif + ) + cc = 255; /* limit range to 0-255 */ + nc = 0; + + if (hex) /* hex: up to two chars */ + { + if (i >= 2) + break; + } +#ifdef FEAT_MBYTE + else if (unicode) /* Unicode: up to four or eight chars */ + { + if ((unicode == 'u' && i >= 4) || (unicode == 'U' && i >= 8)) + break; + } +#endif + else if (i >= 3) /* decimal or octal: up to three chars */ + break; + } + if (i == 0) /* no number entered */ + { + if (nc == K_ZERO) /* NUL is stored as NL */ + { + cc = '\n'; + nc = 0; + } + else + { + cc = nc; + nc = 0; + } + } + + if (cc == 0) /* NUL is stored as NL */ + cc = '\n'; + + --no_mapping; +#ifdef FEAT_GUI + if (gui.in_use) + --allow_keys; +#endif + if (nc) + vungetc(nc); + got_int = FALSE; /* CTRL-C typed after CTRL-V is not an interrupt */ + return cc; +} + +/* + * Insert character, taking care of special keys and mod_mask + */ + static void +insert_special(c, allow_modmask, ctrlv) + int c; + int allow_modmask; + int ctrlv; /* c was typed after CTRL-V */ +{ + char_u *p; + int len; + + /* + * Special function key, translate into "<Key>". Up to the last '>' is + * inserted with ins_str(), so as not to replace characters in replace + * mode. + * Only use mod_mask for special keys, to avoid things like <S-Space>, + * unless 'allow_modmask' is TRUE. + */ +#ifdef MACOS + /* Command-key never produces a normal key */ + if (mod_mask & MOD_MASK_CMD) + allow_modmask = TRUE; +#endif + if (IS_SPECIAL(c) || (mod_mask && allow_modmask)) + { + p = get_special_key_name(c, mod_mask); + len = (int)STRLEN(p); + c = p[len - 1]; + if (len > 2) + { + if (stop_arrow() == FAIL) + return; + p[len - 1] = NUL; + ins_str(p); + AppendToRedobuffLit(p); + ctrlv = FALSE; + } + } + if (stop_arrow() == OK) + insertchar(c, ctrlv ? INSCHAR_CTRLV : 0, -1); +} + +/* + * Special characters in this context are those that need processing other + * than the simple insertion that can be performed here. This includes ESC + * which terminates the insert, and CR/NL which need special processing to + * open up a new line. This routine tries to optimize insertions performed by + * the "redo", "undo" or "put" commands, so it needs to know when it should + * stop and defer processing to the "normal" mechanism. + * '0' and '^' are special, because they can be followed by CTRL-D. + */ +#ifdef EBCDIC +# define ISSPECIAL(c) ((c) < ' ' || (c) == '0' || (c) == '^') +#else +# define ISSPECIAL(c) ((c) < ' ' || (c) >= DEL || (c) == '0' || (c) == '^') +#endif + +#ifdef FEAT_MBYTE +# define WHITECHAR(cc) (vim_iswhite(cc) && (!enc_utf8 || !utf_iscomposing(utf_ptr2char(ml_get_cursor() + 1)))) +#else +# define WHITECHAR(cc) vim_iswhite(cc) +#endif + + void +insertchar(c, flags, second_indent) + int c; /* character to insert or NUL */ + int flags; /* INSCHAR_FORMAT, etc. */ + int second_indent; /* indent for second line if >= 0 */ +{ + int haveto_redraw = FALSE; + int textwidth; +#ifdef FEAT_COMMENTS + colnr_T leader_len; + char_u *p; + int no_leader = FALSE; + int do_comments = (flags & INSCHAR_DO_COM); +#endif + int fo_white_par; + int first_line = TRUE; + int fo_ins_blank; +#ifdef FEAT_MBYTE + int fo_multibyte; +#endif + int save_char = NUL; + int cc; + + textwidth = comp_textwidth(flags & INSCHAR_FORMAT); + fo_ins_blank = has_format_option(FO_INS_BLANK); +#ifdef FEAT_MBYTE + fo_multibyte = has_format_option(FO_MBYTE_BREAK); +#endif + fo_white_par = has_format_option(FO_WHITE_PAR); + + /* + * Try to break the line in two or more pieces when: + * - Always do this if we have been called to do formatting only. + * - Always do this when 'formatoptions' has the 'a' flag and the line + * ends in white space. + * - Otherwise: + * - Don't do this if inserting a blank + * - Don't do this if an existing character is being replaced, unless + * we're in VREPLACE mode. + * - Do this if the cursor is not on the line where insert started + * or - 'formatoptions' doesn't have 'l' or the line was not too long + * before the insert. + * - 'formatoptions' doesn't have 'b' or a blank was inserted at or + * before 'textwidth' + */ + if (textwidth + && ((flags & INSCHAR_FORMAT) + || (!vim_iswhite(c) + && !((State & REPLACE_FLAG) +#ifdef FEAT_VREPLACE + && !(State & VREPLACE_FLAG) +#endif + && *ml_get_cursor() != NUL) + && (curwin->w_cursor.lnum != Insstart.lnum + || ((!has_format_option(FO_INS_LONG) + || Insstart_textlen <= (colnr_T)textwidth) + && (!fo_ins_blank + || Insstart_blank_vcol <= (colnr_T)textwidth + )))))) + { + /* + * When 'ai' is off we don't want a space under the cursor to be + * deleted. Replace it with an 'x' temporarily. + */ + if (!curbuf->b_p_ai) + { + cc = gchar_cursor(); + if (vim_iswhite(cc)) + { + save_char = cc; + pchar_cursor('x'); + } + } + + /* + * Repeat breaking lines, until the current line is not too long. + */ + while (!got_int) + { + int startcol; /* Cursor column at entry */ + int wantcol; /* column at textwidth border */ + int foundcol; /* column for start of spaces */ + int end_foundcol = 0; /* column for start of word */ + colnr_T len; + colnr_T virtcol; +#ifdef FEAT_VREPLACE + int orig_col = 0; + char_u *saved_text = NULL; +#endif + colnr_T col; + + virtcol = get_nolist_virtcol(); + if (virtcol < (colnr_T)textwidth) + break; + +#ifdef FEAT_COMMENTS + if (no_leader) + do_comments = FALSE; + else if (!(flags & INSCHAR_FORMAT) + && has_format_option(FO_WRAP_COMS)) + do_comments = TRUE; + + /* Don't break until after the comment leader */ + if (do_comments) + leader_len = get_leader_len(ml_get_curline(), NULL, FALSE); + else + leader_len = 0; + + /* If the line doesn't start with a comment leader, then don't + * start one in a following broken line. Avoids that a %word + * moved to the start of the next line causes all following lines + * to start with %. */ + if (leader_len == 0) + no_leader = TRUE; +#endif + if (!(flags & INSCHAR_FORMAT) +#ifdef FEAT_COMMENTS + && leader_len == 0 +#endif + && !has_format_option(FO_WRAP)) + + { + textwidth = 0; + break; + } + if ((startcol = curwin->w_cursor.col) == 0) + break; + + /* find column of textwidth border */ + coladvance((colnr_T)textwidth); + wantcol = curwin->w_cursor.col; + + curwin->w_cursor.col = startcol - 1; +#ifdef FEAT_MBYTE + /* Correct cursor for multi-byte character. */ + if (has_mbyte) + mb_adjust_cursor(); +#endif + foundcol = 0; + + /* + * Find position to break at. + * Stop at first entered white when 'formatoptions' has 'v' + */ + while ((!fo_ins_blank && !has_format_option(FO_INS_VI)) + || curwin->w_cursor.lnum != Insstart.lnum + || curwin->w_cursor.col >= Insstart.col) + { + cc = gchar_cursor(); + if (WHITECHAR(cc)) + { + /* remember position of blank just before text */ + end_foundcol = curwin->w_cursor.col; + + /* find start of sequence of blanks */ + while (curwin->w_cursor.col > 0 && WHITECHAR(cc)) + { + dec_cursor(); + cc = gchar_cursor(); + } + if (curwin->w_cursor.col == 0 && WHITECHAR(cc)) + break; /* only spaces in front of text */ +#ifdef FEAT_COMMENTS + /* Don't break until after the comment leader */ + if (curwin->w_cursor.col < leader_len) + break; +#endif + if (has_format_option(FO_ONE_LETTER)) + { + /* do not break after one-letter words */ + if (curwin->w_cursor.col == 0) + break; /* one-letter word at begin */ + + col = curwin->w_cursor.col; + dec_cursor(); + cc = gchar_cursor(); + + if (WHITECHAR(cc)) + continue; /* one-letter, continue */ + curwin->w_cursor.col = col; + } +#ifdef FEAT_MBYTE + if (has_mbyte) + foundcol = curwin->w_cursor.col + + (*mb_ptr2len_check)(ml_get_cursor()); + else +#endif + foundcol = curwin->w_cursor.col + 1; + if (curwin->w_cursor.col < (colnr_T)wantcol) + break; + } +#ifdef FEAT_MBYTE + else if (cc >= 0x100 && fo_multibyte + && curwin->w_cursor.col <= (colnr_T)wantcol) + { + /* Break after or before a multi-byte character. */ + foundcol = curwin->w_cursor.col; + if (curwin->w_cursor.col < (colnr_T)wantcol) + foundcol += (*mb_char2len)(cc); + end_foundcol = foundcol; + break; + } +#endif + if (curwin->w_cursor.col == 0) + break; + dec_cursor(); + } + + if (foundcol == 0) /* no spaces, cannot break line */ + { + curwin->w_cursor.col = startcol; + break; + } + + /* Going to break the line, remove any "$" now. */ + undisplay_dollar(); + + /* + * Offset between cursor position and line break is used by replace + * stack functions. VREPLACE does not use this, and backspaces + * over the text instead. + */ +#ifdef FEAT_VREPLACE + if (State & VREPLACE_FLAG) + orig_col = startcol; /* Will start backspacing from here */ + else +#endif + replace_offset = startcol - end_foundcol - 1; + + /* + * adjust startcol for spaces that will be deleted and + * characters that will remain on top line + */ + curwin->w_cursor.col = foundcol; + while (cc = gchar_cursor(), WHITECHAR(cc)) + inc_cursor(); + startcol -= curwin->w_cursor.col; + if (startcol < 0) + startcol = 0; + +#ifdef FEAT_VREPLACE + if (State & VREPLACE_FLAG) + { + /* + * In VREPLACE mode, we will backspace over the text to be + * wrapped, so save a copy now to put on the next line. + */ + saved_text = vim_strsave(ml_get_cursor()); + curwin->w_cursor.col = orig_col; + if (saved_text == NULL) + break; /* Can't do it, out of memory */ + saved_text[startcol] = NUL; + + /* Backspace over characters that will move to the next line */ + if (!fo_white_par) + backspace_until_column(foundcol); + } + else +#endif + { + /* put cursor after pos. to break line */ + if (!fo_white_par) + curwin->w_cursor.col = foundcol; + } + + /* + * Split the line just before the margin. + * Only insert/delete lines, but don't really redraw the window. + */ + open_line(FORWARD, OPENLINE_DELSPACES + OPENLINE_MARKFIX + + (fo_white_par ? OPENLINE_KEEPTRAIL : 0) +#ifdef FEAT_COMMENTS + + (do_comments ? OPENLINE_DO_COM : 0) +#endif + , old_indent); + old_indent = 0; + + replace_offset = 0; + if (first_line) + { + if (second_indent < 0 && has_format_option(FO_Q_NUMBER)) + second_indent = get_number_indent(curwin->w_cursor.lnum -1); + if (second_indent >= 0) + { +#ifdef FEAT_VREPLACE + if (State & VREPLACE_FLAG) + change_indent(INDENT_SET, second_indent, FALSE, NUL); + else +#endif + (void)set_indent(second_indent, SIN_CHANGED); + } + first_line = FALSE; + } + +#ifdef FEAT_VREPLACE + if (State & VREPLACE_FLAG) + { + /* + * In VREPLACE mode we have backspaced over the text to be + * moved, now we re-insert it into the new line. + */ + ins_bytes(saved_text); + vim_free(saved_text); + } + else +#endif + { + /* + * Check if cursor is not past the NUL off the line, cindent + * may have added or removed indent. + */ + curwin->w_cursor.col += startcol; + len = (colnr_T)STRLEN(ml_get_curline()); + if (curwin->w_cursor.col > len) + curwin->w_cursor.col = len; + } + + haveto_redraw = TRUE; +#ifdef FEAT_CINDENT + can_cindent = TRUE; +#endif + /* moved the cursor, don't autoindent or cindent now */ + did_ai = FALSE; +#ifdef FEAT_SMARTINDENT + did_si = FALSE; + can_si = FALSE; + can_si_back = FALSE; +#endif + line_breakcheck(); + } + + if (save_char) /* put back space after cursor */ + pchar_cursor(save_char); + + if (c == NUL) /* formatting only */ + return; + if (haveto_redraw) + { + update_topline(); + redraw_curbuf_later(VALID); + } + } + if (c == NUL) /* only formatting was wanted */ + return; + +#ifdef FEAT_COMMENTS + /* Check whether this character should end a comment. */ + if (did_ai && (int)c == end_comment_pending) + { + char_u *line; + char_u lead_end[COM_MAX_LEN]; /* end-comment string */ + int middle_len, end_len; + int i; + + /* + * Need to remove existing (middle) comment leader and insert end + * comment leader. First, check what comment leader we can find. + */ + i = get_leader_len(line = ml_get_curline(), &p, FALSE); + if (i > 0 && vim_strchr(p, COM_MIDDLE) != NULL) /* Just checking */ + { + /* Skip middle-comment string */ + while (*p && p[-1] != ':') /* find end of middle flags */ + ++p; + middle_len = copy_option_part(&p, lead_end, COM_MAX_LEN, ","); + /* Don't count trailing white space for middle_len */ + while (middle_len > 0 && vim_iswhite(lead_end[middle_len - 1])) + --middle_len; + + /* Find the end-comment string */ + while (*p && p[-1] != ':') /* find end of end flags */ + ++p; + end_len = copy_option_part(&p, lead_end, COM_MAX_LEN, ","); + + /* Skip white space before the cursor */ + i = curwin->w_cursor.col; + while (--i >= 0 && vim_iswhite(line[i])) + ; + i++; + + /* Skip to before the middle leader */ + i -= middle_len; + + /* Check some expected things before we go on */ + if (i >= 0 && lead_end[end_len - 1] == end_comment_pending) + { + /* Backspace over all the stuff we want to replace */ + backspace_until_column(i); + + /* + * Insert the end-comment string, except for the last + * character, which will get inserted as normal later. + */ + ins_bytes_len(lead_end, end_len - 1); + } + } + } + end_comment_pending = NUL; +#endif + + did_ai = FALSE; +#ifdef FEAT_SMARTINDENT + did_si = FALSE; + can_si = FALSE; + can_si_back = FALSE; +#endif + + /* + * If there's any pending input, grab up to INPUT_BUFLEN at once. + * This speeds up normal text input considerably. + * Don't do this when 'cindent' or 'indentexpr' is set, because we might + * need to re-indent at a ':', or any other character (but not what + * 'paste' is set).. + */ +#ifdef USE_ON_FLY_SCROLL + dont_scroll = FALSE; /* allow scrolling here */ +#endif + + if ( !ISSPECIAL(c) +#ifdef FEAT_MBYTE + && (!has_mbyte || (*mb_char2len)(c) == 1) +#endif + && vpeekc() != NUL + && !(State & REPLACE_FLAG) +#ifdef FEAT_CINDENT + && !cindent_on() +#endif +#ifdef FEAT_RIGHTLEFT + && !p_ri +#endif + ) + { +#define INPUT_BUFLEN 100 + char_u buf[INPUT_BUFLEN + 1]; + int i; + colnr_T virtcol = 0; + + buf[0] = c; + i = 1; + if (textwidth) + virtcol = get_nolist_virtcol(); + /* + * Stop the string when: + * - no more chars available + * - finding a special character (command key) + * - buffer is full + * - running into the 'textwidth' boundary + * - need to check for abbreviation: A non-word char after a word-char + */ + while ( (c = vpeekc()) != NUL + && !ISSPECIAL(c) +#ifdef FEAT_MBYTE + && (!has_mbyte || MB_BYTE2LEN_CHECK(c) == 1) +#endif + && i < INPUT_BUFLEN + && (textwidth == 0 + || (virtcol += byte2cells(buf[i - 1])) < (colnr_T)textwidth) + && !(!no_abbr && !vim_iswordc(c) && vim_iswordc(buf[i - 1]))) + { +#ifdef FEAT_RIGHTLEFT + c = vgetc(); + if (p_hkmap && KeyTyped) + c = hkmap(c); /* Hebrew mode mapping */ +# ifdef FEAT_FKMAP + if (p_fkmap && KeyTyped) + c = fkmap(c); /* Farsi mode mapping */ +# endif + buf[i++] = c; +#else + buf[i++] = vgetc(); +#endif + } + +#ifdef FEAT_DIGRAPHS + do_digraph(-1); /* clear digraphs */ + do_digraph(buf[i-1]); /* may be the start of a digraph */ +#endif + buf[i] = NUL; + ins_str(buf); + if (flags & INSCHAR_CTRLV) + { + redo_literal(*buf); + i = 1; + } + else + i = 0; + if (buf[i] != NUL) + AppendToRedobuffLit(buf + i); + } + else + { +#ifdef FEAT_MBYTE + if (has_mbyte && (cc = (*mb_char2len)(c)) > 1) + { + char_u buf[MB_MAXBYTES + 1]; + + (*mb_char2bytes)(c, buf); + buf[cc] = NUL; + ins_char_bytes(buf, cc); + AppendCharToRedobuff(c); + } + else +#endif + { + ins_char(c); + if (flags & INSCHAR_CTRLV) + redo_literal(c); + else + AppendCharToRedobuff(c); + } + } +} + +/* + * Called after inserting or deleting text: When 'formatoptions' includes the + * 'a' flag format from the current line until the end of the paragraph. + * Keep the cursor at the same position relative to the text. + * The caller must have saved the cursor line for undo, following ones will be + * saved here. + */ + void +auto_format(trailblank, prev_line) + int trailblank; /* when TRUE also format with trailing blank */ + int prev_line; /* may start in previous line */ +{ + pos_T pos; + colnr_T len; + char_u *old; + char_u *new, *pnew; + int wasatend; + + if (!has_format_option(FO_AUTO)) + return; + + pos = curwin->w_cursor; + old = ml_get_curline(); + + /* may remove added space */ + check_auto_format(FALSE); + + /* Don't format in Insert mode when the cursor is on a trailing blank, the + * user might insert normal text next. Also skip formatting when "1" is + * in 'formatoptions' and there is a single character before the cursor. + * Otherwise the line would be broken and when typing another non-white + * next they are not joined back together. */ + wasatend = (pos.col == STRLEN(old)); + if (*old != NUL && !trailblank && wasatend) + { + dec_cursor(); + if (!WHITECHAR(gchar_cursor()) + && curwin->w_cursor.col > 0 + && has_format_option(FO_ONE_LETTER)) + dec_cursor(); + if (WHITECHAR(gchar_cursor())) + { + curwin->w_cursor = pos; + return; + } + curwin->w_cursor = pos; + } + +#ifdef FEAT_COMMENTS + /* With the 'c' flag in 'formatoptions' and 't' missing: only format + * comments. */ + if (has_format_option(FO_WRAP_COMS) && !has_format_option(FO_WRAP) + && get_leader_len(old, NULL, FALSE) == 0) + return; +#endif + + /* + * May start formatting in a previous line, so that after "x" a word is + * moved to the previous line if it fits there now. Only when this is not + * the start of a paragraph. + */ + if (prev_line && !paragraph_start(curwin->w_cursor.lnum)) + { + --curwin->w_cursor.lnum; + if (u_save_cursor() == FAIL) + return; + } + + /* + * Do the formatting and restore the cursor position. "saved_cursor" will + * be adjusted for the text formatting. + */ + saved_cursor = pos; + format_lines((linenr_T)-1); + curwin->w_cursor = saved_cursor; + saved_cursor.lnum = 0; + + if (curwin->w_cursor.lnum > curbuf->b_ml.ml_line_count) + { + /* "cannot happen" */ + curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count; + coladvance((colnr_T)MAXCOL); + } + else + check_cursor_col(); + + /* Insert mode: If the cursor is now after the end of the line while it + * previously wasn't, the line was broken. Because of the rule above we + * need to add a space when 'w' is in 'formatoptions' to keep a paragraph + * formatted. */ + if (!wasatend && has_format_option(FO_WHITE_PAR)) + { + new = ml_get_curline(); + len = STRLEN(new); + if (curwin->w_cursor.col == len) + { + pnew = vim_strnsave(new, len + 2); + pnew[len] = ' '; + pnew[len + 1] = NUL; + ml_replace(curwin->w_cursor.lnum, pnew, FALSE); + /* remove the space later */ + did_add_space = TRUE; + } + else + /* may remove added space */ + check_auto_format(FALSE); + } + + check_cursor(); +} + +/* + * When an extra space was added to continue a paragraph for auto-formatting, + * delete it now. The space must be under the cursor, just after the insert + * position. + */ + static void +check_auto_format(end_insert) + int end_insert; /* TRUE when ending Insert mode */ +{ + int c = ' '; + + if (did_add_space) + { + if (!WHITECHAR(gchar_cursor())) + /* Somehow the space was removed already. */ + did_add_space = FALSE; + else + { + if (!end_insert) + { + inc_cursor(); + c = gchar_cursor(); + dec_cursor(); + } + if (c != NUL) + { + /* The space is no longer at the end of the line, delete it. */ + del_char(FALSE); + did_add_space = FALSE; + } + } + } +} + +/* + * Find out textwidth to be used for formatting: + * if 'textwidth' option is set, use it + * else if 'wrapmargin' option is set, use W_WIDTH(curwin) - 'wrapmargin' + * if invalid value, use 0. + * Set default to window width (maximum 79) for "gq" operator. + */ + int +comp_textwidth(ff) + int ff; /* force formatting (for "Q" command) */ +{ + int textwidth; + + textwidth = curbuf->b_p_tw; + if (textwidth == 0 && curbuf->b_p_wm) + { + /* The width is the window width minus 'wrapmargin' minus all the + * things that add to the margin. */ + textwidth = W_WIDTH(curwin) - curbuf->b_p_wm; +#ifdef FEAT_CMDWIN + if (cmdwin_type != 0) + textwidth -= 1; +#endif +#ifdef FEAT_FOLDING + textwidth -= curwin->w_p_fdc; +#endif +#ifdef FEAT_SIGNS + if (curwin->w_buffer->b_signlist != NULL +# ifdef FEAT_NETBEANS_INTG + || usingNetbeans +# endif + ) + textwidth -= 1; +#endif + if (curwin->w_p_nu) + textwidth -= 8; + } + if (textwidth < 0) + textwidth = 0; + if (ff && textwidth == 0) + { + textwidth = W_WIDTH(curwin) - 1; + if (textwidth > 79) + textwidth = 79; + } + return textwidth; +} + +/* + * Put a character in the redo buffer, for when just after a CTRL-V. + */ + static void +redo_literal(c) + int c; +{ + char_u buf[10]; + + /* Only digits need special treatment. Translate them into a string of + * three digits. */ + if (VIM_ISDIGIT(c)) + { + sprintf((char *)buf, "%03d", c); + AppendToRedobuff(buf); + } + else + AppendCharToRedobuff(c); +} + +/* + * start_arrow() is called when an arrow key is used in insert mode. + * It resembles hitting the <ESC> key. + */ + static void +start_arrow(end_insert_pos) + pos_T *end_insert_pos; +{ + if (!arrow_used) /* something has been inserted */ + { + AppendToRedobuff(ESC_STR); + stop_insert(end_insert_pos, FALSE); + arrow_used = TRUE; /* this means we stopped the current insert */ + } +} + +/* + * stop_arrow() is called before a change is made in insert mode. + * If an arrow key has been used, start a new insertion. + * Returns FAIL if undo is impossible, shouldn't insert then. + */ + int +stop_arrow() +{ + if (arrow_used) + { + if (u_save_cursor() == OK) + { + arrow_used = FALSE; + ins_need_undo = FALSE; + } + Insstart = curwin->w_cursor; /* new insertion starts here */ + Insstart_textlen = linetabsize(ml_get_curline()); + ai_col = 0; +#ifdef FEAT_VREPLACE + if (State & VREPLACE_FLAG) + { + orig_line_count = curbuf->b_ml.ml_line_count; + vr_lines_changed = 1; + } +#endif + ResetRedobuff(); + AppendToRedobuff((char_u *)"1i"); /* pretend we start an insertion */ + } + else if (ins_need_undo) + { + if (u_save_cursor() == OK) + ins_need_undo = FALSE; + } + +#ifdef FEAT_FOLDING + /* Always open fold at the cursor line when inserting something. */ + foldOpenCursor(); +#endif + + return (arrow_used || ins_need_undo ? FAIL : OK); +} + +/* + * do a few things to stop inserting + */ + static void +stop_insert(end_insert_pos, esc) + pos_T *end_insert_pos; /* where insert ended */ + int esc; /* called by ins_esc() */ +{ + int cc; + + stop_redo_ins(); + replace_flush(); /* abandon replace stack */ + + /* + * save the inserted text for later redo with ^@ + */ + vim_free(last_insert); + last_insert = get_inserted(); + last_insert_skip = new_insert_skip; + + if (!arrow_used) + { + /* Auto-format now. It may seem strange to do this when stopping an + * insertion (or moving the cursor), but it's required when appending + * a line and having it end in a space. But only do it when something + * was actually inserted, otherwise undo won't work. */ + if (!ins_need_undo) + { + /* When the cursor is at the end of the line after a space the + * formatting will move it to the following word. Avoid that by + * moving the cursor onto the space. */ + cc = 'x'; + if (curwin->w_cursor.col > 0 && gchar_cursor() == NUL) + { + dec_cursor(); + cc = gchar_cursor(); + if (!vim_iswhite(cc)) + inc_cursor(); + } + + auto_format(TRUE, FALSE); + + if (vim_iswhite(cc) && gchar_cursor() != NUL) + inc_cursor(); + } + + /* If a space was inserted for auto-formatting, remove it now. */ + check_auto_format(TRUE); + + /* If we just did an auto-indent, remove the white space from the end + * of the line, and put the cursor back. */ + if (did_ai && esc) + { + if (gchar_cursor() == NUL && curwin->w_cursor.col > 0) + --curwin->w_cursor.col; + while (cc = gchar_cursor(), vim_iswhite(cc)) + (void)del_char(TRUE); + if (cc != NUL) + ++curwin->w_cursor.col; /* put cursor back on the NUL */ + +#ifdef FEAT_VISUAL + /* <C-S-Right> may have started Visual mode, adjust the position for + * deleted characters. */ + if (VIsual_active && VIsual.lnum == curwin->w_cursor.lnum) + { + cc = STRLEN(ml_get_curline()); + if (VIsual.col > (colnr_T)cc) + { + VIsual.col = cc; +# ifdef FEAT_VIRTUALEDIT + VIsual.coladd = 0; +# endif + } + } +#endif + } + } + did_ai = FALSE; +#ifdef FEAT_SMARTINDENT + did_si = FALSE; + can_si = FALSE; + can_si_back = FALSE; +#endif + + /* set '[ and '] to the inserted text */ + curbuf->b_op_start = Insstart; + curbuf->b_op_end = *end_insert_pos; +} + +/* + * Set the last inserted text to a single character. + * Used for the replace command. + */ + void +set_last_insert(c) + int c; +{ + char_u *s; + + vim_free(last_insert); +#ifdef FEAT_MBYTE + last_insert = alloc(MB_MAXBYTES * 3 + 5); +#else + last_insert = alloc(6); +#endif + if (last_insert != NULL) + { + s = last_insert; + /* Use the CTRL-V only when entering a special char */ + if (c < ' ' || c == DEL) + *s++ = Ctrl_V; + s = add_char2buf(c, s); + *s++ = ESC; + *s++ = NUL; + last_insert_skip = 0; + } +} + +/* + * Add character "c" to buffer "s". Escape the special meaning of K_SPECIAL + * and CSI. Handle multi-byte characters. + * Returns a pointer to after the added bytes. + */ + char_u * +add_char2buf(c, s) + int c; + char_u *s; +{ +#ifdef FEAT_MBYTE + char_u temp[MB_MAXBYTES]; + int i; + int len; + + len = (*mb_char2bytes)(c, temp); + for (i = 0; i < len; ++i) + { + c = temp[i]; +#endif + /* Need to escape K_SPECIAL and CSI like in the typeahead buffer. */ + if (c == K_SPECIAL) + { + *s++ = K_SPECIAL; + *s++ = KS_SPECIAL; + *s++ = KE_FILLER; + } +#ifdef FEAT_GUI + else if (c == CSI) + { + *s++ = CSI; + *s++ = KS_EXTRA; + *s++ = (int)KE_CSI; + } +#endif + else + *s++ = c; +#ifdef FEAT_MBYTE + } +#endif + return s; +} + +/* + * move cursor to start of line + * if flags & BL_WHITE move to first non-white + * if flags & BL_SOL move to first non-white if startofline is set, + * otherwise keep "curswant" column + * if flags & BL_FIX don't leave the cursor on a NUL. + */ + void +beginline(flags) + int flags; +{ + if ((flags & BL_SOL) && !p_sol) + coladvance(curwin->w_curswant); + else + { + curwin->w_cursor.col = 0; +#ifdef FEAT_VIRTUALEDIT + curwin->w_cursor.coladd = 0; +#endif + + if (flags & (BL_WHITE | BL_SOL)) + { + char_u *ptr; + + for (ptr = ml_get_curline(); vim_iswhite(*ptr) + && !((flags & BL_FIX) && ptr[1] == NUL); ++ptr) + ++curwin->w_cursor.col; + } + curwin->w_set_curswant = TRUE; + } +} + +/* + * oneright oneleft cursor_down cursor_up + * + * Move one char {right,left,down,up}. + * Doesn't move onto the NUL past the end of the line. + * Return OK when successful, FAIL when we hit a line of file boundary. + */ + + int +oneright() +{ + char_u *ptr; +#ifdef FEAT_MBYTE + int l; +#endif + +#ifdef FEAT_VIRTUALEDIT + if (virtual_active()) + { + pos_T prevpos = curwin->w_cursor; + + /* Adjust for multi-wide char (excluding TAB) */ + ptr = ml_get_cursor(); + coladvance(getviscol() + ((*ptr != TAB && vim_isprintc( +#ifdef FEAT_MBYTE + (*mb_ptr2char)(ptr) +#else + *ptr +#endif + )) + ? ptr2cells(ptr) : 1)); + curwin->w_set_curswant = TRUE; + /* Return OK if the cursor moved, FAIL otherwise (at window edge). */ + return (prevpos.col != curwin->w_cursor.col + || prevpos.coladd != curwin->w_cursor.coladd) ? OK : FAIL; + } +#endif + + ptr = ml_get_cursor(); +#ifdef FEAT_MBYTE + if (has_mbyte && (l = (*mb_ptr2len_check)(ptr)) > 1) + { + /* The character under the cursor is a multi-byte character, move + * several bytes right, but don't end up on the NUL. */ + if (ptr[l] == NUL) + return FAIL; + curwin->w_cursor.col += l; + } + else +#endif + { + if (*ptr++ == NUL || *ptr == NUL) + return FAIL; + ++curwin->w_cursor.col; + } + + curwin->w_set_curswant = TRUE; + return OK; +} + + int +oneleft() +{ +#ifdef FEAT_VIRTUALEDIT + if (virtual_active()) + { + int width; + int v = getviscol(); + + if (v == 0) + return FAIL; + +# ifdef FEAT_LINEBREAK + /* We might get stuck on 'showbreak', skip over it. */ + width = 1; + for (;;) + { + coladvance(v - width); + /* getviscol() is slow, skip it when 'showbreak' is empty and + * there are no multi-byte characters */ + if ((*p_sbr == NUL +# ifdef FEAT_MBYTE + && !has_mbyte +# endif + ) || getviscol() < v) + break; + ++width; + } +# else + coladvance(v - 1); +# endif + + if (curwin->w_cursor.coladd == 1) + { + char_u *ptr; + + /* Adjust for multi-wide char (not a TAB) */ + ptr = ml_get_cursor(); + if (*ptr != TAB && vim_isprintc( +# ifdef FEAT_MBYTE + (*mb_ptr2char)(ptr) +# else + *ptr +# endif + ) && ptr2cells(ptr) > 1) + curwin->w_cursor.coladd = 0; + } + + curwin->w_set_curswant = TRUE; + return OK; + } +#endif + + if (curwin->w_cursor.col == 0) + return FAIL; + + curwin->w_set_curswant = TRUE; + --curwin->w_cursor.col; + +#ifdef FEAT_MBYTE + /* if the character on the left of the current cursor is a multi-byte + * character, move to its first byte */ + if (has_mbyte) + mb_adjust_cursor(); +#endif + return OK; +} + + int +cursor_up(n, upd_topline) + long n; + int upd_topline; /* When TRUE: update topline */ +{ + linenr_T lnum; + + if (n > 0) + { + lnum = curwin->w_cursor.lnum; + if (lnum <= 1) + return FAIL; + if (n >= lnum) + lnum = 1; + else +#ifdef FEAT_FOLDING + if (hasAnyFolding(curwin)) + { + /* + * Count each sequence of folded lines as one logical line. + */ + /* go to the the start of the current fold */ + (void)hasFolding(lnum, &lnum, NULL); + + while (n--) + { + /* move up one line */ + --lnum; + if (lnum <= 1) + break; + /* If we entered a fold, move to the beginning, unless in + * Insert mode or when 'foldopen' contains "all": it will open + * in a moment. */ + if (n > 0 || !((State & INSERT) || (fdo_flags & FDO_ALL))) + (void)hasFolding(lnum, &lnum, NULL); + } + if (lnum < 1) + lnum = 1; + } + else +#endif + lnum -= n; + curwin->w_cursor.lnum = lnum; + } + + /* try to advance to the column we want to be at */ + coladvance(curwin->w_curswant); + + if (upd_topline) + update_topline(); /* make sure curwin->w_topline is valid */ + + return OK; +} + +/* + * Cursor down a number of logical lines. + */ + int +cursor_down(n, upd_topline) + long n; + int upd_topline; /* When TRUE: update topline */ +{ + linenr_T lnum; + + if (n > 0) + { + lnum = curwin->w_cursor.lnum; +#ifdef FEAT_FOLDING + /* Move to last line of fold, will fail if it's the end-of-file. */ + (void)hasFolding(lnum, NULL, &lnum); +#endif + if (lnum >= curbuf->b_ml.ml_line_count) + return FAIL; + if (lnum + n >= curbuf->b_ml.ml_line_count) + lnum = curbuf->b_ml.ml_line_count; + else +#ifdef FEAT_FOLDING + if (hasAnyFolding(curwin)) + { + linenr_T last; + + /* count each sequence of folded lines as one logical line */ + while (n--) + { + if (hasFolding(lnum, NULL, &last)) + lnum = last + 1; + else + ++lnum; + if (lnum >= curbuf->b_ml.ml_line_count) + break; + } + if (lnum > curbuf->b_ml.ml_line_count) + lnum = curbuf->b_ml.ml_line_count; + } + else +#endif + lnum += n; + curwin->w_cursor.lnum = lnum; + } + + /* try to advance to the column we want to be at */ + coladvance(curwin->w_curswant); + + if (upd_topline) + update_topline(); /* make sure curwin->w_topline is valid */ + + return OK; +} + +/* + * Stuff the last inserted text in the read buffer. + * Last_insert actually is a copy of the redo buffer, so we + * first have to remove the command. + */ + int +stuff_inserted(c, count, no_esc) + int c; /* Command character to be inserted */ + long count; /* Repeat this many times */ + int no_esc; /* Don't add an ESC at the end */ +{ + char_u *esc_ptr; + char_u *ptr; + char_u *last_ptr; + char_u last = NUL; + + ptr = get_last_insert(); + if (ptr == NULL) + { + EMSG(_(e_noinstext)); + return FAIL; + } + + /* may want to stuff the command character, to start Insert mode */ + if (c != NUL) + stuffcharReadbuff(c); + if ((esc_ptr = (char_u *)vim_strrchr(ptr, ESC)) != NULL) + *esc_ptr = NUL; /* remove the ESC */ + + /* when the last char is either "0" or "^" it will be quoted if no ESC + * comes after it OR if it will inserted more than once and "ptr" + * starts with ^D. -- Acevedo + */ + last_ptr = (esc_ptr ? esc_ptr : ptr + STRLEN(ptr)) - 1; + if (last_ptr >= ptr && (*last_ptr == '0' || *last_ptr == '^') + && (no_esc || (*ptr == Ctrl_D && count > 1))) + { + last = *last_ptr; + *last_ptr = NUL; + } + + do + { + stuffReadbuff(ptr); + /* a trailing "0" is inserted as "<C-V>048", "^" as "<C-V>^" */ + if (last) + stuffReadbuff((char_u *)(last == '0' + ? IF_EB("\026\060\064\070", CTRL_V_STR "xf0") + : IF_EB("\026^", CTRL_V_STR "^"))); + } + while (--count > 0); + + if (last) + *last_ptr = last; + + if (esc_ptr != NULL) + *esc_ptr = ESC; /* put the ESC back */ + + /* may want to stuff a trailing ESC, to get out of Insert mode */ + if (!no_esc) + stuffcharReadbuff(ESC); + + return OK; +} + + char_u * +get_last_insert() +{ + if (last_insert == NULL) + return NULL; + return last_insert + last_insert_skip; +} + +/* + * Get last inserted string, and remove trailing <Esc>. + * Returns pointer to allocated memory (must be freed) or NULL. + */ + char_u * +get_last_insert_save() +{ + char_u *s; + int len; + + if (last_insert == NULL) + return NULL; + s = vim_strsave(last_insert + last_insert_skip); + if (s != NULL) + { + len = (int)STRLEN(s); + if (len > 0 && s[len - 1] == ESC) /* remove trailing ESC */ + s[len - 1] = NUL; + } + return s; +} + +/* + * Check the word in front of the cursor for an abbreviation. + * Called when the non-id character "c" has been entered. + * When an abbreviation is recognized it is removed from the text and + * the replacement string is inserted in typebuf.tb_buf[], followed by "c". + */ + static int +echeck_abbr(c) + int c; +{ + /* Don't check for abbreviation in paste mode, when disabled and just + * after moving around with cursor keys. */ + if (p_paste || no_abbr || arrow_used) + return FALSE; + + return check_abbr(c, ml_get_curline(), curwin->w_cursor.col, + curwin->w_cursor.lnum == Insstart.lnum ? Insstart.col : 0); +} + +/* + * replace-stack functions + * + * When replacing characters, the replaced characters are remembered for each + * new character. This is used to re-insert the old text when backspacing. + * + * There is a NUL headed list of characters for each character that is + * currently in the file after the insertion point. When BS is used, one NUL + * headed list is put back for the deleted character. + * + * For a newline, there are two NUL headed lists. One contains the characters + * that the NL replaced. The extra one stores the characters after the cursor + * that were deleted (always white space). + * + * Replace_offset is normally 0, in which case replace_push will add a new + * character at the end of the stack. If replace_offset is not 0, that many + * characters will be left on the stack above the newly inserted character. + */ + +char_u *replace_stack = NULL; +long replace_stack_nr = 0; /* next entry in replace stack */ +long replace_stack_len = 0; /* max. number of entries */ + + void +replace_push(c) + int c; /* character that is replaced (NUL is none) */ +{ + char_u *p; + + if (replace_stack_nr < replace_offset) /* nothing to do */ + return; + if (replace_stack_len <= replace_stack_nr) + { + replace_stack_len += 50; + p = lalloc(sizeof(char_u) * replace_stack_len, TRUE); + if (p == NULL) /* out of memory */ + { + replace_stack_len -= 50; + return; + } + if (replace_stack != NULL) + { + mch_memmove(p, replace_stack, + (size_t)(replace_stack_nr * sizeof(char_u))); + vim_free(replace_stack); + } + replace_stack = p; + } + p = replace_stack + replace_stack_nr - replace_offset; + if (replace_offset) + mch_memmove(p + 1, p, (size_t)(replace_offset * sizeof(char_u))); + *p = c; + ++replace_stack_nr; +} + +/* + * call replace_push(c) with replace_offset set to the first NUL. + */ + static void +replace_push_off(c) + int c; +{ + char_u *p; + + p = replace_stack + replace_stack_nr; + for (replace_offset = 1; replace_offset < replace_stack_nr; + ++replace_offset) + if (*--p == NUL) + break; + replace_push(c); + replace_offset = 0; +} + +/* + * Pop one item from the replace stack. + * return -1 if stack empty + * return replaced character or NUL otherwise + */ + static int +replace_pop() +{ + if (replace_stack_nr == 0) + return -1; + return (int)replace_stack[--replace_stack_nr]; +} + +/* + * Join the top two items on the replace stack. This removes to "off"'th NUL + * encountered. + */ + static void +replace_join(off) + int off; /* offset for which NUL to remove */ +{ + int i; + + for (i = replace_stack_nr; --i >= 0; ) + if (replace_stack[i] == NUL && off-- <= 0) + { + --replace_stack_nr; + mch_memmove(replace_stack + i, replace_stack + i + 1, + (size_t)(replace_stack_nr - i)); + return; + } +} + +/* + * Pop bytes from the replace stack until a NUL is found, and insert them + * before the cursor. Can only be used in REPLACE or VREPLACE mode. + */ + static void +replace_pop_ins() +{ + int cc; + int oldState = State; + + State = NORMAL; /* don't want REPLACE here */ + while ((cc = replace_pop()) > 0) + { +#ifdef FEAT_MBYTE + mb_replace_pop_ins(cc); +#else + ins_char(cc); +#endif + dec_cursor(); + } + State = oldState; +} + +#ifdef FEAT_MBYTE +/* + * Insert bytes popped from the replace stack. "cc" is the first byte. If it + * indicates a multi-byte char, pop the other bytes too. + */ + static void +mb_replace_pop_ins(cc) + int cc; +{ + int n; + char_u buf[MB_MAXBYTES]; + int i; + int c; + + if (has_mbyte && (n = MB_BYTE2LEN(cc)) > 1) + { + buf[0] = cc; + for (i = 1; i < n; ++i) + buf[i] = replace_pop(); + ins_bytes_len(buf, n); + } + else + ins_char(cc); + + if (enc_utf8) + /* Handle composing chars. */ + for (;;) + { + c = replace_pop(); + if (c == -1) /* stack empty */ + break; + if ((n = MB_BYTE2LEN(c)) == 1) + { + /* Not a multi-byte char, put it back. */ + replace_push(c); + break; + } + else + { + buf[0] = c; + for (i = 1; i < n; ++i) + buf[i] = replace_pop(); + if (utf_iscomposing(utf_ptr2char(buf))) + ins_bytes_len(buf, n); + else + { + /* Not a composing char, put it back. */ + for (i = n - 1; i >= 0; --i) + replace_push(buf[i]); + break; + } + } + } +} +#endif + +/* + * make the replace stack empty + * (called when exiting replace mode) + */ + static void +replace_flush() +{ + vim_free(replace_stack); + replace_stack = NULL; + replace_stack_len = 0; + replace_stack_nr = 0; +} + +/* + * Handle doing a BS for one character. + * cc < 0: replace stack empty, just move cursor + * cc == 0: character was inserted, delete it + * cc > 0: character was replaced, put cc (first byte of original char) back + * and check for more characters to be put back + */ + static void +replace_do_bs() +{ + int cc; +#ifdef FEAT_VREPLACE + int orig_len = 0; + int ins_len; + int orig_vcols = 0; + colnr_T start_vcol; + char_u *p; + int i; + int vcol; +#endif + + cc = replace_pop(); + if (cc > 0) + { +#ifdef FEAT_VREPLACE + if (State & VREPLACE_FLAG) + { + /* Get the number of screen cells used by the character we are + * going to delete. */ + getvcol(curwin, &curwin->w_cursor, NULL, &start_vcol, NULL); + orig_vcols = chartabsize(ml_get_cursor(), start_vcol); + } +#endif +#ifdef FEAT_MBYTE + if (has_mbyte) + { + del_char(FALSE); +# ifdef FEAT_VREPLACE + if (State & VREPLACE_FLAG) + orig_len = STRLEN(ml_get_cursor()); +# endif + replace_push(cc); + } + else +#endif + { + pchar_cursor(cc); +#ifdef FEAT_VREPLACE + if (State & VREPLACE_FLAG) + orig_len = STRLEN(ml_get_cursor()) - 1; +#endif + } + replace_pop_ins(); + +#ifdef FEAT_VREPLACE + if (State & VREPLACE_FLAG) + { + /* Get the number of screen cells used by the inserted characters */ + p = ml_get_cursor(); + ins_len = STRLEN(p) - orig_len; + vcol = start_vcol; + for (i = 0; i < ins_len; ++i) + { + vcol += chartabsize(p + i, vcol); +#ifdef FEAT_MBYTE + i += (*mb_ptr2len_check)(p) - 1; +#endif + } + vcol -= start_vcol; + + /* Delete spaces that were inserted after the cursor to keep the + * text aligned. */ + curwin->w_cursor.col += ins_len; + while (vcol > orig_vcols && gchar_cursor() == ' ') + { + del_char(FALSE); + ++orig_vcols; + } + curwin->w_cursor.col -= ins_len; + } +#endif + + /* mark the buffer as changed and prepare for displaying */ + changed_bytes(curwin->w_cursor.lnum, curwin->w_cursor.col); + } + else if (cc == 0) + (void)del_char(FALSE); +} + +#ifdef FEAT_CINDENT +/* + * Return TRUE if C-indenting is on. + */ + static int +cindent_on() +{ + return (!p_paste && (curbuf->b_p_cin +# ifdef FEAT_EVAL + || *curbuf->b_p_inde != NUL +# endif + )); +} +#endif + +#if defined(FEAT_LISP) || defined(FEAT_CINDENT) || defined(PROTO) +/* + * Re-indent the current line, based on the current contents of it and the + * surrounding lines. Fixing the cursor position seems really easy -- I'm very + * confused what all the part that handles Control-T is doing that I'm not. + * "get_the_indent" should be get_c_indent, get_expr_indent or get_lisp_indent. + */ + + void +fixthisline(get_the_indent) + int (*get_the_indent) __ARGS((void)); +{ + change_indent(INDENT_SET, get_the_indent(), FALSE, 0); + if (linewhite(curwin->w_cursor.lnum)) + did_ai = TRUE; /* delete the indent if the line stays empty */ +} + + void +fix_indent() +{ + if (p_paste) + return; +# ifdef FEAT_LISP + if (curbuf->b_p_lisp && curbuf->b_p_ai) + fixthisline(get_lisp_indent); +# endif +# if defined(FEAT_LISP) && defined(FEAT_CINDENT) + else +# endif +# ifdef FEAT_CINDENT + if (cindent_on()) + do_c_expr_indent(); +# endif +} + +#endif + +#ifdef FEAT_CINDENT +/* + * return TRUE if 'cinkeys' contains the key "keytyped", + * when == '*': Only if key is preceded with '*' (indent before insert) + * when == '!': Only if key is prededed with '!' (don't insert) + * when == ' ': Only if key is not preceded with '*'(indent afterwards) + * + * "keytyped" can have a few special values: + * KEY_OPEN_FORW + * KEY_OPEN_BACK + * KEY_COMPLETE just finished completion. + * + * If line_is_empty is TRUE accept keys with '0' before them. + */ + int +in_cinkeys(keytyped, when, line_is_empty) + int keytyped; + int when; + int line_is_empty; +{ + char_u *look; + int try_match; + int try_match_word; + char_u *p; + char_u *line; + int icase; + int i; + +#ifdef FEAT_EVAL + if (*curbuf->b_p_inde != NUL) + look = curbuf->b_p_indk; /* 'indentexpr' set: use 'indentkeys' */ + else +#endif + look = curbuf->b_p_cink; /* 'indentexpr' empty: use 'cinkeys' */ + while (*look) + { + /* + * Find out if we want to try a match with this key, depending on + * 'when' and a '*' or '!' before the key. + */ + switch (when) + { + case '*': try_match = (*look == '*'); break; + case '!': try_match = (*look == '!'); break; + default: try_match = (*look != '*'); break; + } + if (*look == '*' || *look == '!') + ++look; + + /* + * If there is a '0', only accept a match if the line is empty. + * But may still match when typing last char of a word. + */ + if (*look == '0') + { + try_match_word = try_match; + if (!line_is_empty) + try_match = FALSE; + ++look; + } + else + try_match_word = FALSE; + + /* + * does it look like a control character? + */ + if (*look == '^' +#ifdef EBCDIC + && (Ctrl_chr(look[1]) != 0) +#else + && look[1] >= '?' && look[1] <= '_' +#endif + ) + { + if (try_match && keytyped == Ctrl_chr(look[1])) + return TRUE; + look += 2; + } + /* + * 'o' means "o" command, open forward. + * 'O' means "O" command, open backward. + */ + else if (*look == 'o') + { + if (try_match && keytyped == KEY_OPEN_FORW) + return TRUE; + ++look; + } + else if (*look == 'O') + { + if (try_match && keytyped == KEY_OPEN_BACK) + return TRUE; + ++look; + } + + /* + * 'e' means to check for "else" at start of line and just before the + * cursor. + */ + else if (*look == 'e') + { + if (try_match && keytyped == 'e' && curwin->w_cursor.col >= 4) + { + p = ml_get_curline(); + if (skipwhite(p) == p + curwin->w_cursor.col - 4 && + STRNCMP(p + curwin->w_cursor.col - 4, "else", 4) == 0) + return TRUE; + } + ++look; + } + + /* + * ':' only causes an indent if it is at the end of a label or case + * statement, or when it was before typing the ':' (to fix + * class::method for C++). + */ + else if (*look == ':') + { + if (try_match && keytyped == ':') + { + p = ml_get_curline(); + if (cin_iscase(p) || cin_isscopedecl(p) || cin_islabel(30)) + return TRUE; + if (curwin->w_cursor.col > 2 + && p[curwin->w_cursor.col - 1] == ':' + && p[curwin->w_cursor.col - 2] == ':') + { + p[curwin->w_cursor.col - 1] = ' '; + i = (cin_iscase(p) || cin_isscopedecl(p) + || cin_islabel(30)); + p = ml_get_curline(); + p[curwin->w_cursor.col - 1] = ':'; + if (i) + return TRUE; + } + } + ++look; + } + + + /* + * Is it a key in <>, maybe? + */ + else if (*look == '<') + { + if (try_match) + { + /* + * make up some named keys <o>, <O>, <e>, <0>, <>>, <<>, <*>, + * <:> and <!> so that people can re-indent on o, O, e, 0, <, + * >, *, : and ! keys if they really really want to. + */ + if (vim_strchr((char_u *)"<>!*oOe0:", look[1]) != NULL + && keytyped == look[1]) + return TRUE; + + if (keytyped == get_special_key_code(look + 1)) + return TRUE; + } + while (*look && *look != '>') + look++; + while (*look == '>') + look++; + } + + /* + * Is it a word: "=word"? + */ + else if (*look == '=' && look[1] != ',' && look[1] != NUL) + { + ++look; + if (*look == '~') + { + icase = TRUE; + ++look; + } + else + icase = FALSE; + p = vim_strchr(look, ','); + if (p == NULL) + p = look + STRLEN(look); + if ((try_match || try_match_word) + && curwin->w_cursor.col >= (colnr_T)(p - look)) + { + int match = FALSE; + +#ifdef FEAT_INS_EXPAND + if (keytyped == KEY_COMPLETE) + { + char_u *s; + + /* Just completed a word, check if it starts with "look". + * search back for the start of a word. */ + line = ml_get_curline(); +# ifdef FEAT_MBYTE + if (has_mbyte) + { + char_u *n; + + for (s = line + curwin->w_cursor.col; s > line; s = n) + { + n = mb_prevptr(line, s); + if (!vim_iswordp(n)) + break; + } + } + else +# endif + for (s = line + curwin->w_cursor.col; s > line; --s) + if (!vim_iswordc(s[-1])) + break; + if (s + (p - look) <= line + curwin->w_cursor.col + && (icase + ? MB_STRNICMP(s, look, p - look) + : STRNCMP(s, look, p - look)) == 0) + match = TRUE; + } + else +#endif + /* TODO: multi-byte */ + if (keytyped == (int)p[-1] || (icase && keytyped < 256 + && TOLOWER_LOC(keytyped) == TOLOWER_LOC((int)p[-1]))) + { + line = ml_get_cursor(); + if ((curwin->w_cursor.col == (colnr_T)(p - look) + || !vim_iswordc(line[-(p - look) - 1])) + && (icase + ? MB_STRNICMP(line - (p - look), look, p - look) + : STRNCMP(line - (p - look), look, p - look)) + == 0) + match = TRUE; + } + if (match && try_match_word && !try_match) + { + /* "0=word": Check if there are only blanks before the + * word. */ + line = ml_get_curline(); + if ((int)(skipwhite(line) - line) != + (int)(curwin->w_cursor.col - (p - look))) + match = FALSE; + } + if (match) + return TRUE; + } + look = p; + } + + /* + * ok, it's a boring generic character. + */ + else + { + if (try_match && *look == keytyped) + return TRUE; + ++look; + } + + /* + * Skip over ", ". + */ + look = skip_to_option_part(look); + } + return FALSE; +} +#endif /* FEAT_CINDENT */ + +#if defined(FEAT_RIGHTLEFT) || defined(PROTO) +/* + * Map Hebrew keyboard when in hkmap mode. + */ + int +hkmap(c) + int c; +{ + if (p_hkmapp) /* phonetic mapping, by Ilya Dogolazky */ + { + enum {hALEF=0, BET, GIMEL, DALET, HEI, VAV, ZAIN, HET, TET, IUD, + KAFsofit, hKAF, LAMED, MEMsofit, MEM, NUNsofit, NUN, SAMEH, AIN, + PEIsofit, PEI, ZADIsofit, ZADI, KOF, RESH, hSHIN, TAV}; + static char_u map[26] = + {(char_u)hALEF/*a*/, (char_u)BET /*b*/, (char_u)hKAF /*c*/, + (char_u)DALET/*d*/, (char_u)-1 /*e*/, (char_u)PEIsofit/*f*/, + (char_u)GIMEL/*g*/, (char_u)HEI /*h*/, (char_u)IUD /*i*/, + (char_u)HET /*j*/, (char_u)KOF /*k*/, (char_u)LAMED /*l*/, + (char_u)MEM /*m*/, (char_u)NUN /*n*/, (char_u)SAMEH /*o*/, + (char_u)PEI /*p*/, (char_u)-1 /*q*/, (char_u)RESH /*r*/, + (char_u)ZAIN /*s*/, (char_u)TAV /*t*/, (char_u)TET /*u*/, + (char_u)VAV /*v*/, (char_u)hSHIN/*w*/, (char_u)-1 /*x*/, + (char_u)AIN /*y*/, (char_u)ZADI /*z*/}; + + if (c == 'N' || c == 'M' || c == 'P' || c == 'C' || c == 'Z') + return (int)(map[CharOrd(c)] - 1 + p_aleph); + /* '-1'='sofit' */ + else if (c == 'x') + return 'X'; + else if (c == 'q') + return '\''; /* {geresh}={'} */ + else if (c == 246) + return ' '; /* \"o --> ' ' for a german keyboard */ + else if (c == 228) + return ' '; /* \"a --> ' ' -- / -- */ + else if (c == 252) + return ' '; /* \"u --> ' ' -- / -- */ +#ifdef EBCDIC + else if (islower(c)) +#else + /* NOTE: islower() does not do the right thing for us on Linux so we + * do this the same was as 5.7 and previous, so it works correctly on + * all systems. Specifically, the e.g. Delete and Arrow keys are + * munged and won't work if e.g. searching for Hebrew text. + */ + else if (c >= 'a' && c <= 'z') +#endif + return (int)(map[CharOrdLow(c)] + p_aleph); + else + return c; + } + else + { + switch (c) + { + case '`': return ';'; + case '/': return '.'; + case '\'': return ','; + case 'q': return '/'; + case 'w': return '\''; + + /* Hebrew letters - set offset from 'a' */ + case ',': c = '{'; break; + case '.': c = 'v'; break; + case ';': c = 't'; break; + default: { + static char str[] = "zqbcxlsjphmkwonu ydafe rig"; + +#ifdef EBCDIC + /* see note about islower() above */ + if (!islower(c)) +#else + if (c < 'a' || c > 'z') +#endif + return c; + c = str[CharOrdLow(c)]; + break; + } + } + + return (int)(CharOrdLow(c) + p_aleph); + } +} +#endif + + static void +ins_reg() +{ + int need_redraw = FALSE; + int regname; + int literally = 0; + + /* + * If we are going to wait for a character, show a '"'. + */ + pc_status = PC_STATUS_UNSET; + if (redrawing() && !char_avail()) + { + /* may need to redraw when no more chars available now */ + ins_redraw(); + + edit_putchar('"', TRUE); +#ifdef FEAT_CMDL_INFO + add_to_showcmd_c(Ctrl_R); +#endif + } + +#ifdef USE_ON_FLY_SCROLL + dont_scroll = TRUE; /* disallow scrolling here */ +#endif + + /* + * Don't map the register name. This also prevents the mode message to be + * deleted when ESC is hit. + */ + ++no_mapping; + regname = safe_vgetc(); +#ifdef FEAT_LANGMAP + LANGMAP_ADJUST(regname, TRUE); +#endif + if (regname == Ctrl_R || regname == Ctrl_O || regname == Ctrl_P) + { + /* Get a third key for literal register insertion */ + literally = regname; +#ifdef FEAT_CMDL_INFO + add_to_showcmd_c(literally); +#endif + regname = safe_vgetc(); +#ifdef FEAT_LANGMAP + LANGMAP_ADJUST(regname, TRUE); +#endif + } + --no_mapping; + +#ifdef FEAT_EVAL + /* + * Don't call u_sync() while getting the expression, + * evaluating it or giving an error message for it! + */ + ++no_u_sync; + if (regname == '=') + { +#ifdef USE_IM_CONTROL + int im_on = im_get_status(); +#endif + regname = get_expr_register(); +#ifdef USE_IM_CONTROL + /* Restore the Input Method. */ + if (im_on) + im_set_active(TRUE); +#endif + } + if (regname == NUL) + need_redraw = TRUE; /* remove the '"' */ + else + { +#endif + if (literally == Ctrl_O || literally == Ctrl_P) + { + /* Append the command to the redo buffer. */ + AppendCharToRedobuff(Ctrl_R); + AppendCharToRedobuff(literally); + AppendCharToRedobuff(regname); + + do_put(regname, BACKWARD, 1L, + (literally == Ctrl_P ? PUT_FIXINDENT : 0) | PUT_CURSEND); + } + else if (insert_reg(regname, literally) == FAIL) + { + vim_beep(); + need_redraw = TRUE; /* remove the '"' */ + } +#ifdef FEAT_EVAL + } + --no_u_sync; +#endif +#ifdef FEAT_CMDL_INFO + clear_showcmd(); +#endif + + /* If the inserted register is empty, we need to remove the '"' */ + if (need_redraw || stuff_empty()) + edit_unputchar(); +} + +/* + * CTRL-G commands in Insert mode. + */ + static void +ins_ctrl_g() +{ + int c; + +#ifdef FEAT_INS_EXPAND + /* Right after CTRL-X the cursor will be after the ruler. */ + setcursor(); +#endif + + /* + * Don't map the second key. This also prevents the mode message to be + * deleted when ESC is hit. + */ + ++no_mapping; + c = safe_vgetc(); + --no_mapping; + switch (c) + { + /* CTRL-G k and CTRL-G <Up>: cursor up to Insstart.col */ + case K_UP: + case Ctrl_K: + case 'k': ins_up(TRUE); + break; + + /* CTRL-G j and CTRL-G <Down>: cursor down to Insstart.col */ + case K_DOWN: + case Ctrl_J: + case 'j': ins_down(TRUE); + break; + + /* CTRL-G u: start new undoable edit */ + case 'u': u_sync(); + ins_need_undo = TRUE; + break; + + /* Unknown CTRL-G command, reserved for future expansion. */ + default: vim_beep(); + } +} + +/* + * Handle ESC in insert mode. + * Returns TRUE when leaving insert mode, FALSE when going to repeat the + * insert. + */ + static int +ins_esc(count, cmdchar) + long *count; + int cmdchar; +{ + int temp; + static int disabled_redraw = FALSE; + +#if defined(FEAT_HANGULIN) +# if defined(ESC_CHG_TO_ENG_MODE) + hangul_input_state_set(0); +# endif + if (composing_hangul) + { + push_raw_key(composing_hangul_buffer, 2); + composing_hangul = 0; + } +#endif +#if defined(FEAT_MBYTE) && defined(MACOS_CLASSIC) + previous_script = GetScriptManagerVariable(smKeyScript); + KeyScript(smKeyRoman); /* or smKeySysScript */ +#endif + + temp = curwin->w_cursor.col; + if (disabled_redraw) + { + --RedrawingDisabled; + disabled_redraw = FALSE; + } + if (!arrow_used) + { + /* + * Don't append the ESC for "r<CR>" and "grx". + */ + if (cmdchar != 'r' && cmdchar != 'v') + AppendToRedobuff(ESC_STR); + + /* + * Repeating insert may take a long time. Check for + * interrupt now and then. + */ + if (*count > 0) + { + line_breakcheck(); + if (got_int) + *count = 0; + } + + if (--*count > 0) /* repeat what was typed */ + { + (void)start_redo_ins(); + if (cmdchar == 'r' || cmdchar == 'v') + stuffReadbuff(ESC_STR); /* no ESC in redo buffer */ + ++RedrawingDisabled; + disabled_redraw = TRUE; + return FALSE; /* repeat the insert */ + } + stop_insert(&curwin->w_cursor, TRUE); + undisplay_dollar(); + } + + /* When an autoindent was removed, curswant stays after the + * indent */ + if (restart_edit == NUL && (colnr_T)temp == curwin->w_cursor.col) + curwin->w_set_curswant = TRUE; + + /* Remember the last Insert position in the '^ mark. */ + if (!cmdmod.keepjumps) + curbuf->b_last_insert = curwin->w_cursor; + + /* + * The cursor should end up on the last inserted character. + */ + if ((curwin->w_cursor.col != 0 +#ifdef FEAT_VIRTUALEDIT + || curwin->w_cursor.coladd > 0 +#endif + ) && (restart_edit == NUL + || (gchar_cursor() == NUL +#ifdef FEAT_VISUAL + && !VIsual_active +#endif + )) +#ifdef FEAT_RIGHTLEFT + && !revins_on +#endif + ) + { +#ifdef FEAT_VIRTUALEDIT + if (curwin->w_cursor.coladd > 0 || ve_flags == VE_ALL) + { + oneleft(); + if (restart_edit != NUL) + ++curwin->w_cursor.coladd; + } + else +#endif + { + --curwin->w_cursor.col; +#ifdef FEAT_MBYTE + /* Correct cursor for multi-byte character. */ + if (has_mbyte) + mb_adjust_cursor(); +#endif + } + } + +#ifdef USE_IM_CONTROL + /* Disable IM to allow typing English directly for Normal mode commands. + * When ":lmap" is enabled don't change 'iminsert' (IM can be enabled as + * well). */ + if (!(State & LANGMAP)) + im_save_status(&curbuf->b_p_iminsert); + im_set_active(FALSE); +#endif + + State = NORMAL; + /* need to position cursor again (e.g. when on a TAB ) */ + changed_cline_bef_curs(); + +#ifdef FEAT_MOUSE + setmouse(); +#endif +#ifdef CURSOR_SHAPE + ui_cursor_shape(); /* may show different cursor shape */ +#endif + + /* + * When recording or for CTRL-O, need to display the new mode. + * Otherwise remove the mode message. + */ + if (Recording || restart_edit != NUL) + showmode(); + else if (p_smd) + MSG(""); + + return TRUE; /* exit Insert mode */ +} + +#ifdef FEAT_RIGHTLEFT +/* + * Toggle language: hkmap and revins_on. + * Move to end of reverse inserted text. + */ + static void +ins_ctrl_() +{ + if (revins_on && revins_chars && revins_scol >= 0) + { + while (gchar_cursor() != NUL && revins_chars--) + ++curwin->w_cursor.col; + } + p_ri = !p_ri; + revins_on = (State == INSERT && p_ri); + if (revins_on) + { + revins_scol = curwin->w_cursor.col; + revins_legal++; + revins_chars = 0; + undisplay_dollar(); + } + else + revins_scol = -1; +#ifdef FEAT_FKMAP + if (p_altkeymap) + { + /* + * to be consistent also for redo command, using '.' + * set arrow_used to true and stop it - causing to redo + * characters entered in one mode (normal/reverse insert). + */ + arrow_used = TRUE; + (void)stop_arrow(); + p_fkmap = curwin->w_p_rl ^ p_ri; + if (p_fkmap && p_ri) + State = INSERT; + } + else +#endif + p_hkmap = curwin->w_p_rl ^ p_ri; /* be consistent! */ + showmode(); +} +#endif + +#ifdef FEAT_VISUAL +/* + * If 'keymodel' contains "startsel", may start selection. + * Returns TRUE when a CTRL-O and other keys stuffed. + */ + static int +ins_start_select(c) + int c; +{ + if (km_startsel) + switch (c) + { + case K_KHOME: + case K_XHOME: + case K_KEND: + case K_XEND: + case K_PAGEUP: + case K_KPAGEUP: + case K_PAGEDOWN: + case K_KPAGEDOWN: +# ifdef MACOS + case K_LEFT: + case K_RIGHT: + case K_UP: + case K_DOWN: + case K_END: + case K_HOME: +# endif + if (!(mod_mask & MOD_MASK_SHIFT)) + break; + /* FALLTHROUGH */ + case K_S_LEFT: + case K_S_RIGHT: + case K_S_UP: + case K_S_DOWN: + case K_S_END: + case K_S_HOME: + /* Start selection right away, the cursor can move with + * CTRL-O when beyond the end of the line. */ + start_selection(); + + /* Execute the key in (insert) Select mode. */ + stuffcharReadbuff(Ctrl_O); + if (mod_mask) + { + char_u buf[4]; + + buf[0] = K_SPECIAL; + buf[1] = KS_MODIFIER; + buf[2] = mod_mask; + buf[3] = NUL; + stuffReadbuff(buf); + } + stuffcharReadbuff(c); + return TRUE; + } + return FALSE; +} +#endif + +/* + * If the cursor is on an indent, ^T/^D insert/delete one + * shiftwidth. Otherwise ^T/^D behave like a "<<" or ">>". + * Always round the indent to 'shiftwith', this is compatible + * with vi. But vi only supports ^T and ^D after an + * autoindent, we support it everywhere. + */ + static void +ins_shift(c, lastc) + int c; + int lastc; +{ + if (stop_arrow() == FAIL) + return; + AppendCharToRedobuff(c); + + /* + * 0^D and ^^D: remove all indent. + */ + if ((lastc == '0' || lastc == '^') && curwin->w_cursor.col) + { + --curwin->w_cursor.col; + (void)del_char(FALSE); /* delete the '^' or '0' */ + /* In Replace mode, restore the characters that '^' or '0' replaced. */ + if (State & REPLACE_FLAG) + replace_pop_ins(); + if (lastc == '^') + old_indent = get_indent(); /* remember curr. indent */ + change_indent(INDENT_SET, 0, TRUE, 0); + } + else + change_indent(c == Ctrl_D ? INDENT_DEC : INDENT_INC, 0, TRUE, 0); + + if (did_ai && *skipwhite(ml_get_curline()) != NUL) + did_ai = FALSE; +#ifdef FEAT_SMARTINDENT + did_si = FALSE; + can_si = FALSE; + can_si_back = FALSE; +#endif +#ifdef FEAT_CINDENT + can_cindent = FALSE; /* no cindenting after ^D or ^T */ +#endif +} + + static void +ins_del() +{ + int temp; + + if (stop_arrow() == FAIL) + return; + if (gchar_cursor() == NUL) /* delete newline */ + { + temp = curwin->w_cursor.col; + if (!can_bs(BS_EOL) /* only if "eol" included */ + || u_save((linenr_T)(curwin->w_cursor.lnum - 1), + (linenr_T)(curwin->w_cursor.lnum + 2)) == FAIL + || do_join(FALSE) == FAIL) + vim_beep(); + else + curwin->w_cursor.col = temp; + } + else if (del_char(FALSE) == FAIL) /* delete char under cursor */ + vim_beep(); + did_ai = FALSE; +#ifdef FEAT_SMARTINDENT + did_si = FALSE; + can_si = FALSE; + can_si_back = FALSE; +#endif + AppendCharToRedobuff(K_DEL); +} + +/* + * Handle Backspace, delete-word and delete-line in Insert mode. + * Return TRUE when backspace was actually used. + */ + static int +ins_bs(c, mode, inserted_space_p) + int c; + int mode; + int *inserted_space_p; +{ + linenr_T lnum; + int cc; + int temp = 0; /* init for GCC */ + colnr_T mincol; + int did_backspace = FALSE; + int in_indent; + int oldState; +#ifdef FEAT_MBYTE + int p1, p2; +#endif + + /* + * can't delete anything in an empty file + * can't backup past first character in buffer + * can't backup past starting point unless 'backspace' > 1 + * can backup to a previous line if 'backspace' == 0 + */ + if ( bufempty() + || ( +#ifdef FEAT_RIGHTLEFT + !revins_on && +#endif + ((curwin->w_cursor.lnum == 1 && curwin->w_cursor.col == 0) + || (!can_bs(BS_START) + && (arrow_used + || (curwin->w_cursor.lnum == Insstart.lnum + && curwin->w_cursor.col <= Insstart.col))) + || (!can_bs(BS_INDENT) && !arrow_used && ai_col > 0 + && curwin->w_cursor.col <= ai_col) + || (!can_bs(BS_EOL) && curwin->w_cursor.col == 0)))) + { + vim_beep(); + return FALSE; + } + + if (stop_arrow() == FAIL) + return FALSE; + in_indent = inindent(0); +#ifdef FEAT_CINDENT + if (in_indent) + can_cindent = FALSE; +#endif +#ifdef FEAT_COMMENTS + end_comment_pending = NUL; /* After BS, don't auto-end comment */ +#endif +#ifdef FEAT_RIGHTLEFT + if (revins_on) /* put cursor after last inserted char */ + inc_cursor(); +#endif + +#ifdef FEAT_VIRTUALEDIT + /* Virtualedit: + * BACKSPACE_CHAR eats a virtual space + * BACKSPACE_WORD eats all coladd + * BACKSPACE_LINE eats all coladd and keeps going + */ + if (curwin->w_cursor.coladd > 0) + { + if (mode == BACKSPACE_CHAR) + { + --curwin->w_cursor.coladd; + return TRUE; + } + if (mode == BACKSPACE_WORD) + { + curwin->w_cursor.coladd = 0; + return TRUE; + } + curwin->w_cursor.coladd = 0; + } +#endif + + /* + * delete newline! + */ + if (curwin->w_cursor.col == 0) + { + lnum = Insstart.lnum; + if (curwin->w_cursor.lnum == Insstart.lnum +#ifdef FEAT_RIGHTLEFT + || revins_on +#endif + ) + { + if (u_save((linenr_T)(curwin->w_cursor.lnum - 2), + (linenr_T)(curwin->w_cursor.lnum + 1)) == FAIL) + return FALSE; + --Insstart.lnum; + Insstart.col = MAXCOL; + } + /* + * In replace mode: + * cc < 0: NL was inserted, delete it + * cc >= 0: NL was replaced, put original characters back + */ + cc = -1; + if (State & REPLACE_FLAG) + cc = replace_pop(); /* returns -1 if NL was inserted */ + /* + * In replace mode, in the line we started replacing, we only move the + * cursor. + */ + if ((State & REPLACE_FLAG) && curwin->w_cursor.lnum <= lnum) + { + dec_cursor(); + } + else + { +#ifdef FEAT_VREPLACE + if (!(State & VREPLACE_FLAG) + || curwin->w_cursor.lnum > orig_line_count) +#endif + { + temp = gchar_cursor(); /* remember current char */ + --curwin->w_cursor.lnum; + (void)do_join(FALSE); + if (temp == NUL && gchar_cursor() != NUL) + inc_cursor(); + } +#ifdef FEAT_VREPLACE + else + dec_cursor(); +#endif + + /* + * In REPLACE mode we have to put back the text that was replaced + * by the NL. On the replace stack is first a NUL-terminated + * sequence of characters that were deleted and then the + * characters that NL replaced. + */ + if (State & REPLACE_FLAG) + { + /* + * Do the next ins_char() in NORMAL state, to + * prevent ins_char() from replacing characters and + * avoiding showmatch(). + */ + oldState = State; + State = NORMAL; + /* + * restore characters (blanks) deleted after cursor + */ + while (cc > 0) + { + temp = curwin->w_cursor.col; +#ifdef FEAT_MBYTE + mb_replace_pop_ins(cc); +#else + ins_char(cc); +#endif + curwin->w_cursor.col = temp; + cc = replace_pop(); + } + /* restore the characters that NL replaced */ + replace_pop_ins(); + State = oldState; + } + } + did_ai = FALSE; + } + else + { + /* + * Delete character(s) before the cursor. + */ +#ifdef FEAT_RIGHTLEFT + if (revins_on) /* put cursor on last inserted char */ + dec_cursor(); +#endif + mincol = 0; + /* keep indent */ + if (mode == BACKSPACE_LINE && curbuf->b_p_ai +#ifdef FEAT_RIGHTLEFT + && !revins_on +#endif + ) + { + temp = curwin->w_cursor.col; + beginline(BL_WHITE); + if (curwin->w_cursor.col < (colnr_T)temp) + mincol = curwin->w_cursor.col; + curwin->w_cursor.col = temp; + } + + /* + * Handle deleting one 'shiftwidth' or 'softtabstop'. + */ + if ( mode == BACKSPACE_CHAR + && ((p_sta && in_indent) + || (curbuf->b_p_sts + && (*(ml_get_cursor() - 1) == TAB + || (*(ml_get_cursor() - 1) == ' ' + && (!*inserted_space_p + || arrow_used)))))) + { + int ts; + colnr_T vcol; + colnr_T want_vcol; + int extra = 0; + + *inserted_space_p = FALSE; + if (p_sta) + ts = curbuf->b_p_sw; + else + ts = curbuf->b_p_sts; + /* Compute the virtual column where we want to be. Since + * 'showbreak' may get in the way, need to get the last column of + * the previous character. */ + getvcol(curwin, &curwin->w_cursor, &vcol, NULL, NULL); + dec_cursor(); + getvcol(curwin, &curwin->w_cursor, NULL, NULL, &want_vcol); + inc_cursor(); + want_vcol = (want_vcol / ts) * ts; + + /* delete characters until we are at or before want_vcol */ + while (vcol > want_vcol + && (cc = *(ml_get_cursor() - 1), vim_iswhite(cc))) + { + dec_cursor(); + getvcol(curwin, &curwin->w_cursor, &vcol, NULL, NULL); + if (State & REPLACE_FLAG) + { + /* Don't delete characters before the insert point when in + * Replace mode */ + if (curwin->w_cursor.lnum != Insstart.lnum + || curwin->w_cursor.col >= Insstart.col) + { +#if 0 /* what was this for? It causes problems when sw != ts. */ + if (State == REPLACE && (int)vcol < want_vcol) + { + (void)del_char(FALSE); + extra = 2; /* don't pop too much */ + } + else +#endif + replace_do_bs(); + } + } + else + (void)del_char(FALSE); + } + + /* insert extra spaces until we are at want_vcol */ + while (vcol < want_vcol) + { + /* Remember the first char we inserted */ + if (curwin->w_cursor.lnum == Insstart.lnum + && curwin->w_cursor.col < Insstart.col) + Insstart.col = curwin->w_cursor.col; + +#ifdef FEAT_VREPLACE + if (State & VREPLACE_FLAG) + ins_char(' '); + else +#endif + { + ins_str((char_u *)" "); + if ((State & REPLACE_FLAG) && extra <= 1) + { + if (extra) + replace_push_off(NUL); + else + replace_push(NUL); + } + if (extra == 2) + extra = 1; + } + getvcol(curwin, &curwin->w_cursor, &vcol, NULL, NULL); + } + } + + /* + * Delete upto starting point, start of line or previous word. + */ + else do + { +#ifdef FEAT_RIGHTLEFT + if (!revins_on) /* put cursor on char to be deleted */ +#endif + dec_cursor(); + + /* start of word? */ + if (mode == BACKSPACE_WORD && !vim_isspace(gchar_cursor())) + { + mode = BACKSPACE_WORD_NOT_SPACE; + temp = vim_iswordc(gchar_cursor()); + } + /* end of word? */ + else if (mode == BACKSPACE_WORD_NOT_SPACE + && (vim_isspace(cc = gchar_cursor()) + || vim_iswordc(cc) != temp)) + { +#ifdef FEAT_RIGHTLEFT + if (!revins_on) +#endif + inc_cursor(); +#ifdef FEAT_RIGHTLEFT + else if (State & REPLACE_FLAG) + dec_cursor(); +#endif + break; + } + if (State & REPLACE_FLAG) + replace_do_bs(); + else + { +#ifdef FEAT_MBYTE + if (enc_utf8 && p_deco) + (void)utfc_ptr2char(ml_get_cursor(), &p1, &p2); +#endif + (void)del_char(FALSE); +#ifdef FEAT_MBYTE + /* + * If p1 or p2 is non-zero, there are combining characters we + * need to take account of. Don't back up before the base + * character. + */ + if (enc_utf8 && p_deco && (p1 != NUL || p2 != NUL)) + inc_cursor(); +#endif +#ifdef FEAT_RIGHTLEFT + if (revins_chars) + { + revins_chars--; + revins_legal++; + } + if (revins_on && gchar_cursor() == NUL) + break; +#endif + } + /* Just a single backspace?: */ + if (mode == BACKSPACE_CHAR) + break; + } while ( +#ifdef FEAT_RIGHTLEFT + revins_on || +#endif + (curwin->w_cursor.col > mincol + && (curwin->w_cursor.lnum != Insstart.lnum + || curwin->w_cursor.col != Insstart.col))); + did_backspace = TRUE; + } +#ifdef FEAT_SMARTINDENT + did_si = FALSE; + can_si = FALSE; + can_si_back = FALSE; +#endif + if (curwin->w_cursor.col <= 1) + did_ai = FALSE; + /* + * It's a little strange to put backspaces into the redo + * buffer, but it makes auto-indent a lot easier to deal + * with. + */ + AppendCharToRedobuff(c); + + /* If deleted before the insertion point, adjust it */ + if (curwin->w_cursor.lnum == Insstart.lnum + && curwin->w_cursor.col < Insstart.col) + Insstart.col = curwin->w_cursor.col; + + /* vi behaviour: the cursor moves backward but the character that + * was there remains visible + * Vim behaviour: the cursor moves backward and the character that + * was there is erased from the screen. + * We can emulate the vi behaviour by pretending there is a dollar + * displayed even when there isn't. + * --pkv Sun Jan 19 01:56:40 EST 2003 */ + if (vim_strchr(p_cpo, CPO_BACKSPACE) != NULL && dollar_vcol == 0) + dollar_vcol = curwin->w_virtcol; + + return did_backspace; +} + +#ifdef FEAT_MOUSE + static void +ins_mouse(c) + int c; +{ + pos_T tpos; + +# ifdef FEAT_GUI + /* When GUI is active, also move/paste when 'mouse' is empty */ + if (!gui.in_use) +# endif + if (!mouse_has(MOUSE_INSERT)) + return; + + undisplay_dollar(); + tpos = curwin->w_cursor; + if (do_mouse(NULL, c, BACKWARD, 1L, 0)) + { + start_arrow(&tpos); +# ifdef FEAT_CINDENT + can_cindent = TRUE; +# endif + } + +#ifdef FEAT_WINDOWS + /* redraw status lines (in case another window became active) */ + redraw_statuslines(); +#endif +} + + static void +ins_mousescroll(up) + int up; +{ + pos_T tpos; +# if defined(FEAT_GUI) && defined(FEAT_WINDOWS) + win_T *old_curwin; +# endif + + tpos = curwin->w_cursor; + +# if defined(FEAT_GUI) && defined(FEAT_WINDOWS) + old_curwin = curwin; + + /* Currently the mouse coordinates are only known in the GUI. */ + if (gui.in_use && mouse_row >= 0 && mouse_col >= 0) + { + int row, col; + + row = mouse_row; + col = mouse_col; + + /* find the window at the pointer coordinates */ + curwin = mouse_find_win(&row, &col); + curbuf = curwin->w_buffer; + } + if (curwin == old_curwin) +# endif + undisplay_dollar(); + + if (mod_mask & (MOD_MASK_SHIFT | MOD_MASK_CTRL)) + scroll_redraw(up, (long)(curwin->w_botline - curwin->w_topline)); + else + scroll_redraw(up, 3L); + +# if defined(FEAT_GUI) && defined(FEAT_WINDOWS) + curwin->w_redr_status = TRUE; + + curwin = old_curwin; + curbuf = curwin->w_buffer; +# endif + + if (!equalpos(curwin->w_cursor, tpos)) + { + start_arrow(&tpos); +# ifdef FEAT_CINDENT + can_cindent = TRUE; +# endif + } +} +#endif + +#ifdef FEAT_GUI + void +ins_scroll() +{ + pos_T tpos; + + undisplay_dollar(); + tpos = curwin->w_cursor; + if (gui_do_scroll()) + { + start_arrow(&tpos); +# ifdef FEAT_CINDENT + can_cindent = TRUE; +# endif + } +} + + void +ins_horscroll() +{ + pos_T tpos; + + undisplay_dollar(); + tpos = curwin->w_cursor; + if (gui_do_horiz_scroll()) + { + start_arrow(&tpos); +# ifdef FEAT_CINDENT + can_cindent = TRUE; +# endif + } +} +#endif + + static void +ins_left() +{ + pos_T tpos; + +#ifdef FEAT_FOLDING + if ((fdo_flags & FDO_HOR) && KeyTyped) + foldOpenCursor(); +#endif + undisplay_dollar(); + tpos = curwin->w_cursor; + if (oneleft() == OK) + { + start_arrow(&tpos); +#ifdef FEAT_RIGHTLEFT + /* If exit reversed string, position is fixed */ + if (revins_scol != -1 && (int)curwin->w_cursor.col >= revins_scol) + revins_legal++; + revins_chars++; +#endif + } + + /* + * if 'whichwrap' set for cursor in insert mode may go to + * previous line + */ + else if (vim_strchr(p_ww, '[') != NULL && curwin->w_cursor.lnum > 1) + { + start_arrow(&tpos); + --(curwin->w_cursor.lnum); + coladvance((colnr_T)MAXCOL); + curwin->w_set_curswant = TRUE; /* so we stay at the end */ + } + else + vim_beep(); +} + + static void +ins_home(c) + int c; +{ + pos_T tpos; + +#ifdef FEAT_FOLDING + if ((fdo_flags & FDO_HOR) && KeyTyped) + foldOpenCursor(); +#endif + undisplay_dollar(); + tpos = curwin->w_cursor; + if (c == K_C_HOME) + curwin->w_cursor.lnum = 1; + curwin->w_cursor.col = 0; +#ifdef FEAT_VIRTUALEDIT + curwin->w_cursor.coladd = 0; +#endif + curwin->w_curswant = 0; + start_arrow(&tpos); +} + + static void +ins_end(c) + int c; +{ + pos_T tpos; + +#ifdef FEAT_FOLDING + if ((fdo_flags & FDO_HOR) && KeyTyped) + foldOpenCursor(); +#endif + undisplay_dollar(); + tpos = curwin->w_cursor; + if (c == K_C_END) + curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count; + coladvance((colnr_T)MAXCOL); + curwin->w_curswant = MAXCOL; + + start_arrow(&tpos); +} + + static void +ins_s_left() +{ +#ifdef FEAT_FOLDING + if ((fdo_flags & FDO_HOR) && KeyTyped) + foldOpenCursor(); +#endif + undisplay_dollar(); + if (curwin->w_cursor.lnum > 1 || curwin->w_cursor.col > 0) + { + start_arrow(&curwin->w_cursor); + (void)bck_word(1L, FALSE, FALSE); + curwin->w_set_curswant = TRUE; + } + else + vim_beep(); +} + + static void +ins_right() +{ +#ifdef FEAT_FOLDING + if ((fdo_flags & FDO_HOR) && KeyTyped) + foldOpenCursor(); +#endif + undisplay_dollar(); + if (gchar_cursor() != NUL || virtual_active() + ) + { + start_arrow(&curwin->w_cursor); + curwin->w_set_curswant = TRUE; +#ifdef FEAT_VIRTUALEDIT + if (virtual_active()) + oneright(); + else +#endif + { +#ifdef FEAT_MBYTE + if (has_mbyte) + curwin->w_cursor.col += (*mb_ptr2len_check)(ml_get_cursor()); + else +#endif + ++curwin->w_cursor.col; + } + +#ifdef FEAT_RIGHTLEFT + revins_legal++; + if (revins_chars) + revins_chars--; +#endif + } + /* if 'whichwrap' set for cursor in insert mode, may move the + * cursor to the next line */ + else if (vim_strchr(p_ww, ']') != NULL + && curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count) + { + start_arrow(&curwin->w_cursor); + curwin->w_set_curswant = TRUE; + ++curwin->w_cursor.lnum; + curwin->w_cursor.col = 0; + } + else + vim_beep(); +} + + static void +ins_s_right() +{ +#ifdef FEAT_FOLDING + if ((fdo_flags & FDO_HOR) && KeyTyped) + foldOpenCursor(); +#endif + undisplay_dollar(); + if (curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count + || gchar_cursor() != NUL) + { + start_arrow(&curwin->w_cursor); + (void)fwd_word(1L, FALSE, 0); + curwin->w_set_curswant = TRUE; + } + else + vim_beep(); +} + + static void +ins_up(startcol) + int startcol; /* when TRUE move to Insstart.col */ +{ + pos_T tpos; + linenr_T old_topline = curwin->w_topline; +#ifdef FEAT_DIFF + int old_topfill = curwin->w_topfill; +#endif + + undisplay_dollar(); + tpos = curwin->w_cursor; + if (cursor_up(1L, TRUE) == OK) + { + if (startcol) + coladvance(getvcol_nolist(&Insstart)); + if (old_topline != curwin->w_topline +#ifdef FEAT_DIFF + || old_topfill != curwin->w_topfill +#endif + ) + redraw_later(VALID); + start_arrow(&tpos); +#ifdef FEAT_CINDENT + can_cindent = TRUE; +#endif + } + else + vim_beep(); +} + + static void +ins_pageup() +{ + pos_T tpos; + + undisplay_dollar(); + tpos = curwin->w_cursor; + if (onepage(BACKWARD, 1L) == OK) + { + start_arrow(&tpos); +#ifdef FEAT_CINDENT + can_cindent = TRUE; +#endif + } + else + vim_beep(); +} + + static void +ins_down(startcol) + int startcol; /* when TRUE move to Insstart.col */ +{ + pos_T tpos; + linenr_T old_topline = curwin->w_topline; +#ifdef FEAT_DIFF + int old_topfill = curwin->w_topfill; +#endif + + undisplay_dollar(); + tpos = curwin->w_cursor; + if (cursor_down(1L, TRUE) == OK) + { + if (startcol) + coladvance(getvcol_nolist(&Insstart)); + if (old_topline != curwin->w_topline +#ifdef FEAT_DIFF + || old_topfill != curwin->w_topfill +#endif + ) + redraw_later(VALID); + start_arrow(&tpos); +#ifdef FEAT_CINDENT + can_cindent = TRUE; +#endif + } + else + vim_beep(); +} + + static void +ins_pagedown() +{ + pos_T tpos; + + undisplay_dollar(); + tpos = curwin->w_cursor; + if (onepage(FORWARD, 1L) == OK) + { + start_arrow(&tpos); +#ifdef FEAT_CINDENT + can_cindent = TRUE; +#endif + } + else + vim_beep(); +} + +#ifdef FEAT_DND + static void +ins_drop() +{ + do_put('~', BACKWARD, 1L, PUT_CURSEND); +} +#endif + +/* + * Handle TAB in Insert or Replace mode. + * Return TRUE when the TAB needs to be inserted like a normal character. + */ + static int +ins_tab() +{ + int ind; + int i; + int temp; + + if (Insstart_blank_vcol == MAXCOL && curwin->w_cursor.lnum == Insstart.lnum) + Insstart_blank_vcol = get_nolist_virtcol(); + if (echeck_abbr(TAB + ABBR_OFF)) + return FALSE; + + ind = inindent(0); +#ifdef FEAT_CINDENT + if (ind) + can_cindent = FALSE; +#endif + + /* + * When nothing special, insert TAB like a normal character + */ + if (!curbuf->b_p_et + && !(p_sta && ind && curbuf->b_p_ts != curbuf->b_p_sw) + && curbuf->b_p_sts == 0) + return TRUE; + + if (stop_arrow() == FAIL) + return TRUE; + + did_ai = FALSE; +#ifdef FEAT_SMARTINDENT + did_si = FALSE; + can_si = FALSE; + can_si_back = FALSE; +#endif + AppendToRedobuff((char_u *)"\t"); + + if (p_sta && ind) /* insert tab in indent, use 'shiftwidth' */ + temp = (int)curbuf->b_p_sw; + else if (curbuf->b_p_sts > 0) /* use 'softtabstop' when set */ + temp = (int)curbuf->b_p_sts; + else /* otherwise use 'tabstop' */ + temp = (int)curbuf->b_p_ts; + temp -= get_nolist_virtcol() % temp; + + /* + * Insert the first space with ins_char(). It will delete one char in + * replace mode. Insert the rest with ins_str(); it will not delete any + * chars. For VREPLACE mode, we use ins_char() for all characters. + */ + ins_char(' '); + while (--temp > 0) + { +#ifdef FEAT_VREPLACE + if (State & VREPLACE_FLAG) + ins_char(' '); + else +#endif + { + ins_str((char_u *)" "); + if (State & REPLACE_FLAG) /* no char replaced */ + replace_push(NUL); + } + } + + /* + * When 'expandtab' not set: Replace spaces by TABs where possible. + */ + if (!curbuf->b_p_et && (curbuf->b_p_sts || (p_sta && ind))) + { + char_u *ptr; +#ifdef FEAT_VREPLACE + char_u *saved_line = NULL; /* init for GCC */ + pos_T pos; +#endif + pos_T fpos; + pos_T *cursor; + colnr_T want_vcol, vcol; + int change_col = -1; + int save_list = curwin->w_p_list; + + /* + * Get the current line. For VREPLACE mode, don't make real changes + * yet, just work on a copy of the line. + */ +#ifdef FEAT_VREPLACE + if (State & VREPLACE_FLAG) + { + pos = curwin->w_cursor; + cursor = &pos; + saved_line = vim_strsave(ml_get_curline()); + if (saved_line == NULL) + return FALSE; + ptr = saved_line + pos.col; + } + else +#endif + { + ptr = ml_get_cursor(); + cursor = &curwin->w_cursor; + } + + /* When 'L' is not in 'cpoptions' a tab always takes up 'ts' spaces. */ + if (vim_strchr(p_cpo, CPO_LISTWM) == NULL) + curwin->w_p_list = FALSE; + + /* Find first white before the cursor */ + fpos = curwin->w_cursor; + while (fpos.col > 0 && vim_iswhite(ptr[-1])) + { + --fpos.col; + --ptr; + } + + /* In Replace mode, don't change characters before the insert point. */ + if ((State & REPLACE_FLAG) + && fpos.lnum == Insstart.lnum + && fpos.col < Insstart.col) + { + ptr += Insstart.col - fpos.col; + fpos.col = Insstart.col; + } + + /* compute virtual column numbers of first white and cursor */ + getvcol(curwin, &fpos, &vcol, NULL, NULL); + getvcol(curwin, cursor, &want_vcol, NULL, NULL); + + /* Use as many TABs as possible. Beware of 'showbreak' and + * 'linebreak' adding extra virtual columns. */ + while (vim_iswhite(*ptr)) + { + i = lbr_chartabsize((char_u *)"\t", vcol); + if (vcol + i > want_vcol) + break; + if (*ptr != TAB) + { + *ptr = TAB; + if (change_col < 0) + { + change_col = fpos.col; /* Column of first change */ + /* May have to adjust Insstart */ + if (fpos.lnum == Insstart.lnum && fpos.col < Insstart.col) + Insstart.col = fpos.col; + } + } + ++fpos.col; + ++ptr; + vcol += i; + } + + if (change_col >= 0) + { + int repl_off = 0; + + /* Skip over the spaces we need. */ + while (vcol < want_vcol && *ptr == ' ') + { + vcol += lbr_chartabsize(ptr, vcol); + ++ptr; + ++repl_off; + } + if (vcol > want_vcol) + { + /* Must have a char with 'showbreak' just before it. */ + --ptr; + --repl_off; + } + fpos.col += repl_off; + + /* Delete following spaces. */ + i = cursor->col - fpos.col; + if (i > 0) + { + mch_memmove(ptr, ptr + i, STRLEN(ptr + i) + 1); + /* correct replace stack. */ + if ((State & REPLACE_FLAG) +#ifdef FEAT_VREPLACE + && !(State & VREPLACE_FLAG) +#endif + ) + for (temp = i; --temp >= 0; ) + replace_join(repl_off); + } + cursor->col -= i; + +#ifdef FEAT_VREPLACE + /* + * In VREPLACE mode, we haven't changed anything yet. Do it now by + * backspacing over the changed spacing and then inserting the new + * spacing. + */ + if (State & VREPLACE_FLAG) + { + /* Backspace from real cursor to change_col */ + backspace_until_column(change_col); + + /* Insert each char in saved_line from changed_col to + * ptr-cursor */ + ins_bytes_len(saved_line + change_col, + cursor->col - change_col); + } +#endif + } + +#ifdef FEAT_VREPLACE + if (State & VREPLACE_FLAG) + vim_free(saved_line); +#endif + curwin->w_p_list = save_list; + } + + return FALSE; +} + +/* + * Handle CR or NL in insert mode. + * Return TRUE when out of memory or can't undo. + */ + static int +ins_eol(c) + int c; +{ + int i; + + if (echeck_abbr(c + ABBR_OFF)) + return FALSE; + if (stop_arrow() == FAIL) + return TRUE; + undisplay_dollar(); + + /* + * Strange Vi behaviour: In Replace mode, typing a NL will not delete the + * character under the cursor. Only push a NUL on the replace stack, + * nothing to put back when the NL is deleted. + */ + if ((State & REPLACE_FLAG) +#ifdef FEAT_VREPLACE + && !(State & VREPLACE_FLAG) +#endif + ) + replace_push(NUL); + + /* + * In VREPLACE mode, a NL replaces the rest of the line, and starts + * replacing the next line, so we push all of the characters left on the + * line onto the replace stack. This is not done here though, it is done + * in open_line(). + */ + +#ifdef FEAT_RIGHTLEFT +# ifdef FEAT_FKMAP + if (p_altkeymap && p_fkmap) + fkmap(NL); +# endif + /* NL in reverse insert will always start in the end of + * current line. */ + if (revins_on) + curwin->w_cursor.col += (colnr_T)STRLEN(ml_get_cursor()); +#endif + + AppendToRedobuff(NL_STR); + i = open_line(FORWARD, +#ifdef FEAT_COMMENTS + has_format_option(FO_RET_COMS) ? OPENLINE_DO_COM : +#endif + 0, old_indent); + old_indent = 0; +#ifdef FEAT_CINDENT + can_cindent = TRUE; +#endif + + return (!i); +} + +#ifdef FEAT_DIGRAPHS +/* + * Handle digraph in insert mode. + * Returns character still to be inserted, or NUL when nothing remaining to be + * done. + */ + static int +ins_digraph() +{ + int c; + int cc; + + pc_status = PC_STATUS_UNSET; + if (redrawing() && !char_avail()) + { + /* may need to redraw when no more chars available now */ + ins_redraw(); + + edit_putchar('?', TRUE); +#ifdef FEAT_CMDL_INFO + add_to_showcmd_c(Ctrl_K); +#endif + } + +#ifdef USE_ON_FLY_SCROLL + dont_scroll = TRUE; /* disallow scrolling here */ +#endif + + /* don't map the digraph chars. This also prevents the + * mode message to be deleted when ESC is hit */ + ++no_mapping; + ++allow_keys; + c = safe_vgetc(); + --no_mapping; + --allow_keys; + if (IS_SPECIAL(c) || mod_mask) /* special key */ + { +#ifdef FEAT_CMDL_INFO + clear_showcmd(); +#endif + insert_special(c, TRUE, FALSE); + return NUL; + } + if (c != ESC) + { + if (redrawing() && !char_avail()) + { + /* may need to redraw when no more chars available now */ + ins_redraw(); + + if (char2cells(c) == 1) + { + /* first remove the '?', otherwise it's restored when typing + * an ESC next */ + edit_unputchar(); + ins_redraw(); + edit_putchar(c, TRUE); + } +#ifdef FEAT_CMDL_INFO + add_to_showcmd_c(c); +#endif + } + ++no_mapping; + ++allow_keys; + cc = safe_vgetc(); + --no_mapping; + --allow_keys; + if (cc != ESC) + { + AppendToRedobuff((char_u *)CTRL_V_STR); + c = getdigraph(c, cc, TRUE); +#ifdef FEAT_CMDL_INFO + clear_showcmd(); +#endif + return c; + } + } + edit_unputchar(); +#ifdef FEAT_CMDL_INFO + clear_showcmd(); +#endif + return NUL; +} +#endif + +/* + * Handle CTRL-E and CTRL-Y in Insert mode: copy char from other line. + * Returns the char to be inserted, or NUL if none found. + */ + static int +ins_copychar(lnum) + linenr_T lnum; +{ + int c; + int temp; + char_u *ptr, *prev_ptr; + + if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count) + { + vim_beep(); + return NUL; + } + + /* try to advance to the cursor column */ + temp = 0; + ptr = ml_get(lnum); + prev_ptr = ptr; + validate_virtcol(); + while ((colnr_T)temp < curwin->w_virtcol && *ptr != NUL) + { + prev_ptr = ptr; + temp += lbr_chartabsize_adv(&ptr, (colnr_T)temp); + } + if ((colnr_T)temp > curwin->w_virtcol) + ptr = prev_ptr; + +#ifdef FEAT_MBYTE + c = (*mb_ptr2char)(ptr); +#else + c = *ptr; +#endif + if (c == NUL) + vim_beep(); + return c; +} + +#ifdef FEAT_SMARTINDENT +/* + * Try to do some very smart auto-indenting. + * Used when inserting a "normal" character. + */ + static void +ins_try_si(c) + int c; +{ + pos_T *pos, old_pos; + char_u *ptr; + int i; + int temp; + + /* + * do some very smart indenting when entering '{' or '}' + */ + if (((did_si || can_si_back) && c == '{') || (can_si && c == '}')) + { + /* + * for '}' set indent equal to indent of line containing matching '{' + */ + if (c == '}' && (pos = findmatch(NULL, '{')) != NULL) + { + old_pos = curwin->w_cursor; + /* + * If the matching '{' has a ')' immediately before it (ignoring + * white-space), then line up with the start of the line + * containing the matching '(' if there is one. This handles the + * case where an "if (..\n..) {" statement continues over multiple + * lines -- webb + */ + ptr = ml_get(pos->lnum); + i = pos->col; + if (i > 0) /* skip blanks before '{' */ + while (--i > 0 && vim_iswhite(ptr[i])) + ; + curwin->w_cursor.lnum = pos->lnum; + curwin->w_cursor.col = i; + if (ptr[i] == ')' && (pos = findmatch(NULL, '(')) != NULL) + curwin->w_cursor = *pos; + i = get_indent(); + curwin->w_cursor = old_pos; +#ifdef FEAT_VREPLACE + if (State & VREPLACE_FLAG) + change_indent(INDENT_SET, i, FALSE, NUL); + else +#endif + (void)set_indent(i, SIN_CHANGED); + } + else if (curwin->w_cursor.col > 0) + { + /* + * when inserting '{' after "O" reduce indent, but not + * more than indent of previous line + */ + temp = TRUE; + if (c == '{' && can_si_back && curwin->w_cursor.lnum > 1) + { + old_pos = curwin->w_cursor; + i = get_indent(); + while (curwin->w_cursor.lnum > 1) + { + ptr = skipwhite(ml_get(--(curwin->w_cursor.lnum))); + + /* ignore empty lines and lines starting with '#'. */ + if (*ptr != '#' && *ptr != NUL) + break; + } + if (get_indent() >= i) + temp = FALSE; + curwin->w_cursor = old_pos; + } + if (temp) + shift_line(TRUE, FALSE, 1); + } + } + + /* + * set indent of '#' always to 0 + */ + if (curwin->w_cursor.col > 0 && can_si && c == '#') + { + /* remember current indent for next line */ + old_indent = get_indent(); + (void)set_indent(0, SIN_CHANGED); + } + + /* Adjust ai_col, the char at this position can be deleted. */ + if (ai_col > curwin->w_cursor.col) + ai_col = curwin->w_cursor.col; +} +#endif + +/* + * Get the value that w_virtcol would have when 'list' is off. + * Unless 'cpo' contains the 'L' flag. + */ + static colnr_T +get_nolist_virtcol() +{ + if (curwin->w_p_list && vim_strchr(p_cpo, CPO_LISTWM) == NULL) + return getvcol_nolist(&curwin->w_cursor); + validate_virtcol(); + return curwin->w_virtcol; +} |