From da51dc9cf202772f60bd2da975dbef257bd9237c Mon Sep 17 00:00:00 2001 From: Eliseo Martínez Date: Mon, 12 May 2014 02:25:17 +0200 Subject: Introduce nvim namespace: Move files. Move files from src/ to src/nvim/. - src/nvim/ becomes the new root dir for nvim executable sources. - src/libnvim/ is planned to become root dir of the neovim library. --- src/nvim/edit.c | 8444 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 8444 insertions(+) create mode 100644 src/nvim/edit.c (limited to 'src/nvim/edit.c') diff --git a/src/nvim/edit.c b/src/nvim/edit.c new file mode 100644 index 0000000000..146a8bba70 --- /dev/null +++ b/src/nvim/edit.c @@ -0,0 +1,8444 @@ +/* + * 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 + +#include "vim.h" +#include "edit.h" +#include "buffer.h" +#include "charset.h" +#include "digraph.h" +#include "eval.h" +#include "ex_docmd.h" +#include "ex_getln.h" +#include "farsi.h" +#include "fileio.h" +#include "fold.h" +#include "getchar.h" +#include "indent.h" +#include "indent_c.h" +#include "main.h" +#include "mbyte.h" +#include "memline.h" +#include "memory.h" +#include "message.h" +#include "misc1.h" +#include "misc2.h" +#include "keymap.h" +#include "move.h" +#include "normal.h" +#include "ops.h" +#include "option.h" +#include "path.h" +#include "popupmnu.h" +#include "quickfix.h" +#include "regexp.h" +#include "screen.h" +#include "search.h" +#include "spell.h" +#include "syntax.h" +#include "tag.h" +#include "term.h" +#include "ui.h" +#include "undo.h" +#include "window.h" +#include "os/event.h" + +/* + * definitions used for CTRL-X submode + */ +#define CTRL_X_WANT_IDENT 0x100 + +#define CTRL_X_NOT_DEFINED_YET 1 +#define CTRL_X_SCROLL 2 +#define CTRL_X_WHOLE_LINE 3 +#define CTRL_X_FILES 4 +#define CTRL_X_TAGS (5 + CTRL_X_WANT_IDENT) +#define CTRL_X_PATH_PATTERNS (6 + CTRL_X_WANT_IDENT) +#define CTRL_X_PATH_DEFINES (7 + CTRL_X_WANT_IDENT) +#define CTRL_X_FINISHED 8 +#define CTRL_X_DICTIONARY (9 + CTRL_X_WANT_IDENT) +#define CTRL_X_THESAURUS (10 + CTRL_X_WANT_IDENT) +#define CTRL_X_CMDLINE 11 +#define CTRL_X_FUNCTION 12 +#define CTRL_X_OMNI 13 +#define CTRL_X_SPELL 14 +#define CTRL_X_LOCAL_MSG 15 /* only used in "ctrl_x_msgs" */ + +#define CTRL_X_MSG(i) ctrl_x_msgs[(i) & ~CTRL_X_WANT_IDENT] + +static char *ctrl_x_msgs[] = +{ + N_(" Keyword completion (^N^P)"), /* ctrl_x_mode == 0, ^P/^N compl. */ + N_(" ^X mode (^]^D^E^F^I^K^L^N^O^Ps^U^V^Y)"), + NULL, + N_(" Whole line completion (^L^N^P)"), + N_(" File name completion (^F^N^P)"), + N_(" Tag completion (^]^N^P)"), + N_(" Path pattern completion (^N^P)"), + N_(" Definition completion (^D^N^P)"), + NULL, + N_(" Dictionary completion (^K^N^P)"), + N_(" Thesaurus completion (^T^N^P)"), + N_(" Command-line completion (^V^N^P)"), + N_(" User defined completion (^U^N^P)"), + N_(" Omni completion (^O^N^P)"), + N_(" Spelling suggestion (s^N^P)"), + N_(" Keyword Local completion (^N^P)"), +}; + +static char e_hitend[] = N_("Hit end of paragraph"); +static char e_complwin[] = N_("E839: Completion function changed window"); +static char e_compldel[] = N_("E840: Completion function deleted text"); + +/* + * Structure used to store one match for insert completion. + */ +typedef struct compl_S compl_T; +struct compl_S { + compl_T *cp_next; + compl_T *cp_prev; + char_u *cp_str; /* matched text */ + char cp_icase; /* TRUE or FALSE: ignore case */ + char_u *(cp_text[CPT_COUNT]); /* text for the menu */ + char_u *cp_fname; /* file containing the match, allocated when + * cp_flags has FREE_FNAME */ + int cp_flags; /* ORIGINAL_TEXT, CONT_S_IPOS or FREE_FNAME */ + int cp_number; /* sequence number */ +}; + +#define ORIGINAL_TEXT (1) /* the original text when the expansion begun */ +#define FREE_FNAME (2) + +/* + * All the current matches are stored in a list. + * "compl_first_match" points to the start of the list. + * "compl_curr_match" points to the currently selected entry. + * "compl_shown_match" is different from compl_curr_match during + * ins_compl_get_exp(). + */ +static compl_T *compl_first_match = NULL; +static compl_T *compl_curr_match = NULL; +static compl_T *compl_shown_match = NULL; + +/* After using a cursor key selects a match in the popup menu, + * otherwise it inserts a line break. */ +static int compl_enter_selects = FALSE; + +/* When "compl_leader" is not NULL only matches that start with this string + * are used. */ +static char_u *compl_leader = NULL; + +static int compl_get_longest = FALSE; /* put longest common string + in compl_leader */ + +static int compl_used_match; /* Selected one of the matches. When + FALSE the match was edited or using + the longest common string. */ + +static int compl_was_interrupted = FALSE; /* didn't finish finding + completions. */ + +static int compl_restarting = FALSE; /* don't insert match */ + +/* When the first completion is done "compl_started" is set. When it's + * FALSE the word to be completed must be located. */ +static int compl_started = FALSE; + +/* Set when doing something for completion that may call edit() recursively, + * which is not allowed. */ +static int compl_busy = FALSE; + +static int compl_matches = 0; +static char_u *compl_pattern = NULL; +static int compl_direction = FORWARD; +static int compl_shows_dir = FORWARD; +static int compl_pending = 0; /* > 1 for postponed CTRL-N */ +static pos_T compl_startpos; +static colnr_T compl_col = 0; /* column where the text starts + * that is being completed */ +static char_u *compl_orig_text = NULL; /* text as it was before + * completion started */ +static int compl_cont_mode = 0; +static expand_T compl_xp; + +static int compl_opt_refresh_always = FALSE; + +static void ins_ctrl_x(void); +static int has_compl_option(int dict_opt); +static int ins_compl_accept_char(int c); +static int ins_compl_add(char_u *str, int len, int icase, char_u *fname, + char_u **cptext, int cdir, int flags, + int adup); +static int ins_compl_equal(compl_T *match, char_u *str, int len); +static void ins_compl_longest_match(compl_T *match); +static void ins_compl_add_matches(int num_matches, char_u **matches, + int icase); +static int ins_compl_make_cyclic(void); +static void ins_compl_upd_pum(void); +static void ins_compl_del_pum(void); +static int pum_wanted(void); +static int pum_enough_matches(void); +static void ins_compl_dictionaries(char_u *dict, char_u *pat, int flags, + int thesaurus); +static void ins_compl_files(int count, char_u **files, int thesaurus, + int flags, regmatch_T *regmatch, char_u * + buf, + int *dir); +static char_u *find_line_end(char_u *ptr); +static void ins_compl_free(void); +static void ins_compl_clear(void); +static int ins_compl_bs(void); +static int ins_compl_need_restart(void); +static void ins_compl_new_leader(void); +static void ins_compl_addleader(int c); +static int ins_compl_len(void); +static void ins_compl_restart(void); +static void ins_compl_set_original_text(char_u *str); +static void ins_compl_addfrommatch(void); +static int ins_compl_prep(int c); +static void ins_compl_fixRedoBufForLeader(char_u *ptr_arg); +static buf_T *ins_compl_next_buf(buf_T *buf, int flag); +static void ins_compl_add_list(list_T *list); +static void ins_compl_add_dict(dict_T *dict); +static int ins_compl_get_exp(pos_T *ini); +static void ins_compl_delete(void); +static void ins_compl_insert(void); +static int ins_compl_next(int allow_get_expansion, int count, + int insert_match); +static int ins_compl_key2dir(int c); +static int ins_compl_pum_key(int c); +static int ins_compl_key2count(int c); +static int ins_compl_use_match(int c); +static int ins_complete(int c); +static unsigned quote_meta(char_u *dest, char_u *str, int len); + +#define BACKSPACE_CHAR 1 +#define BACKSPACE_WORD 2 +#define BACKSPACE_WORD_NOT_SPACE 3 +#define BACKSPACE_LINE 4 + +static void ins_redraw(int ready); +static void ins_ctrl_v(void); +static void undisplay_dollar(void); +static void insert_special(int, int, int); +static void internal_format(int textwidth, int second_indent, int flags, + int format_only, + int c); +static void check_auto_format(int); +static void redo_literal(int c); +static void start_arrow(pos_T *end_insert_pos); +static void check_spell_redraw(void); +static void spell_back_to_badword(void); +static int spell_bad_len = 0; /* length of located bad word */ +static void stop_insert(pos_T *end_insert_pos, int esc, int nomove); +static int echeck_abbr(int); +static int replace_pop(void); +static void replace_join(int off); +static void replace_pop_ins(void); +static void mb_replace_pop_ins(int cc); +static void replace_flush(void); +static void replace_do_bs(int limit_col); +static int del_char_after_col(int limit_col); +static int cindent_on(void); +static void ins_reg(void); +static void ins_ctrl_g(void); +static void ins_ctrl_hat(void); +static int ins_esc(long *count, int cmdchar, int nomove); +static void ins_ctrl_(void); +static int ins_start_select(int c); +static void ins_insert(int replaceState); +static void ins_ctrl_o(void); +static void ins_shift(int c, int lastc); +static void ins_del(void); +static int ins_bs(int c, int mode, int *inserted_space_p); +static void ins_mouse(int c); +static void ins_mousescroll(int dir); +static void ins_left(void); +static void ins_home(int c); +static void ins_end(int c); +static void ins_s_left(void); +static void ins_right(void); +static void ins_s_right(void); +static void ins_up(int startcol); +static void ins_pageup(void); +static void ins_down(int startcol); +static void ins_pagedown(void); +static int ins_tab(void); +static int ins_eol(int c); +static int ins_digraph(void); +static int ins_ctrl_ey(int tc); +static void ins_try_si(int c); +static colnr_T get_nolist_virtcol(void); +static char_u *do_insert_char_pre(int c); + +static colnr_T Insstart_textlen; /* length of line when insert started */ +static colnr_T Insstart_blank_vcol; /* vcol for first inserted blank */ +static bool update_Insstart_orig = true; /* set Insstart_orig to Insstart */ + +static char_u *last_insert = NULL; /* the text of the previous insert, + K_SPECIAL and CSI are escaped */ +static int last_insert_skip; /* nr of chars in front of previous insert */ +static int new_insert_skip; /* nr of chars in front of current insert */ +static int did_restart_edit; /* "restart_edit" when calling edit() */ + +static int can_cindent; /* may do cindenting on this line */ + +static int old_indent = 0; /* for ^^D command in insert mode */ + +static int revins_on; /* reverse insert mode on */ +static int revins_chars; /* how much to skip after edit */ +static int revins_legal; /* was the last char 'legal'? */ +static int revins_scol; /* start column of revins session */ + +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" command: insert one . Note: count can be > 1, for redo, + * but still only one is inserted. The 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 ( + int cmdchar, + int startln, /* if set, insert at start of line */ + long count +) +{ + int c = 0; + char_u *ptr; + int lastc; + int mincol; + static linenr_T o_lnum = 0; + int i; + int did_backspace = TRUE; /* previous char was backspace */ + int line_is_white = FALSE; /* line is empty before insert */ + linenr_T old_topline = 0; /* topline before insertion */ + int old_topfill = -1; + int inserted_space = FALSE; /* just inserted a space */ + int replaceState = REPLACE; + int nomove = FALSE; /* don't move cursor on return */ + + /* Remember whether editing was restarted after CTRL-O. */ + did_restart_edit = restart_edit; + + /* sleep before redrawing, needed for "CTRL-O :" that results in an + * error message */ + check_for_delay(TRUE); + + // set Insstart_orig to Insstart + update_Insstart_orig = true; + +#ifdef HAVE_SANDBOX + /* Don't allow inserting in the sandbox. */ + if (sandbox != 0) { + EMSG(_(e_sandbox)); + return FALSE; + } +#endif + /* Don't allow changes in the buffer while editing the cmdline. The + * caller of getcmdline() may get confused. */ + if (textlock != 0) { + EMSG(_(e_secure)); + return FALSE; + } + + /* Don't allow recursive insert mode when busy with completion. */ + if (compl_started || compl_busy || pum_visible()) { + EMSG(_(e_secure)); + return FALSE; + } + ins_compl_clear(); /* clear stuff for CTRL-X mode */ + + /* + * Trigger InsertEnter autocommands. Do not do this for "r" or "grx". + */ + if (cmdchar != 'r' && cmdchar != 'v') { + pos_T save_cursor = curwin->w_cursor; + + if (cmdchar == 'R') + ptr = (char_u *)"r"; + else if (cmdchar == 'V') + ptr = (char_u *)"v"; + else + ptr = (char_u *)"i"; + set_vim_var_string(VV_INSERTMODE, ptr, 1); + set_vim_var_string(VV_CHAR, NULL, -1); /* clear v:char */ + apply_autocmds(EVENT_INSERTENTER, NULL, NULL, FALSE, curbuf); + + /* Make sure the cursor didn't move. Do call check_cursor_col() in + * case the text was modified. Since Insert mode was not started yet + * a call to check_cursor_col() may move the cursor, especially with + * the "A" command, thus set State to avoid that. Also check that the + * line number is still valid (lines may have been deleted). + * Do not restore if v:char was set to a non-empty string. */ + if (!equalpos(curwin->w_cursor, save_cursor) + && *get_vim_var_str(VV_CHAR) == NUL + && save_cursor.lnum <= curbuf->b_ml.ml_line_count) { + int save_state = State; + + curwin->w_cursor = save_cursor; + State = INSERT; + check_cursor_col(); + State = save_state; + } + } + + /* Check if the cursor line needs redrawing before changing State. If + * 'concealcursor' is "n" it needs to be redrawn without concealing. */ + conceal_check_cursur_line(); + + /* + * 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 { + Insstart = curwin->w_cursor; + if (startln) + Insstart.col = 0; + } + Insstart_textlen = (colnr_T)linetabsize(ml_get_curline()); + Insstart_blank_vcol = MAXCOL; + if (!did_ai) + ai_col = 0; + + if (cmdchar != NUL && restart_edit == 0) { + ResetRedobuff(); + AppendNumberToRedobuff(count); + if (cmdchar == 'V' || cmdchar == 'v') { + /* "gR" or "gr" command */ + AppendCharToRedobuff('g'); + AppendCharToRedobuff((cmdchar == 'v') ? 'r' : 'R'); + } else { + AppendCharToRedobuff(cmdchar); + if (cmdchar == 'g') /* "gI" command */ + AppendCharToRedobuff('I'); + else if (cmdchar == 'r') /* "r" command */ + count = 1; /* insert only one */ + } + } + + if (cmdchar == 'R') { + if (p_fkmap && p_ri) { + beep_flush(); + EMSG(farsi_text_3); /* encoded in Farsi */ + State = INSERT; + } else + State = REPLACE; + } else if (cmdchar == 'V' || cmdchar == 'v') { + State = VREPLACE; + replaceState = VREPLACE; + orig_line_count = curbuf->b_ml.ml_line_count; + vr_lines_changed = 1; + } 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 . + */ + 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 + + setmouse(); + clear_showcmd(); + /* 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; + + /* + * 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()) { + /* + * 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 + arrow_used = TRUE; + restart_edit = 0; + + /* + * If the cursor was after the end-of-line before the CTRL-O and it is + * now at the end-of-line, put it after the end-of-line (this is not + * correct in very rare cases). + * Also do this if curswant is greater than the current virtual + * column. Eg after "^O$" or "^O80|". + */ + validate_virtcol(); + update_curswant(); + if (((ins_at_eol && curwin->w_cursor.lnum == o_lnum) + || curwin->w_curswant > curwin->w_virtcol) + && *(ptr = ml_get_curline() + curwin->w_cursor.col) != NUL) { + if (ptr[1] == NUL) + ++curwin->w_cursor.col; + else if (has_mbyte) { + i = (*mb_ptr2len)(ptr); + if (ptr[i] == NUL) + curwin->w_cursor.col += i; + } + } + ins_at_eol = FALSE; + } else + arrow_used = FALSE; + + /* we are in insert mode now, don't need to start it anymore */ + need_start_insertmode = FALSE; + + /* Need to save the line for undo before inserting the first char. */ + ins_need_undo = TRUE; + + where_paste_started.lnum = 0; + can_cindent = TRUE; + /* The cursor line is not in a closed fold, unless 'insertmode' is set or + * restarting. */ + if (!p_im && did_restart_edit == 0) + foldOpenCursor(); + + /* + * If 'showmode' is set, show the current (insert/replace/..) mode. + * A warning message for changing a readonly file is given here, before + * actually changing anything. It's put after the mode, if any. + */ + i = 0; + if (p_smd && msg_silent == 0) + i = showmode(); + + if (!p_im && did_restart_edit == 0) + change_warning(i == 0 ? 0 : i + 1); + + ui_cursor_shape(); /* may show different cursor shape */ + do_digraph(-1); /* clear digraphs */ + + /* + * 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); + free(ptr); + } + + old_indent = 0; + + /* + * Main loop in Insert mode: repeat until Insert mode is left. + */ + for (;; ) { + if (!revins_legal) + revins_scol = -1; /* reset on illegal motions */ + else + revins_legal = 0; + if (arrow_used) /* don't repeat insert when arrow key used */ + count = 0; + + if (update_Insstart_orig) { + Insstart_orig = Insstart; + } + + 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; + + + /* 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(); + + /* + * 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 + && curwin->w_topfill == old_topfill + ) { + mincol = curwin->w_wcol; + validate_cursor_col(); + + if ((int)curwin->w_wcol < mincol - curbuf->b_p_ts + && curwin->w_wrow == W_WINROW(curwin) + + curwin->w_height - 1 - p_so + && (curwin->w_cursor.lnum != curwin->w_topline + || curwin->w_topfill > 0 + )) { + if (curwin->w_topfill > 0) + --curwin->w_topfill; + else if (hasFolding(curwin->w_topline, NULL, &old_topline)) + set_topline(curwin, old_topline + 1); + else + set_topline(curwin, curwin->w_topline + 1); + } + } + + /* May need to adjust w_topline to show the cursor. */ + update_topline(); + + did_backspace = FALSE; + + validate_cursor(); /* may set must_redraw */ + + /* + * Redraw the display when no characters are waiting. + * Also shows mode, ruler and positions cursor. + */ + ins_redraw(TRUE); + + if (curwin->w_p_scb) + do_check_scrollbind(TRUE); + + if (curwin->w_p_crb) + do_check_cursorbind(); + update_curswant(); + old_topline = curwin->w_topline; + old_topfill = curwin->w_topfill; + +#ifdef USE_ON_FLY_SCROLL + dont_scroll = FALSE; /* allow scrolling here */ +#endif + + /* + * Get a character for Insert mode. Ignore K_IGNORE. + */ + lastc = c; /* remember previous char for CTRL-D */ + do { + c = safe_vgetc(); + } while (c == K_IGNORE); + + /* Don't want K_CURSORHOLD for the second key, e.g., after CTRL-V. */ + did_cursorhold = TRUE; + + if (p_hkmap && KeyTyped) + c = hkmap(c); /* Hebrew mode mapping */ + if (p_fkmap && KeyTyped) + c = fkmap(c); /* Farsi mode mapping */ + + /* + * Special handling of keys while the popup menu is visible or wanted + * and the cursor is still in the completed word. Only when there is + * a match, skip this when no matches were found. + */ + if (compl_started + && pum_wanted() + && curwin->w_cursor.col >= compl_col + && (compl_shown_match == NULL + || compl_shown_match != compl_shown_match->cp_next)) { + /* BS: Delete one character from "compl_leader". */ + if ((c == K_BS || c == Ctrl_H) + && curwin->w_cursor.col > compl_col + && (c = ins_compl_bs()) == NUL) + continue; + + /* When no match was selected or it was edited. */ + if (!compl_used_match) { + /* CTRL-L: Add one character from the current match to + * "compl_leader". Except when at the original match and + * there is nothing to add, CTRL-L works like CTRL-P then. */ + if (c == Ctrl_L + && (ctrl_x_mode != CTRL_X_WHOLE_LINE + || (int)STRLEN(compl_shown_match->cp_str) + > curwin->w_cursor.col - compl_col)) { + ins_compl_addfrommatch(); + continue; + } + + /* A non-white character that fits in with the current + * completion: Add to "compl_leader". */ + if (ins_compl_accept_char(c)) { + /* Trigger InsertCharPre. */ + char_u *str = do_insert_char_pre(c); + char_u *p; + + if (str != NULL) { + for (p = str; *p != NUL; mb_ptr_adv(p)) + ins_compl_addleader(PTR2CHAR(p)); + free(str); + } else + ins_compl_addleader(c); + continue; + } + + /* Pressing CTRL-Y selects the current match. When + * compl_enter_selects is set the Enter key does the same. */ + if (c == Ctrl_Y || (compl_enter_selects + && (c == CAR || c == K_KENTER || c == NL))) { + ins_compl_delete(); + ins_compl_insert(); + } + } + } + + /* Prepare for or stop CTRL-X mode. This doesn't do completion, but + * it does fix up the text when finishing completion. */ + compl_get_longest = FALSE; + if (ins_compl_prep(c)) + continue; + + /* CTRL-\ CTRL-N goes to Normal mode, + * CTRL-\ CTRL-G goes to mode selected with 'insertmode', + * CTRL-\ CTRL-O is like CTRL-O but without moving the cursor. */ + if (c == Ctrl_BSL) { + /* may need to redraw when no more chars available now */ + ins_redraw(FALSE); + ++no_mapping; + ++allow_keys; + c = plain_vgetc(); + --no_mapping; + --allow_keys; + if (c != Ctrl_N && c != Ctrl_G && c != Ctrl_O) { + /* it's something else */ + vungetc(c); + c = Ctrl_BSL; + } else if (c == Ctrl_G && p_im) + continue; + else { + if (c == Ctrl_O) { + ins_ctrl_o(); + ins_at_eol = FALSE; /* cursor keeps its column */ + nomove = TRUE; + } + count = 0; + goto doESCkey; + } + } + + c = do_digraph(c); + + if ((c == Ctrl_V || c == Ctrl_Q) && ctrl_x_mode == CTRL_X_CMDLINE) + goto docomplete; + if (c == Ctrl_V || c == Ctrl_Q) { + ins_ctrl_v(); + c = Ctrl_V; /* pretend CTRL-V is last typed character */ + continue; + } + + if (cindent_on() + && ctrl_x_mode == 0 + ) { + /* 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(); + } + + 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; + } + + /* + * 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; + + /* + * The big switch to handle a character in insert mode. + */ + switch (c) { + case ESC: /* End input mode */ + if (echeck_abbr(ESC + ABBR_OFF)) + break; + /*FALLTHROUGH*/ + + case Ctrl_C: /* End input mode */ + if (c == Ctrl_C && cmdwin_type != 0) { + /* Close the cmdline window. */ + cmdwin_result = K_IGNORE; + got_int = FALSE; /* don't stop executing autocommands et al. */ + nomove = TRUE; + goto doESCkey; + } + +#ifdef UNIX +do_intr: +#endif + /* when 'insertmode' set, and not halfway a mapping, don't leave + * Insert mode */ + if (goto_im()) { + if (got_int) { + (void)vgetc(); /* flush all buffers */ + got_int = FALSE; + } else + vim_beep(); + break; + } +doESCkey: + /* + * This is the ONLY return from edit()! + */ + /* Always update o_lnum, so that a "CTRL-O ." that adds a line + * still puts the cursor back after the inserted text. */ + if (ins_at_eol && gchar_cursor() == NUL) + o_lnum = curwin->w_cursor.lnum; + + if (ins_esc(&count, cmdchar, nomove)) { + if (cmdchar != 'r' && cmdchar != 'v') + apply_autocmds(EVENT_INSERTLEAVE, NULL, NULL, + FALSE, curbuf); + did_cursorhold = FALSE; + return c == Ctrl_O; + } + continue; + + case Ctrl_Z: /* suspend when 'insertmode' set */ + if (!p_im) + goto normalchar; /* insert CTRL-Z as normal char */ + stuffReadbuff((char_u *)":st\r"); + c = Ctrl_O; + /*FALLTHROUGH*/ + + case Ctrl_O: /* execute one command */ + if (ctrl_x_mode == CTRL_X_OMNI) + goto docomplete; + if (echeck_abbr(Ctrl_O + ABBR_OFF)) + break; + ins_ctrl_o(); + + /* don't move the cursor left when 'virtualedit' has "onemore". */ + if (ve_flags & VE_ONEMORE) { + ins_at_eol = FALSE; + nomove = TRUE; + } + count = 0; + goto doESCkey; + + case K_INS: /* toggle insert/replace mode */ + case K_KINS: + ins_insert(replaceState); + break; + + case K_SELECT: /* end of Select mode mapping - ignore */ + break; + + + case K_HELP: /* Help key works like */ + case K_F1: + case K_XF1: + stuffcharReadbuff(K_HELP); + if (p_im) + need_start_insertmode = TRUE; + goto doESCkey; + + + case K_ZERO: /* Insert the previously inserted text. */ + case NUL: + case Ctrl_A: + /* For ^@ the trailing ESC will end the insert, unless there is an + * error. */ + if (stuff_inserted(NUL, 1L, (c == Ctrl_A)) == FAIL + && c != Ctrl_A && !p_im) + goto doESCkey; /* quit insert mode */ + inserted_space = FALSE; + break; + + case Ctrl_R: /* insert the contents of a register */ + ins_reg(); + auto_format(FALSE, TRUE); + inserted_space = FALSE; + break; + + case Ctrl_G: /* commands starting with CTRL-G */ + ins_ctrl_g(); + break; + + case Ctrl_HAT: /* switch input mode and/or langmap */ + ins_ctrl_hat(); + break; + + case Ctrl__: /* switch between languages */ + if (!p_ari) + goto normalchar; + ins_ctrl_(); + break; + + case Ctrl_D: /* Make indent one shiftwidth smaller. */ + if (ctrl_x_mode == CTRL_X_PATH_DEFINES) + goto docomplete; + /* FALLTHROUGH */ + + case Ctrl_T: /* Make indent one shiftwidth greater. */ + if (c == Ctrl_T && ctrl_x_mode == CTRL_X_THESAURUS) { + if (has_compl_option(FALSE)) + goto docomplete; + break; + } + ins_shift(c, lastc); + auto_format(FALSE, TRUE); + inserted_space = FALSE; + break; + + case K_DEL: /* delete character under the cursor */ + case K_KDEL: + ins_del(); + auto_format(FALSE, TRUE); + break; + + case K_BS: /* delete character before the cursor */ + case Ctrl_H: + did_backspace = ins_bs(c, BACKSPACE_CHAR, &inserted_space); + auto_format(FALSE, TRUE); + break; + + case Ctrl_W: /* delete word before the cursor */ + did_backspace = ins_bs(c, BACKSPACE_WORD, &inserted_space); + auto_format(FALSE, TRUE); + break; + + case Ctrl_U: /* delete all inserted text in current line */ + /* CTRL-X CTRL-U completes with 'completefunc'. */ + if (ctrl_x_mode == CTRL_X_FUNCTION) + goto docomplete; + did_backspace = ins_bs(c, BACKSPACE_LINE, &inserted_space); + auto_format(FALSE, TRUE); + inserted_space = FALSE; + break; + + case K_LEFTMOUSE: /* mouse keys */ + 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; + + case K_MOUSEDOWN: /* Default action for scroll wheel up: scroll up */ + ins_mousescroll(MSCR_DOWN); + break; + + case K_MOUSEUP: /* Default action for scroll wheel down: scroll down */ + ins_mousescroll(MSCR_UP); + break; + + case K_MOUSELEFT: /* Scroll wheel left */ + ins_mousescroll(MSCR_LEFT); + break; + + case K_MOUSERIGHT: /* Scroll wheel right */ + ins_mousescroll(MSCR_RIGHT); + break; + + case K_IGNORE: /* Something mapped to nothing */ + break; + + case K_CURSORHOLD: /* Didn't type something for a while. */ + apply_autocmds(EVENT_CURSORHOLDI, NULL, NULL, FALSE, curbuf); + did_cursorhold = TRUE; + break; + + case K_EVENT: + event_process(); + break; + + case K_HOME: /* */ + case K_KHOME: + case K_S_HOME: + case K_C_HOME: + ins_home(c); + break; + + case K_END: /* */ + case K_KEND: + case K_S_END: + case K_C_END: + ins_end(c); + break; + + case K_LEFT: /* */ + if (mod_mask & (MOD_MASK_SHIFT|MOD_MASK_CTRL)) + ins_s_left(); + else + ins_left(); + break; + + case K_S_LEFT: /* */ + case K_C_LEFT: + ins_s_left(); + break; + + case K_RIGHT: /* */ + if (mod_mask & (MOD_MASK_SHIFT|MOD_MASK_CTRL)) + ins_s_right(); + else + ins_right(); + break; + + case K_S_RIGHT: /* */ + case K_C_RIGHT: + ins_s_right(); + break; + + case K_UP: /* */ + if (pum_visible()) + goto docomplete; + if (mod_mask & MOD_MASK_SHIFT) + ins_pageup(); + else + ins_up(FALSE); + break; + + case K_S_UP: /* */ + case K_PAGEUP: + case K_KPAGEUP: + if (pum_visible()) + goto docomplete; + ins_pageup(); + break; + + case K_DOWN: /* */ + if (pum_visible()) + goto docomplete; + if (mod_mask & MOD_MASK_SHIFT) + ins_pagedown(); + else + ins_down(FALSE); + break; + + case K_S_DOWN: /* */ + case K_PAGEDOWN: + case K_KPAGEDOWN: + if (pum_visible()) + goto docomplete; + ins_pagedown(); + break; + + + case K_S_TAB: /* When not mapped, use like a normal TAB */ + c = TAB; + /* FALLTHROUGH */ + + case TAB: /* TAB or Complete patterns along path */ + if (ctrl_x_mode == CTRL_X_PATH_PATTERNS) + goto docomplete; + 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: + /* In a quickfix window a jumps to the error under the + * cursor. */ + if (bt_quickfix(curbuf) && c == CAR) { + if (curwin->w_llist_ref == NULL) /* quickfix window */ + do_cmdline_cmd((char_u *)".cc"); + else /* location list window */ + do_cmdline_cmd((char_u *)".ll"); + break; + } + if (cmdwin_type != 0) { + /* Execute the command in the cmdline window. */ + cmdwin_result = CAR; + goto doESCkey; + } + if (ins_eol(c) && !p_im) + goto doESCkey; /* out of memory */ + auto_format(FALSE, FALSE); + inserted_space = FALSE; + break; + + case Ctrl_K: /* digraph or keyword completion */ + if (ctrl_x_mode == CTRL_X_DICTIONARY) { + if (has_compl_option(TRUE)) + goto docomplete; + break; + } + c = ins_digraph(); + if (c == NUL) + break; + goto normalchar; + + case Ctrl_X: /* Enter CTRL-X mode */ + ins_ctrl_x(); + break; + + 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; + + case 's': /* Spelling completion after ^X */ + case Ctrl_S: + if (ctrl_x_mode != CTRL_X_SPELL) + goto normalchar; + goto docomplete; + + case Ctrl_L: /* Whole line completion after ^X */ + if (ctrl_x_mode != CTRL_X_WHOLE_LINE) { + /* CTRL-L with 'insertmode' set: Leave Insert mode */ + if (p_im) { + if (echeck_abbr(Ctrl_L + ABBR_OFF)) + break; + goto doESCkey; + } + goto normalchar; + } + /* FALLTHROUGH */ + + case Ctrl_P: /* Do previous/next pattern completion */ + 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 + && !(compl_cont_status & CONT_LOCAL)) + goto normalchar; + +docomplete: + compl_busy = TRUE; + if (ins_complete(c) == FAIL) + compl_cont_status = 0; + compl_busy = FALSE; + break; + + case Ctrl_Y: /* copy from previous line or scroll down */ + case Ctrl_E: /* copy from next line or scroll up */ + c = ins_ctrl_ey(c); + break; + + default: +#ifdef UNIX + if (c == intr_char) /* special interrupt char */ + goto do_intr; +#endif + +normalchar: + /* + * Insert a normal character. + */ + if (!p_paste) { + /* Trigger InsertCharPre. */ + char_u *str = do_insert_char_pre(c); + char_u *p; + + if (str != NULL) { + if (*str != NUL && stop_arrow() != FAIL) { + /* Insert the new value of v:char literally. */ + for (p = str; *p != NUL; mb_ptr_adv(p)) { + c = PTR2CHAR(p); + if (c == CAR || c == K_KENTER || c == NL) + ins_eol(c); + else + ins_char(c); + } + AppendToRedobuffLit(str, -1); + } + free(str); + c = NUL; + } + + /* If the new value is already inserted or an empty string + * then don't insert any character. */ + if (c == NUL) + break; + } + /* Try to perform smart-indenting. */ + ins_try_si(c); + + if (c == ' ') { + inserted_space = TRUE; + if (inindent(0)) + can_cindent = FALSE; + if (Insstart_blank_vcol == MAXCOL + && curwin->w_cursor.lnum == Insstart.lnum) + Insstart_blank_vcol = get_nolist_virtcol(); + } + + /* Insert a normal character and check for abbreviations on a + * special character. Let CTRL-] expand abbreviations without + * inserting it. */ + if (vim_iswordc(c) || (!echeck_abbr( + /* Add ABBR_OFF for characters above 0x100, this is + * what check_abbr() expects. */ + (has_mbyte && c >= 0x100) ? (c + ABBR_OFF) : + c) && c != Ctrl_RSB)) { + insert_special(c, FALSE, FALSE); + revins_legal++; + revins_chars++; + } + + auto_format(FALSE, TRUE); + + /* When inserting a character the cursor line must never be in a + * closed fold. */ + foldOpenCursor(); + break; + } /* end of switch (c) */ + + /* If typed something may trigger CursorHoldI again. */ + if (c != K_CURSORHOLD) + did_cursorhold = FALSE; + + /* If the cursor was moved we didn't just insert a space */ + if (arrow_used) + inserted_space = FALSE; + + if (can_cindent && cindent_on() + && ctrl_x_mode == 0 + ) { +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(); + } + } + + } /* 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 ( + int ready /* not busy with something */ +) +{ + linenr_T conceal_old_cursor_line = 0; + linenr_T conceal_new_cursor_line = 0; + int conceal_update_lines = FALSE; + + if (char_avail()) + return; + + /* Trigger CursorMoved if the cursor moved. Not when the popup menu is + * visible, the command might delete it. */ + if (ready && ( + has_cursormovedI() + || + curwin->w_p_cole > 0 + ) + && !equalpos(last_cursormoved, curwin->w_cursor) + && !pum_visible() + ) { + /* Need to update the screen first, to make sure syntax + * highlighting is correct after making a change (e.g., inserting + * a "(". The autocommand may also require a redraw, so it's done + * again below, unfortunately. */ + if (syntax_present(curwin) && must_redraw) + update_screen(0); + if (has_cursormovedI()) + apply_autocmds(EVENT_CURSORMOVEDI, NULL, NULL, FALSE, curbuf); + if (curwin->w_p_cole > 0) { + conceal_old_cursor_line = last_cursormoved.lnum; + conceal_new_cursor_line = curwin->w_cursor.lnum; + conceal_update_lines = TRUE; + } + last_cursormoved = curwin->w_cursor; + } + + /* Trigger TextChangedI if b_changedtick differs. */ + if (ready && has_textchangedI() + && last_changedtick != curbuf->b_changedtick + && !pum_visible() + ) { + if (last_changedtick_buf == curbuf) + apply_autocmds(EVENT_TEXTCHANGEDI, NULL, NULL, FALSE, curbuf); + last_changedtick_buf = curbuf; + last_changedtick = curbuf->b_changedtick; + } + + if (must_redraw) + update_screen(0); + else if (clear_cmdline || redraw_cmdline) + showmode(); /* clear cmdline and show mode */ + if ((conceal_update_lines + && (conceal_old_cursor_line != conceal_new_cursor_line + || conceal_cursor_line(curwin))) + || need_cursor_line_redraw) { + if (conceal_old_cursor_line != conceal_new_cursor_line) + update_single_line(curwin, conceal_old_cursor_line); + update_single_line(curwin, conceal_new_cursor_line == 0 + ? curwin->w_cursor.lnum : conceal_new_cursor_line); + curwin->w_valid &= ~VALID_CROW; + } + 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(void) +{ + int c; + int did_putchar = FALSE; + + /* may need to redraw when no more chars available now */ + ins_redraw(FALSE); + + if (redrawing() && !char_avail()) { + edit_putchar('^', TRUE); + did_putchar = TRUE; + } + AppendToRedobuff((char_u *)CTRL_V_STR); /* CTRL-V */ + + add_to_showcmd_c(Ctrl_V); + + c = get_literal(); + if (did_putchar) + /* when the line fits in 'columns' the '^' is at the start of the next + * line and will not removed by the redraw */ + edit_unputchar(); + clear_showcmd(); + insert_special(c, FALSE, TRUE); + revins_chars++; + revins_legal++; +} + +/* + * 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 */ +static char_u pc_bytes[MB_MAXBYTES + 1]; /* saved bytes */ +static int pc_attr; +static int pc_row; +static int pc_col; + +void edit_putchar(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); + pc_status = PC_STATUS_UNSET; + if (curwin->w_p_rl) { + pc_col += W_WIDTH(curwin) - 1 - curwin->w_wcol; + 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; + } + } + } else { + pc_col += curwin->w_wcol; + if (mb_lefthalve(pc_row, pc_col)) + pc_status = PC_STATUS_LEFT; + } + + /* save the character to be able to put it back */ + if (pc_status == PC_STATUS_UNSET) { + 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(void) +{ + if (pc_status != PC_STATUS_UNSET && pc_row >= msg_scrolled) { + 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 + 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(colnr_T col) +{ + colnr_T save_col; + + if (!redrawing()) + return; + + cursor_off(); + save_col = curwin->w_cursor.col; + curwin->w_cursor.col = col; + 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); + } + 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(void) +{ + if (dollar_vcol >= 0) { + dollar_vcol = -1; + redrawWinline(curwin->w_cursor.lnum, FALSE); + } +} + +/* + * Insert an indent (for 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 ) + * 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 ( + int type, + int amount, + int round, + int replaced, /* replaced character, put on replace stack */ + int call_changed_bytes /* call changed_bytes() */ +) +{ + 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; + 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; + } + + /* 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, call_changed_bytes ? SIN_CHANGED : 0); + else { + int save_State = State; + + /* Avoid being called recursively. */ + if (State & VREPLACE_FLAG) + State = INSERT; + shift_line(type == INDENT_DEC, round, 1, call_changed_bytes); + State = save_State; + } + 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 = (colnr_T)((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; + if (has_mbyte && new_cursor_col >= 0) + new_cursor_col += (*mb_ptr2len)(ptr + new_cursor_col); + else + ++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 = (colnr_T)new_cursor_col; + i = (int)curwin->w_virtcol - vcol; + ptr = xmallocz(i); + memset(ptr, ' ', i); + new_cursor_col += i; + ins_str(ptr); + 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 = (colnr_T)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; + } + } + + /* + * 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); + + free(new_line); + } +} + +/* + * 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(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. + * Will attempt not to go before "col" even when there is a composing + * character. + */ +void backspace_until_column(int col) +{ + while ((int)curwin->w_cursor.col > col) { + curwin->w_cursor.col--; + if (State & REPLACE_FLAG) + replace_do_bs(col); + else if (!del_char_after_col(col)) + break; + } +} +#endif + +/* + * Like del_char(), but make sure not to go before column "limit_col". + * Only matters when there are composing characters. + * Return TRUE when something was deleted. + */ +static int del_char_after_col(int limit_col) +{ + if (enc_utf8 && limit_col >= 0) { + colnr_T ecol = curwin->w_cursor.col + 1; + + /* Make sure the cursor is at the start of a character, but + * skip forward again when going too far back because of a + * composing character. */ + mb_adjust_cursor(); + while (curwin->w_cursor.col < (colnr_T)limit_col) { + int l = utf_ptr2len(ml_get_cursor()); + + if (l == 0) /* end of line */ + break; + curwin->w_cursor.col += l; + } + if (*ml_get_cursor() == NUL || curwin->w_cursor.col == ecol) + return FALSE; + del_bytes((long)((int)ecol - curwin->w_cursor.col), FALSE, TRUE); + } else + (void)del_char(FALSE); + return TRUE; +} + +/* + * CTRL-X pressed in Insert mode. + */ +static void ins_ctrl_x(void) +{ + /* CTRL-X after CTRL-X CTRL-V 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 + * compl_cont_status */ + if (compl_cont_status & CONT_N_ADDS) + compl_cont_status |= CONT_INTRPT; + else + compl_cont_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(); + } +} + +/* + * Return TRUE if the 'dict' or 'tsr' option can be used. + */ +static int has_compl_option(int dict_opt) +{ + if (dict_opt ? (*curbuf->b_p_dict == NUL && *p_dict == NUL + && !curwin->w_p_spell + ) + : (*curbuf->b_p_tsr == NUL && *p_tsr == NUL)) { + ctrl_x_mode = 0; + edit_submode = NULL; + msg_attr(dict_opt ? (char_u *)_("'dictionary' option is empty") + : (char_u *)_("'thesaurus' option is empty"), + hl_attr(HLF_E)); + if (emsg_silent == 0) { + vim_beep(); + setcursor(); + out_flush(); + ui_delay(2000L, FALSE); + } + return FALSE; + } + return TRUE; +} + +/* + * 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(int c) +{ + /* Always allow ^R - let it's results then be checked */ + if (c == Ctrl_R) + return TRUE; + + /* Accept and if the popup menu is visible. */ + if (ins_compl_pum_key(c)) + 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 || c == Ctrl_U || c == Ctrl_O + || c == Ctrl_S || c == Ctrl_K || c == 's'; + 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; + 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; + case CTRL_X_CMDLINE: + return c == Ctrl_V || c == Ctrl_Q || c == Ctrl_P || c == Ctrl_N + || c == Ctrl_X; + case CTRL_X_FUNCTION: + return c == Ctrl_U || c == Ctrl_P || c == Ctrl_N; + case CTRL_X_OMNI: + return c == Ctrl_O || c == Ctrl_P || c == Ctrl_N; + case CTRL_X_SPELL: + return c == Ctrl_S || c == Ctrl_P || c == Ctrl_N; + } + EMSG(_(e_internal)); + return FALSE; +} + +/* + * Return TRUE when character "c" is part of the item currently being + * completed. Used to decide whether to abandon complete mode when the menu + * is visible. + */ +static int ins_compl_accept_char(int c) +{ + if (ctrl_x_mode & CTRL_X_WANT_IDENT) + /* When expanding an identifier only accept identifier chars. */ + return vim_isIDc(c); + + switch (ctrl_x_mode) { + case CTRL_X_FILES: + /* When expanding file name only accept file name chars. But not + * path separators, so that "proto/" expands files in + * "proto", not "proto/" as a whole */ + return vim_isfilec(c) && !vim_ispathsep(c); + + case CTRL_X_CMDLINE: + case CTRL_X_OMNI: + /* Command line and Omni completion can work with just about any + * printable character, but do stop at white space. */ + return vim_isprintc(c) && !vim_iswhite(c); + + case CTRL_X_WHOLE_LINE: + /* For while line completion a space can be part of the line. */ + return vim_isprintc(c); + } + return vim_iswordc(c); +} + +/* + * 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 inferred, 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(char_u *str, int len, int icase, char_u *fname, int dir, int flags) +{ + char_u *p; + int i, c; + int actual_len; /* Take multi-byte characters */ + int actual_compl_length; /* into account. */ + int min_len; + int *wca; /* Wide character array. */ + int has_lower = FALSE; + int was_letter = FALSE; + + if (p_ic && curbuf->b_p_inf && len > 0) { + /* Infer case of completed part. */ + + /* Find actual length of completion. */ + if (has_mbyte) { + p = str; + actual_len = 0; + while (*p != NUL) { + mb_ptr_adv(p); + ++actual_len; + } + } else + actual_len = len; + + /* Find actual length of original text. */ + if (has_mbyte) { + p = compl_orig_text; + actual_compl_length = 0; + while (*p != NUL) { + mb_ptr_adv(p); + ++actual_compl_length; + } + } else + actual_compl_length = compl_length; + + /* "actual_len" may be smaller than "actual_compl_length" when using + * thesaurus, only use the minimum when comparing. */ + min_len = actual_len < actual_compl_length + ? actual_len : actual_compl_length; + + /* Allocate wide character array for the completion and fill it. */ + wca = xmalloc(actual_len * sizeof(*wca)); + p = str; + for (i = 0; i < actual_len; ++i) + if (has_mbyte) + wca[i] = mb_ptr2char_adv(&p); + else + wca[i] = *(p++); + + /* Rule 1: Were any chars converted to lower? */ + p = compl_orig_text; + for (i = 0; i < min_len; ++i) { + if (has_mbyte) + c = mb_ptr2char_adv(&p); + else + c = *(p++); + if (vim_islower(c)) { + has_lower = TRUE; + if (vim_isupper(wca[i])) { + /* Rule 1 is satisfied. */ + for (i = actual_compl_length; i < actual_len; ++i) + wca[i] = vim_tolower(wca[i]); + break; + } + } + } + + /* + * Rule 2: No lower case, 2nd consecutive letter converted to + * upper case. + */ + if (!has_lower) { + p = compl_orig_text; + for (i = 0; i < min_len; ++i) { + if (has_mbyte) + c = mb_ptr2char_adv(&p); + else + c = *(p++); + if (was_letter && vim_isupper(c) && vim_islower(wca[i])) { + /* Rule 2 is satisfied. */ + for (i = actual_compl_length; i < actual_len; ++i) + wca[i] = vim_toupper(wca[i]); + break; + } + was_letter = vim_islower(c) || vim_isupper(c); + } + } + + /* Copy the original case of the part we typed. */ + p = compl_orig_text; + for (i = 0; i < min_len; ++i) { + if (has_mbyte) + c = mb_ptr2char_adv(&p); + else + c = *(p++); + if (vim_islower(c)) + wca[i] = vim_tolower(wca[i]); + else if (vim_isupper(c)) + wca[i] = vim_t