blob: ec3e8ff6c41fa5c6660fcbd8d04f35d36530437a [file] [log] [blame]
Bram Moolenaaredf3f972016-08-29 22:49:24 +02001/* vi:set ts=8 sts=4 sw=4 noet:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 *
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
8 */
9
10/*
11 * edit.c: functions for Insert mode
12 */
13
14#include "vim.h"
15
Bram Moolenaar071d4272004-06-13 20:20:40 +000016#define BACKSPACE_CHAR 1
17#define BACKSPACE_WORD 2
18#define BACKSPACE_WORD_NOT_SPACE 3
19#define BACKSPACE_LINE 4
20
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010021// Set when doing something for completion that may call edit() recursively,
22// which is not allowed.
Bram Moolenaar7591bb32019-03-30 13:53:47 +010023static int compl_busy = FALSE;
Bram Moolenaar7591bb32019-03-30 13:53:47 +010024
25
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010026static void ins_ctrl_v(void);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010027static void insert_special(int, int, int);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010028static void redo_literal(int c);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010029static void start_arrow_common(pos_T *end_insert_pos, int change);
Bram Moolenaarb9a02fc2006-03-12 22:08:12 +000030#ifdef FEAT_SPELL
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010031static void check_spell_redraw(void);
Bram Moolenaar217ad922005-03-20 22:37:15 +000032#endif
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010033static void stop_insert(pos_T *end_insert_pos, int esc, int nomove);
34static int echeck_abbr(int);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010035static void mb_replace_pop_ins(int cc);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010036static void replace_flush(void);
37static void replace_do_bs(int limit_col);
38static int del_char_after_col(int limit_col);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010039static void ins_reg(void);
40static void ins_ctrl_g(void);
41static void ins_ctrl_hat(void);
42static int ins_esc(long *count, int cmdchar, int nomove);
Bram Moolenaar071d4272004-06-13 20:20:40 +000043#ifdef FEAT_RIGHTLEFT
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010044static void ins_ctrl_(void);
Bram Moolenaar071d4272004-06-13 20:20:40 +000045#endif
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010046static int ins_start_select(int c);
47static void ins_insert(int replaceState);
48static void ins_ctrl_o(void);
49static void ins_shift(int c, int lastc);
50static void ins_del(void);
51static int ins_bs(int c, int mode, int *inserted_space_p);
Bram Moolenaara23ccb82006-02-27 00:08:02 +000052#if defined(FEAT_GUI_TABLINE) || defined(PROTO)
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010053static void ins_tabline(int c);
Bram Moolenaara23ccb82006-02-27 00:08:02 +000054#endif
Bram Moolenaar75bf3d22019-03-26 22:46:05 +010055static void ins_left(void);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010056static void ins_home(int c);
57static void ins_end(int c);
58static void ins_s_left(void);
Bram Moolenaar75bf3d22019-03-26 22:46:05 +010059static void ins_right(void);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010060static void ins_s_right(void);
61static void ins_up(int startcol);
62static void ins_pageup(void);
63static void ins_down(int startcol);
64static void ins_pagedown(void);
Bram Moolenaar071d4272004-06-13 20:20:40 +000065#ifdef FEAT_DND
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010066static void ins_drop(void);
Bram Moolenaar071d4272004-06-13 20:20:40 +000067#endif
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010068static int ins_tab(void);
Bram Moolenaar071d4272004-06-13 20:20:40 +000069#ifdef FEAT_DIGRAPHS
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010070static int ins_digraph(void);
Bram Moolenaar071d4272004-06-13 20:20:40 +000071#endif
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010072static int ins_ctrl_ey(int tc);
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +010073#if defined(FEAT_EVAL)
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010074static char_u *do_insert_char_pre(int c);
Bram Moolenaarf5876f12012-02-29 18:22:08 +010075#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +000076
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010077static colnr_T Insstart_textlen; // length of line when insert started
78static colnr_T Insstart_blank_vcol; // vcol for first inserted blank
79static int update_Insstart_orig = TRUE; // set Insstart_orig to Insstart
Bram Moolenaar071d4272004-06-13 20:20:40 +000080
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010081static char_u *last_insert = NULL; // the text of the previous insert,
82 // K_SPECIAL and CSI are escaped
83static int last_insert_skip; // nr of chars in front of previous insert
84static int new_insert_skip; // nr of chars in front of current insert
85static int did_restart_edit; // "restart_edit" when calling edit()
Bram Moolenaar071d4272004-06-13 20:20:40 +000086
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010087static int can_cindent; // may do cindenting on this line
Bram Moolenaar071d4272004-06-13 20:20:40 +000088
Bram Moolenaar071d4272004-06-13 20:20:40 +000089#ifdef FEAT_RIGHTLEFT
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010090static int revins_on; // reverse insert mode on
91static int revins_chars; // how much to skip after edit
92static int revins_legal; // was the last char 'legal'?
93static int revins_scol; // start column of revins session
Bram Moolenaar071d4272004-06-13 20:20:40 +000094#endif
95
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010096static int ins_need_undo; // call u_save() before inserting a
97 // char. Set when edit() is called.
98 // after that arrow_used is used.
Bram Moolenaar071d4272004-06-13 20:20:40 +000099
Bram Moolenaar75bf3d22019-03-26 22:46:05 +0100100static int dont_sync_undo = FALSE; // CTRL-G U prevents syncing undo for
101 // the next left/right cursor key
Bram Moolenaar071d4272004-06-13 20:20:40 +0000102
103/*
104 * edit(): Start inserting text.
105 *
106 * "cmdchar" can be:
107 * 'i' normal insert command
108 * 'a' normal append command
Bram Moolenaarec2da362017-01-21 20:04:22 +0100109 * K_PS bracketed paste
Bram Moolenaar071d4272004-06-13 20:20:40 +0000110 * 'R' replace command
111 * 'r' "r<CR>" command: insert one <CR>. Note: count can be > 1, for redo,
112 * but still only one <CR> is inserted. The <Esc> is not used for redo.
113 * 'g' "gI" command.
114 * 'V' "gR" command for Virtual Replace mode.
115 * 'v' "gr" command for single character Virtual Replace mode.
116 *
117 * This function is not called recursively. For CTRL-O commands, it returns
118 * and lets the caller handle the Normal-mode command.
119 *
120 * Return TRUE if a CTRL-O command caused the return (insert mode pending).
121 */
122 int
Bram Moolenaar7454a062016-01-30 15:14:10 +0100123edit(
124 int cmdchar,
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100125 int startln, // if set, insert at start of line
Bram Moolenaar7454a062016-01-30 15:14:10 +0100126 long count)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000127{
128 int c = 0;
129 char_u *ptr;
Bram Moolenaar418f81b2016-02-16 20:12:02 +0100130 int lastc = 0;
Bram Moolenaar0ab2a882009-05-13 10:51:08 +0000131 int mincol;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000132 static linenr_T o_lnum = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000133 int i;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100134 int did_backspace = TRUE; // previous char was backspace
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100135 int line_is_white = FALSE; // line is empty before insert
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100136 linenr_T old_topline = 0; // topline before insertion
Bram Moolenaar071d4272004-06-13 20:20:40 +0000137#ifdef FEAT_DIFF
138 int old_topfill = -1;
139#endif
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100140 int inserted_space = FALSE; // just inserted a space
Bram Moolenaar24959102022-05-07 20:01:16 +0100141 int replaceState = MODE_REPLACE;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100142 int nomove = FALSE; // don't move cursor on return
Bram Moolenaarf2732452018-06-03 14:47:35 +0200143#ifdef FEAT_JOB_CHANNEL
144 int cmdchar_todo = cmdchar;
145#endif
Bram Moolenaarea042672021-06-29 20:22:32 +0200146#ifdef FEAT_CONCEAL
147 int cursor_line_was_concealed;
148#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000149
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100150 // Remember whether editing was restarted after CTRL-O.
Bram Moolenaar83c465c2005-12-16 21:53:56 +0000151 did_restart_edit = restart_edit;
152
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100153 // sleep before redrawing, needed for "CTRL-O :" that results in an
154 // error message
Bram Moolenaar071d4272004-06-13 20:20:40 +0000155 check_for_delay(TRUE);
156
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100157 // set Insstart_orig to Insstart
Bram Moolenaarb1d90a32014-02-22 23:03:55 +0100158 update_Insstart_orig = TRUE;
159
Bram Moolenaar071d4272004-06-13 20:20:40 +0000160#ifdef HAVE_SANDBOX
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100161 // Don't allow inserting in the sandbox.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000162 if (sandbox != 0)
163 {
Bram Moolenaard8e44472021-07-21 22:20:33 +0200164 emsg(_(e_not_allowed_in_sandbox));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000165 return FALSE;
166 }
167#endif
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100168 // Don't allow changes in the buffer while editing the cmdline. The
169 // caller of getcmdline() may get confused.
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100170 // Don't allow recursive insert mode when busy with completion.
zeertzjqcfe45652022-05-27 17:26:55 +0100171 if (textlock != 0 || ins_compl_active() || compl_busy || pum_visible())
Bram Moolenaarf193fff2006-04-27 00:02:13 +0000172 {
Bram Moolenaar74409f62022-01-01 15:58:22 +0000173 emsg(_(e_not_allowed_to_change_text_or_change_window));
Bram Moolenaarf193fff2006-04-27 00:02:13 +0000174 return FALSE;
175 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100176 ins_compl_clear(); // clear stuff for CTRL-X mode
Bram Moolenaar071d4272004-06-13 20:20:40 +0000177
Bram Moolenaar843ee412004-06-30 16:16:41 +0000178 /*
179 * Trigger InsertEnter autocommands. Do not do this for "r<CR>" or "grx".
180 */
181 if (cmdchar != 'r' && cmdchar != 'v')
182 {
Bram Moolenaar3e37fd02013-01-17 15:37:01 +0100183 pos_T save_cursor = curwin->w_cursor;
184
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +0100185#ifdef FEAT_EVAL
Bram Moolenaar843ee412004-06-30 16:16:41 +0000186 if (cmdchar == 'R')
187 ptr = (char_u *)"r";
188 else if (cmdchar == 'V')
189 ptr = (char_u *)"v";
190 else
191 ptr = (char_u *)"i";
192 set_vim_var_string(VV_INSERTMODE, ptr, 1);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100193 set_vim_var_string(VV_CHAR, NULL, -1); // clear v:char
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +0100194#endif
Bram Moolenaar9fa95062018-08-08 22:08:32 +0200195 ins_apply_autocmds(EVENT_INSERTENTER);
Bram Moolenaar3e37fd02013-01-17 15:37:01 +0100196
Bram Moolenaar2e6cdb92021-01-28 11:07:44 +0100197 // Check for changed highlighting, e.g. for ModeMsg.
198 if (need_highlight_changed)
199 highlight_changed();
200
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100201 // Make sure the cursor didn't move. Do call check_cursor_col() in
202 // case the text was modified. Since Insert mode was not started yet
203 // a call to check_cursor_col() may move the cursor, especially with
204 // the "A" command, thus set State to avoid that. Also check that the
205 // line number is still valid (lines may have been deleted).
206 // Do not restore if v:char was set to a non-empty string.
Bram Moolenaarb5aedf32017-03-12 18:23:53 +0100207 if (!EQUAL_POS(curwin->w_cursor, save_cursor)
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +0100208#ifdef FEAT_EVAL
Bram Moolenaar097c9922013-05-19 21:15:15 +0200209 && *get_vim_var_str(VV_CHAR) == NUL
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +0100210#endif
Bram Moolenaar097c9922013-05-19 21:15:15 +0200211 && save_cursor.lnum <= curbuf->b_ml.ml_line_count)
Bram Moolenaar3e37fd02013-01-17 15:37:01 +0100212 {
213 int save_state = State;
214
215 curwin->w_cursor = save_cursor;
Bram Moolenaar24959102022-05-07 20:01:16 +0100216 State = MODE_INSERT;
Bram Moolenaar3e37fd02013-01-17 15:37:01 +0100217 check_cursor_col();
218 State = save_state;
219 }
Bram Moolenaar843ee412004-06-30 16:16:41 +0000220 }
Bram Moolenaar843ee412004-06-30 16:16:41 +0000221
Bram Moolenaarf5963f72010-07-23 22:10:27 +0200222#ifdef FEAT_CONCEAL
Bram Moolenaarea042672021-06-29 20:22:32 +0200223 // Check if the cursor line was concealed before changing State.
224 cursor_line_was_concealed = curwin->w_p_cole > 0
225 && conceal_cursor_line(curwin);
Bram Moolenaarf5963f72010-07-23 22:10:27 +0200226#endif
227
Bram Moolenaar071d4272004-06-13 20:20:40 +0000228 /*
229 * When doing a paste with the middle mouse button, Insstart is set to
230 * where the paste started.
231 */
232 if (where_paste_started.lnum != 0)
233 Insstart = where_paste_started;
234 else
Bram Moolenaar071d4272004-06-13 20:20:40 +0000235 {
236 Insstart = curwin->w_cursor;
237 if (startln)
238 Insstart.col = 0;
239 }
Bram Moolenaar0ab2a882009-05-13 10:51:08 +0000240 Insstart_textlen = (colnr_T)linetabsize(ml_get_curline());
Bram Moolenaar071d4272004-06-13 20:20:40 +0000241 Insstart_blank_vcol = MAXCOL;
242 if (!did_ai)
243 ai_col = 0;
244
245 if (cmdchar != NUL && restart_edit == 0)
246 {
247 ResetRedobuff();
248 AppendNumberToRedobuff(count);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000249 if (cmdchar == 'V' || cmdchar == 'v')
250 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100251 // "gR" or "gr" command
Bram Moolenaar071d4272004-06-13 20:20:40 +0000252 AppendCharToRedobuff('g');
253 AppendCharToRedobuff((cmdchar == 'v') ? 'r' : 'R');
254 }
255 else
Bram Moolenaar071d4272004-06-13 20:20:40 +0000256 {
Bram Moolenaar076e5022017-01-24 18:58:30 +0100257 if (cmdchar == K_PS)
258 AppendCharToRedobuff('a');
259 else
260 AppendCharToRedobuff(cmdchar);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100261 if (cmdchar == 'g') // "gI" command
Bram Moolenaar071d4272004-06-13 20:20:40 +0000262 AppendCharToRedobuff('I');
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100263 else if (cmdchar == 'r') // "r<CR>" command
264 count = 1; // insert only one <CR>
Bram Moolenaar071d4272004-06-13 20:20:40 +0000265 }
266 }
267
268 if (cmdchar == 'R')
269 {
Bram Moolenaar24959102022-05-07 20:01:16 +0100270 State = MODE_REPLACE;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000271 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000272 else if (cmdchar == 'V' || cmdchar == 'v')
273 {
Bram Moolenaar24959102022-05-07 20:01:16 +0100274 State = MODE_VREPLACE;
275 replaceState = MODE_VREPLACE;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000276 orig_line_count = curbuf->b_ml.ml_line_count;
277 vr_lines_changed = 1;
278 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000279 else
Bram Moolenaar24959102022-05-07 20:01:16 +0100280 State = MODE_INSERT;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000281
LemonBoy2bf52dd2022-04-09 18:17:34 +0100282 may_trigger_modechanged();
Bram Moolenaar071d4272004-06-13 20:20:40 +0000283 stop_insert_mode = FALSE;
284
Bram Moolenaarea042672021-06-29 20:22:32 +0200285#ifdef FEAT_CONCEAL
286 // Check if the cursor line needs redrawing after changing State. If
287 // 'concealcursor' is "n" it needs to be redrawn without concealing.
288 conceal_check_cursor_line(cursor_line_was_concealed);
289#endif
290
Bram Moolenaar1f4ee192022-08-01 15:52:55 +0100291 // Need to position cursor again when on a TAB and when on a char with
292 // virtual text.
293 if (gchar_cursor() == TAB
294#ifdef FEAT_PROP_POPUP
295 || curbuf->b_has_textprop
296#endif
297 )
zeertzjq8c979602022-04-07 15:08:01 +0100298 curwin->w_valid &= ~(VALID_WROW|VALID_WCOL|VALID_VIRTCOL);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000299
300 /*
301 * Enable langmap or IME, indicated by 'iminsert'.
302 * Note that IME may enabled/disabled without us noticing here, thus the
303 * 'iminsert' value may not reflect what is actually used. It is updated
304 * when hitting <Esc>.
305 */
306 if (curbuf->b_p_iminsert == B_IMODE_LMAP)
Bram Moolenaar24959102022-05-07 20:01:16 +0100307 State |= MODE_LANGMAP;
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +0100308#ifdef HAVE_INPUT_METHOD
Bram Moolenaar071d4272004-06-13 20:20:40 +0000309 im_set_active(curbuf->b_p_iminsert == B_IMODE_IM);
310#endif
311
Bram Moolenaar071d4272004-06-13 20:20:40 +0000312 setmouse();
Bram Moolenaar071d4272004-06-13 20:20:40 +0000313#ifdef FEAT_CMDL_INFO
314 clear_showcmd();
315#endif
316#ifdef FEAT_RIGHTLEFT
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100317 // there is no reverse replace mode
Bram Moolenaar24959102022-05-07 20:01:16 +0100318 revins_on = (State == MODE_INSERT && p_ri);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000319 if (revins_on)
320 undisplay_dollar();
321 revins_chars = 0;
322 revins_legal = 0;
323 revins_scol = -1;
324#endif
Bram Moolenaar48c9f3b2017-01-24 19:08:15 +0100325 if (!p_ek)
Bram Moolenaar177c9f22019-11-06 13:59:16 +0100326 {
Bram Moolenaar1d97db32022-06-04 22:15:54 +0100327 MAY_WANT_TO_LOG_THIS;
328
Bram Moolenaar177c9f22019-11-06 13:59:16 +0100329 // Disable bracketed paste mode, we won't recognize the escape
330 // sequences.
Bram Moolenaar48c9f3b2017-01-24 19:08:15 +0100331 out_str(T_BD);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000332
Bram Moolenaar177c9f22019-11-06 13:59:16 +0100333 // Disable modifyOtherKeys, keys with modifiers would cause exiting
334 // Insert mode.
335 out_str(T_CTE);
336 }
337
Bram Moolenaar071d4272004-06-13 20:20:40 +0000338 /*
339 * Handle restarting Insert mode.
Bram Moolenaara6c07602017-03-05 21:18:27 +0100340 * Don't do this for "CTRL-O ." (repeat an insert): In that case we get
341 * here with something in the stuff buffer.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000342 */
343 if (restart_edit != 0 && stuff_empty())
344 {
Bram Moolenaar071d4272004-06-13 20:20:40 +0000345 /*
346 * After a paste we consider text typed to be part of the insert for
347 * the pasted text. You can backspace over the pasted text too.
348 */
349 if (where_paste_started.lnum)
350 arrow_used = FALSE;
351 else
Bram Moolenaar071d4272004-06-13 20:20:40 +0000352 arrow_used = TRUE;
353 restart_edit = 0;
354
355 /*
356 * If the cursor was after the end-of-line before the CTRL-O and it is
357 * now at the end-of-line, put it after the end-of-line (this is not
358 * correct in very rare cases).
359 * Also do this if curswant is greater than the current virtual
360 * column. Eg after "^O$" or "^O80|".
361 */
362 validate_virtcol();
363 update_curswant();
Bram Moolenaar68b76a62005-03-25 21:53:48 +0000364 if (((ins_at_eol && curwin->w_cursor.lnum == o_lnum)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000365 || curwin->w_curswant > curwin->w_virtcol)
366 && *(ptr = ml_get_curline() + curwin->w_cursor.col) != NUL)
367 {
368 if (ptr[1] == NUL)
369 ++curwin->w_cursor.col;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000370 else if (has_mbyte)
371 {
Bram Moolenaar0fa313a2005-08-10 21:07:57 +0000372 i = (*mb_ptr2len)(ptr);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000373 if (ptr[i] == NUL)
374 curwin->w_cursor.col += i;
375 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000376 }
Bram Moolenaar68b76a62005-03-25 21:53:48 +0000377 ins_at_eol = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000378 }
379 else
380 arrow_used = FALSE;
381
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100382 // we are in insert mode now, don't need to start it anymore
Bram Moolenaar071d4272004-06-13 20:20:40 +0000383 need_start_insertmode = FALSE;
384
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100385 // Need to save the line for undo before inserting the first char.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000386 ins_need_undo = TRUE;
387
Bram Moolenaar071d4272004-06-13 20:20:40 +0000388 where_paste_started.lnum = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000389 can_cindent = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000390#ifdef FEAT_FOLDING
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100391 // The cursor line is not in a closed fold, unless 'insertmode' is set or
392 // restarting.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000393 if (!p_im && did_restart_edit == 0)
394 foldOpenCursor();
395#endif
396
397 /*
398 * If 'showmode' is set, show the current (insert/replace/..) mode.
399 * A warning message for changing a readonly file is given here, before
400 * actually changing anything. It's put after the mode, if any.
401 */
402 i = 0;
Bram Moolenaard12f5c12006-01-25 22:10:52 +0000403 if (p_smd && msg_silent == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000404 i = showmode();
405
406 if (!p_im && did_restart_edit == 0)
Bram Moolenaar21af89e2008-01-02 21:09:33 +0000407 change_warning(i == 0 ? 0 : i + 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000408
409#ifdef CURSOR_SHAPE
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100410 ui_cursor_shape(); // may show different cursor shape
Bram Moolenaar071d4272004-06-13 20:20:40 +0000411#endif
412#ifdef FEAT_DIGRAPHS
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100413 do_digraph(-1); // clear digraphs
Bram Moolenaar071d4272004-06-13 20:20:40 +0000414#endif
415
Bram Moolenaar83c465c2005-12-16 21:53:56 +0000416 /*
417 * Get the current length of the redo buffer, those characters have to be
418 * skipped if we want to get to the inserted characters.
419 */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000420 ptr = get_inserted();
421 if (ptr == NULL)
422 new_insert_skip = 0;
423 else
424 {
425 new_insert_skip = (int)STRLEN(ptr);
426 vim_free(ptr);
427 }
428
429 old_indent = 0;
430
431 /*
432 * Main loop in Insert mode: repeat until Insert mode is left.
433 */
434 for (;;)
435 {
436#ifdef FEAT_RIGHTLEFT
437 if (!revins_legal)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100438 revins_scol = -1; // reset on illegal motions
Bram Moolenaar071d4272004-06-13 20:20:40 +0000439 else
440 revins_legal = 0;
441#endif
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100442 if (arrow_used) // don't repeat insert when arrow key used
Bram Moolenaar071d4272004-06-13 20:20:40 +0000443 count = 0;
444
Bram Moolenaarb1d90a32014-02-22 23:03:55 +0100445 if (update_Insstart_orig)
446 Insstart_orig = Insstart;
447
zeertzjqcd5dbad2022-05-04 17:51:50 +0100448 if (stop_insert_mode && !ins_compl_active())
Bram Moolenaar071d4272004-06-13 20:20:40 +0000449 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100450 // ":stopinsert" used or 'insertmode' reset
Bram Moolenaar071d4272004-06-13 20:20:40 +0000451 count = 0;
452 goto doESCkey;
453 }
454
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100455 // set curwin->w_curswant for next K_DOWN or K_UP
Bram Moolenaar071d4272004-06-13 20:20:40 +0000456 if (!arrow_used)
457 curwin->w_set_curswant = TRUE;
458
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100459 // If there is no typeahead may check for timestamps (e.g., for when a
460 // menu invoked a shell command).
Bram Moolenaar071d4272004-06-13 20:20:40 +0000461 if (stuff_empty())
462 {
463 did_check_timestamps = FALSE;
464 if (need_check_timestamps)
465 check_timestamps(FALSE);
466 }
467
468 /*
469 * When emsg() was called msg_scroll will have been set.
470 */
471 msg_scroll = FALSE;
472
473#ifdef FEAT_GUI
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100474 // When 'mousefocus' is set a mouse movement may have taken us to
475 // another window. "need_mouse_correct" may then be set because of an
476 // autocommand.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000477 if (need_mouse_correct)
478 gui_mouse_correct();
479#endif
480
481#ifdef FEAT_FOLDING
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100482 // Open fold at the cursor line, according to 'foldopen'.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000483 if (fdo_flags & FDO_INSERT)
484 foldOpenCursor();
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100485 // Close folds where the cursor isn't, according to 'foldclose'
Bram Moolenaar071d4272004-06-13 20:20:40 +0000486 if (!char_avail())
487 foldCheckClose();
488#endif
489
Bram Moolenaarf2732452018-06-03 14:47:35 +0200490#ifdef FEAT_JOB_CHANNEL
491 if (bt_prompt(curbuf))
492 {
493 init_prompt(cmdchar_todo);
494 cmdchar_todo = NUL;
495 }
496#endif
497
Bram Moolenaar071d4272004-06-13 20:20:40 +0000498 /*
499 * If we inserted a character at the last position of the last line in
500 * the window, scroll the window one line up. This avoids an extra
501 * redraw.
502 * This is detected when the cursor column is smaller after inserting
503 * something.
504 * Don't do this when the topline changed already, it has
505 * already been adjusted (by insertchar() calling open_line())).
506 */
507 if (curbuf->b_mod_set
508 && curwin->w_p_wrap
509 && !did_backspace
510 && curwin->w_topline == old_topline
511#ifdef FEAT_DIFF
512 && curwin->w_topfill == old_topfill
513#endif
514 )
515 {
516 mincol = curwin->w_wcol;
517 validate_cursor_col();
518
Bram Moolenaar04958cb2018-06-23 19:23:02 +0200519 if (
520#ifdef FEAT_VARTABS
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +0000521 curwin->w_wcol < mincol - tabstop_at(
Bram Moolenaar04958cb2018-06-23 19:23:02 +0200522 get_nolist_virtcol(), curbuf->b_p_ts,
523 curbuf->b_p_vts_array)
524#else
525 (int)curwin->w_wcol < mincol - curbuf->b_p_ts
526#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000527 && curwin->w_wrow == W_WINROW(curwin)
Bram Moolenaar375e3392019-01-31 18:26:10 +0100528 + curwin->w_height - 1 - get_scrolloff_value()
Bram Moolenaar071d4272004-06-13 20:20:40 +0000529 && (curwin->w_cursor.lnum != curwin->w_topline
530#ifdef FEAT_DIFF
531 || curwin->w_topfill > 0
532#endif
533 ))
534 {
535#ifdef FEAT_DIFF
536 if (curwin->w_topfill > 0)
537 --curwin->w_topfill;
538 else
539#endif
540#ifdef FEAT_FOLDING
541 if (hasFolding(curwin->w_topline, NULL, &old_topline))
542 set_topline(curwin, old_topline + 1);
543 else
544#endif
545 set_topline(curwin, curwin->w_topline + 1);
546 }
547 }
548
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100549 // May need to adjust w_topline to show the cursor.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000550 update_topline();
551
552 did_backspace = FALSE;
553
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100554 validate_cursor(); // may set must_redraw
Bram Moolenaar071d4272004-06-13 20:20:40 +0000555
556 /*
557 * Redraw the display when no characters are waiting.
558 * Also shows mode, ruler and positions cursor.
559 */
Bram Moolenaar754b5602006-02-09 23:53:20 +0000560 ins_redraw(TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000561
Bram Moolenaar071d4272004-06-13 20:20:40 +0000562 if (curwin->w_p_scb)
563 do_check_scrollbind(TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000564
Bram Moolenaar860cae12010-06-05 23:22:07 +0200565 if (curwin->w_p_crb)
566 do_check_cursorbind();
Bram Moolenaar071d4272004-06-13 20:20:40 +0000567 update_curswant();
568 old_topline = curwin->w_topline;
569#ifdef FEAT_DIFF
570 old_topfill = curwin->w_topfill;
571#endif
572
573#ifdef USE_ON_FLY_SCROLL
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100574 dont_scroll = FALSE; // allow scrolling here
Bram Moolenaar071d4272004-06-13 20:20:40 +0000575#endif
576
577 /*
Bram Moolenaarc5aa55d2017-11-28 20:47:40 +0100578 * Get a character for Insert mode. Ignore K_IGNORE and K_NOP.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000579 */
Bram Moolenaar6c5bdb72015-03-13 13:24:23 +0100580 if (c != K_CURSORHOLD)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100581 lastc = c; // remember the previous char for CTRL-D
Bram Moolenaar8b5f65a2015-09-01 19:26:12 +0200582
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100583 // After using CTRL-G U the next cursor key will not break undo.
Bram Moolenaar8b5f65a2015-09-01 19:26:12 +0200584 if (dont_sync_undo == MAYBE)
585 dont_sync_undo = TRUE;
586 else
587 dont_sync_undo = FALSE;
Bram Moolenaarec2da362017-01-21 20:04:22 +0100588 if (cmdchar == K_PS)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100589 // Got here from normal mode when bracketed paste started.
Bram Moolenaarec2da362017-01-21 20:04:22 +0100590 c = K_PS;
591 else
592 do
593 {
594 c = safe_vgetc();
Bram Moolenaar6d41c782018-06-06 09:11:12 +0200595
Bram Moolenaar81035272021-12-16 18:02:07 +0000596 if (stop_insert_mode
597#ifdef FEAT_TERMINAL
598 || (c == K_IGNORE && term_use_loop())
599#endif
600 )
Bram Moolenaar6d41c782018-06-06 09:11:12 +0200601 {
Bram Moolenaar81035272021-12-16 18:02:07 +0000602 // Insert mode ended, possibly from a callback, or a timer
603 // must have opened a terminal window.
Bram Moolenaard0e1b712020-09-27 20:13:03 +0200604 if (c != K_IGNORE && c != K_NOP)
605 vungetc(c);
Bram Moolenaar6d41c782018-06-06 09:11:12 +0200606 count = 0;
607 nomove = TRUE;
Bram Moolenaard0e1b712020-09-27 20:13:03 +0200608 ins_compl_prep(ESC);
Bram Moolenaar6d41c782018-06-06 09:11:12 +0200609 goto doESCkey;
610 }
Bram Moolenaarc5aa55d2017-11-28 20:47:40 +0100611 } while (c == K_IGNORE || c == K_NOP);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000612
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100613 // Don't want K_CURSORHOLD for the second key, e.g., after CTRL-V.
Bram Moolenaard29a9ee2006-09-14 09:07:34 +0000614 did_cursorhold = TRUE;
Bram Moolenaard29a9ee2006-09-14 09:07:34 +0000615
Bram Moolenaar071d4272004-06-13 20:20:40 +0000616#ifdef FEAT_RIGHTLEFT
617 if (p_hkmap && KeyTyped)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100618 c = hkmap(c); // Hebrew mode mapping
Bram Moolenaar071d4272004-06-13 20:20:40 +0000619#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000620
Bram Moolenaard0fb9072021-12-09 11:57:22 +0000621 // If the window was made so small that nothing shows, make it at least
622 // one line and one column when typing.
623 if (KeyTyped && !KeyStuffed)
624 win_ensure_size();
625
Bram Moolenaar8b6144b2006-02-08 09:20:24 +0000626 /*
627 * Special handling of keys while the popup menu is visible or wanted
Bram Moolenaarbe46a1e2006-06-22 15:13:21 +0000628 * and the cursor is still in the completed word. Only when there is
629 * a match, skip this when no matches were found.
Bram Moolenaar8b6144b2006-02-08 09:20:24 +0000630 */
Bram Moolenaar7591bb32019-03-30 13:53:47 +0100631 if (ins_compl_active()
Bram Moolenaarbe46a1e2006-06-22 15:13:21 +0000632 && pum_wanted()
Bram Moolenaar7591bb32019-03-30 13:53:47 +0100633 && curwin->w_cursor.col >= ins_compl_col()
634 && ins_compl_has_shown_match())
Bram Moolenaara6557602006-02-04 22:43:20 +0000635 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100636 // BS: Delete one character from "compl_leader".
Bram Moolenaar8b6144b2006-02-08 09:20:24 +0000637 if ((c == K_BS || c == Ctrl_H)
Bram Moolenaar7591bb32019-03-30 13:53:47 +0100638 && curwin->w_cursor.col > ins_compl_col()
Bram Moolenaarc1e37902006-04-18 21:55:01 +0000639 && (c = ins_compl_bs()) == NUL)
Bram Moolenaara6557602006-02-04 22:43:20 +0000640 continue;
641
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100642 // When no match was selected or it was edited.
Bram Moolenaar7591bb32019-03-30 13:53:47 +0100643 if (!ins_compl_used_match())
Bram Moolenaara6557602006-02-04 22:43:20 +0000644 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100645 // CTRL-L: Add one character from the current match to
646 // "compl_leader". Except when at the original match and
647 // there is nothing to add, CTRL-L works like CTRL-P then.
Bram Moolenaarc1e37902006-04-18 21:55:01 +0000648 if (c == Ctrl_L
Bram Moolenaar7591bb32019-03-30 13:53:47 +0100649 && (!ctrl_x_mode_line_or_eval()
650 || ins_compl_long_shown_match()))
Bram Moolenaar8b6144b2006-02-08 09:20:24 +0000651 {
652 ins_compl_addfrommatch();
653 continue;
654 }
655
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100656 // A non-white character that fits in with the current
657 // completion: Add to "compl_leader".
Bram Moolenaar711d5b52007-10-19 18:40:51 +0000658 if (ins_compl_accept_char(c))
Bram Moolenaar8b6144b2006-02-08 09:20:24 +0000659 {
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +0100660#if defined(FEAT_EVAL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100661 // Trigger InsertCharPre.
Bram Moolenaarf5876f12012-02-29 18:22:08 +0100662 char_u *str = do_insert_char_pre(c);
663 char_u *p;
664
665 if (str != NULL)
666 {
Bram Moolenaar91acfff2017-03-12 19:22:36 +0100667 for (p = str; *p != NUL; MB_PTR_ADV(p))
Bram Moolenaarf5876f12012-02-29 18:22:08 +0100668 ins_compl_addleader(PTR2CHAR(p));
669 vim_free(str);
670 }
671 else
672#endif
673 ins_compl_addleader(c);
Bram Moolenaar8b6144b2006-02-08 09:20:24 +0000674 continue;
675 }
Bram Moolenaarc7453f52006-02-10 23:20:28 +0000676
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100677 // Pressing CTRL-Y selects the current match. When
678 // ins_compl_enter_selects() is set the Enter key does the
679 // same.
Bram Moolenaar7591bb32019-03-30 13:53:47 +0100680 if ((c == Ctrl_Y || (ins_compl_enter_selects()
Bram Moolenaarcbd3bd62016-10-17 20:47:02 +0200681 && (c == CAR || c == K_KENTER || c == NL)))
682 && stop_arrow() == OK)
Bram Moolenaarc7453f52006-02-10 23:20:28 +0000683 {
684 ins_compl_delete();
Bram Moolenaar472e8592016-10-15 17:06:47 +0200685 ins_compl_insert(FALSE);
Bram Moolenaarc7453f52006-02-10 23:20:28 +0000686 }
Bram Moolenaara6557602006-02-04 22:43:20 +0000687 }
688 }
689
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100690 // Prepare for or stop CTRL-X mode. This doesn't do completion, but
691 // it does fix up the text when finishing completion.
Bram Moolenaar7591bb32019-03-30 13:53:47 +0100692 ins_compl_init_get_longest();
Bram Moolenaard4e20a72008-01-22 16:50:03 +0000693 if (ins_compl_prep(c))
Bram Moolenaara6557602006-02-04 22:43:20 +0000694 continue;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000695
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100696 // CTRL-\ CTRL-N goes to Normal mode,
697 // CTRL-\ CTRL-G goes to mode selected with 'insertmode',
698 // CTRL-\ CTRL-O is like CTRL-O but without moving the cursor.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000699 if (c == Ctrl_BSL)
700 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100701 // may need to redraw when no more chars available now
Bram Moolenaar754b5602006-02-09 23:53:20 +0000702 ins_redraw(FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000703 ++no_mapping;
704 ++allow_keys;
Bram Moolenaar61abfd12007-09-13 16:26:47 +0000705 c = plain_vgetc();
Bram Moolenaar071d4272004-06-13 20:20:40 +0000706 --no_mapping;
707 --allow_keys;
Bram Moolenaar488c6512005-08-11 20:09:58 +0000708 if (c != Ctrl_N && c != Ctrl_G && c != Ctrl_O)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000709 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100710 // it's something else
Bram Moolenaar071d4272004-06-13 20:20:40 +0000711 vungetc(c);
712 c = Ctrl_BSL;
713 }
714 else if (c == Ctrl_G && p_im)
715 continue;
716 else
717 {
Bram Moolenaar488c6512005-08-11 20:09:58 +0000718 if (c == Ctrl_O)
719 {
720 ins_ctrl_o();
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100721 ins_at_eol = FALSE; // cursor keeps its column
Bram Moolenaar488c6512005-08-11 20:09:58 +0000722 nomove = TRUE;
723 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000724 count = 0;
725 goto doESCkey;
726 }
727 }
728
729#ifdef FEAT_DIGRAPHS
730 c = do_digraph(c);
731#endif
732
Bram Moolenaar7591bb32019-03-30 13:53:47 +0100733 if ((c == Ctrl_V || c == Ctrl_Q) && ctrl_x_mode_cmdline())
Bram Moolenaar071d4272004-06-13 20:20:40 +0000734 goto docomplete;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000735 if (c == Ctrl_V || c == Ctrl_Q)
736 {
737 ins_ctrl_v();
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100738 c = Ctrl_V; // pretend CTRL-V is last typed character
Bram Moolenaar071d4272004-06-13 20:20:40 +0000739 continue;
740 }
741
Bram Moolenaare2c453d2019-08-21 14:37:09 +0200742 if (cindent_on() && ctrl_x_mode_none())
Bram Moolenaar071d4272004-06-13 20:20:40 +0000743 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100744 // A key name preceded by a bang means this key is not to be
745 // inserted. Skip ahead to the re-indenting below.
746 // A key name preceded by a star means that indenting has to be
747 // done before inserting the key.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000748 line_is_white = inindent(0);
749 if (in_cinkeys(c, '!', line_is_white))
750 goto force_cindent;
751 if (can_cindent && in_cinkeys(c, '*', line_is_white)
752 && stop_arrow() == OK)
753 do_c_expr_indent();
754 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000755
756#ifdef FEAT_RIGHTLEFT
757 if (curwin->w_p_rl)
758 switch (c)
759 {
760 case K_LEFT: c = K_RIGHT; break;
761 case K_S_LEFT: c = K_S_RIGHT; break;
762 case K_C_LEFT: c = K_C_RIGHT; break;
763 case K_RIGHT: c = K_LEFT; break;
764 case K_S_RIGHT: c = K_S_LEFT; break;
765 case K_C_RIGHT: c = K_C_LEFT; break;
766 }
767#endif
768
Bram Moolenaar071d4272004-06-13 20:20:40 +0000769 /*
770 * If 'keymodel' contains "startsel", may start selection. If it
771 * does, a CTRL-O and c will be stuffed, we need to get these
772 * characters.
773 */
774 if (ins_start_select(c))
775 continue;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000776
777 /*
778 * The big switch to handle a character in insert mode.
779 */
780 switch (c)
781 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100782 case ESC: // End input mode
Bram Moolenaar071d4272004-06-13 20:20:40 +0000783 if (echeck_abbr(ESC + ABBR_OFF))
784 break;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100785 // FALLTHROUGH
Bram Moolenaar071d4272004-06-13 20:20:40 +0000786
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100787 case Ctrl_C: // End input mode
Bram Moolenaar071d4272004-06-13 20:20:40 +0000788#ifdef FEAT_CMDWIN
789 if (c == Ctrl_C && cmdwin_type != 0)
790 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100791 // Close the cmdline window.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000792 cmdwin_result = K_IGNORE;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100793 got_int = FALSE; // don't stop executing autocommands et al.
Bram Moolenaar5495cc92006-08-16 14:23:04 +0000794 nomove = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000795 goto doESCkey;
796 }
797#endif
Bram Moolenaar0e5979a2018-06-17 19:36:33 +0200798#ifdef FEAT_JOB_CHANNEL
799 if (c == Ctrl_C && bt_prompt(curbuf))
800 {
801 if (invoke_prompt_interrupt())
802 {
803 if (!bt_prompt(curbuf))
804 // buffer changed to a non-prompt buffer, get out of
805 // Insert mode
806 goto doESCkey;
807 break;
808 }
809 }
810#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000811
812#ifdef UNIX
813do_intr:
814#endif
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100815 // when 'insertmode' set, and not halfway a mapping, don't leave
816 // Insert mode
Bram Moolenaar071d4272004-06-13 20:20:40 +0000817 if (goto_im())
818 {
819 if (got_int)
820 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100821 (void)vgetc(); // flush all buffers
Bram Moolenaar071d4272004-06-13 20:20:40 +0000822 got_int = FALSE;
823 }
824 else
Bram Moolenaar165bc692015-07-21 17:53:25 +0200825 vim_beep(BO_IM);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000826 break;
827 }
828doESCkey:
829 /*
830 * This is the ONLY return from edit()!
831 */
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100832 // Always update o_lnum, so that a "CTRL-O ." that adds a line
833 // still puts the cursor back after the inserted text.
Bram Moolenaar68b76a62005-03-25 21:53:48 +0000834 if (ins_at_eol && gchar_cursor() == NUL)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000835 o_lnum = curwin->w_cursor.lnum;
836
Bram Moolenaar488c6512005-08-11 20:09:58 +0000837 if (ins_esc(&count, cmdchar, nomove))
Bram Moolenaar843ee412004-06-30 16:16:41 +0000838 {
Bram Moolenaar4dbc2622018-11-02 11:59:15 +0100839 // When CTRL-C was typed got_int will be set, with the result
840 // that the autocommands won't be executed. When mapped got_int
841 // is not set, but let's keep the behavior the same.
842 if (cmdchar != 'r' && cmdchar != 'v' && c != Ctrl_C)
Bram Moolenaar9fa95062018-08-08 22:08:32 +0200843 ins_apply_autocmds(EVENT_INSERTLEAVE);
Bram Moolenaarc0a0ab52006-10-06 18:39:58 +0000844 did_cursorhold = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000845 return (c == Ctrl_O);
Bram Moolenaar843ee412004-06-30 16:16:41 +0000846 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000847 continue;
848
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100849 case Ctrl_Z: // suspend when 'insertmode' set
Bram Moolenaar4be06f92005-07-29 22:36:03 +0000850 if (!p_im)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100851 goto normalchar; // insert CTRL-Z as normal char
Bram Moolenaar25b0e6b2017-01-20 21:51:53 +0100852 do_cmdline_cmd((char_u *)"stop");
Bram Moolenaar74a47162017-02-26 19:09:05 +0100853#ifdef CURSOR_SHAPE
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100854 ui_cursor_shape(); // may need to update cursor shape
Bram Moolenaar74a47162017-02-26 19:09:05 +0100855#endif
856 continue;
Bram Moolenaar4be06f92005-07-29 22:36:03 +0000857
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100858 case Ctrl_O: // execute one command
Bram Moolenaare344bea2005-09-01 20:46:49 +0000859#ifdef FEAT_COMPL_FUNC
Bram Moolenaar7591bb32019-03-30 13:53:47 +0100860 if (ctrl_x_mode_omni())
Bram Moolenaar4be06f92005-07-29 22:36:03 +0000861 goto docomplete;
862#endif
863 if (echeck_abbr(Ctrl_O + ABBR_OFF))
864 break;
865 ins_ctrl_o();
Bram Moolenaar06a89a52006-04-29 22:01:03 +0000866
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100867 // don't move the cursor left when 'virtualedit' has "onemore".
Gary Johnson53ba05b2021-07-26 22:19:10 +0200868 if (get_ve_flags() & VE_ONEMORE)
Bram Moolenaar06a89a52006-04-29 22:01:03 +0000869 {
870 ins_at_eol = FALSE;
871 nomove = TRUE;
872 }
Bram Moolenaar4be06f92005-07-29 22:36:03 +0000873 count = 0;
874 goto doESCkey;
875
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100876 case K_INS: // toggle insert/replace mode
Bram Moolenaar572cb562005-08-05 21:35:02 +0000877 case K_KINS:
878 ins_insert(replaceState);
879 break;
880
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100881 case K_SELECT: // end of Select mode mapping - ignore
Bram Moolenaar572cb562005-08-05 21:35:02 +0000882 break;
883
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100884 case K_HELP: // Help key works like <ESC> <Help>
Bram Moolenaar4be06f92005-07-29 22:36:03 +0000885 case K_F1:
886 case K_XF1:
887 stuffcharReadbuff(K_HELP);
888 if (p_im)
889 need_start_insertmode = TRUE;
890 goto doESCkey;
891
892#ifdef FEAT_NETBEANS_INTG
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100893 case K_F21: // NetBeans command
894 ++no_mapping; // don't map the next key hits
Bram Moolenaar61abfd12007-09-13 16:26:47 +0000895 i = plain_vgetc();
Bram Moolenaar4be06f92005-07-29 22:36:03 +0000896 --no_mapping;
897 netbeans_keycommand(i);
898 break;
899#endif
900
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100901 case K_ZERO: // Insert the previously inserted text.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000902 case NUL:
903 case Ctrl_A:
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100904 // For ^@ the trailing ESC will end the insert, unless there is an
905 // error.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000906 if (stuff_inserted(NUL, 1L, (c == Ctrl_A)) == FAIL
907 && c != Ctrl_A && !p_im)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100908 goto doESCkey; // quit insert mode
Bram Moolenaar071d4272004-06-13 20:20:40 +0000909 inserted_space = FALSE;
910 break;
911
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100912 case Ctrl_R: // insert the contents of a register
Bram Moolenaar071d4272004-06-13 20:20:40 +0000913 ins_reg();
914 auto_format(FALSE, TRUE);
915 inserted_space = FALSE;
916 break;
917
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100918 case Ctrl_G: // commands starting with CTRL-G
Bram Moolenaar071d4272004-06-13 20:20:40 +0000919 ins_ctrl_g();
920 break;
921
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100922 case Ctrl_HAT: // switch input mode and/or langmap
Bram Moolenaar4be06f92005-07-29 22:36:03 +0000923 ins_ctrl_hat();
Bram Moolenaar071d4272004-06-13 20:20:40 +0000924 break;
925
926#ifdef FEAT_RIGHTLEFT
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100927 case Ctrl__: // switch between languages
Bram Moolenaar071d4272004-06-13 20:20:40 +0000928 if (!p_ari)
929 goto normalchar;
930 ins_ctrl_();
931 break;
932#endif
933
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100934 case Ctrl_D: // Make indent one shiftwidth smaller.
Bram Moolenaare2c453d2019-08-21 14:37:09 +0200935#if defined(FEAT_FIND_ID)
Bram Moolenaar7591bb32019-03-30 13:53:47 +0100936 if (ctrl_x_mode_path_defines())
Bram Moolenaar071d4272004-06-13 20:20:40 +0000937 goto docomplete;
938#endif
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100939 // FALLTHROUGH
Bram Moolenaar071d4272004-06-13 20:20:40 +0000940
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100941 case Ctrl_T: // Make indent one shiftwidth greater.
Bram Moolenaar7591bb32019-03-30 13:53:47 +0100942 if (c == Ctrl_T && ctrl_x_mode_thesaurus())
Bram Moolenaar071d4272004-06-13 20:20:40 +0000943 {
Bram Moolenaar4be06f92005-07-29 22:36:03 +0000944 if (has_compl_option(FALSE))
945 goto docomplete;
946 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000947 }
Bram Moolenaare2c453d2019-08-21 14:37:09 +0200948
Bram Moolenaar071d4272004-06-13 20:20:40 +0000949 ins_shift(c, lastc);
950 auto_format(FALSE, TRUE);
951 inserted_space = FALSE;
952 break;
953
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100954 case K_DEL: // delete character under the cursor
Bram Moolenaar071d4272004-06-13 20:20:40 +0000955 case K_KDEL:
956 ins_del();
957 auto_format(FALSE, TRUE);
958 break;
959
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100960 case K_BS: // delete character before the cursor
Christian Brabandtdfbdadc2022-05-05 20:46:47 +0100961 case K_S_BS:
Bram Moolenaar071d4272004-06-13 20:20:40 +0000962 case Ctrl_H:
963 did_backspace = ins_bs(c, BACKSPACE_CHAR, &inserted_space);
964 auto_format(FALSE, TRUE);
965 break;
966
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100967 case Ctrl_W: // delete word before the cursor
Bram Moolenaar6d41c782018-06-06 09:11:12 +0200968#ifdef FEAT_JOB_CHANNEL
969 if (bt_prompt(curbuf) && (mod_mask & MOD_MASK_SHIFT) == 0)
970 {
971 // In a prompt window CTRL-W is used for window commands.
972 // Use Shift-CTRL-W to delete a word.
973 stuffcharReadbuff(Ctrl_W);
Bram Moolenaar942b4542018-06-17 16:23:34 +0200974 restart_edit = 'A';
Bram Moolenaar6d41c782018-06-06 09:11:12 +0200975 nomove = TRUE;
976 count = 0;
977 goto doESCkey;
978 }
979#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000980 did_backspace = ins_bs(c, BACKSPACE_WORD, &inserted_space);
981 auto_format(FALSE, TRUE);
982 break;
983
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100984 case Ctrl_U: // delete all inserted text in current line
Bram Moolenaarcfbc5ee2004-07-02 15:38:35 +0000985# ifdef FEAT_COMPL_FUNC
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100986 // CTRL-X CTRL-U completes with 'completefunc'.
Bram Moolenaar7591bb32019-03-30 13:53:47 +0100987 if (ctrl_x_mode_function())
Bram Moolenaarcfbc5ee2004-07-02 15:38:35 +0000988 goto docomplete;
989# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000990 did_backspace = ins_bs(c, BACKSPACE_LINE, &inserted_space);
991 auto_format(FALSE, TRUE);
992 inserted_space = FALSE;
993 break;
994
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100995 case K_LEFTMOUSE: // mouse keys
Bram Moolenaar071d4272004-06-13 20:20:40 +0000996 case K_LEFTMOUSE_NM:
997 case K_LEFTDRAG:
998 case K_LEFTRELEASE:
999 case K_LEFTRELEASE_NM:
Bram Moolenaar51b0f372017-11-18 18:52:04 +01001000 case K_MOUSEMOVE:
Bram Moolenaar071d4272004-06-13 20:20:40 +00001001 case K_MIDDLEMOUSE:
1002 case K_MIDDLEDRAG:
1003 case K_MIDDLERELEASE:
1004 case K_RIGHTMOUSE:
1005 case K_RIGHTDRAG:
1006 case K_RIGHTRELEASE:
1007 case K_X1MOUSE:
1008 case K_X1DRAG:
1009 case K_X1RELEASE:
1010 case K_X2MOUSE:
1011 case K_X2DRAG:
1012 case K_X2RELEASE:
1013 ins_mouse(c);
1014 break;
1015
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001016 case K_MOUSEDOWN: // Default action for scroll wheel up: scroll up
Bram Moolenaar8d9b40e2010-07-25 15:49:07 +02001017 ins_mousescroll(MSCR_DOWN);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001018 break;
1019
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001020 case K_MOUSEUP: // Default action for scroll wheel down: scroll down
Bram Moolenaar8d9b40e2010-07-25 15:49:07 +02001021 ins_mousescroll(MSCR_UP);
1022 break;
1023
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001024 case K_MOUSELEFT: // Scroll wheel left
Bram Moolenaar8d9b40e2010-07-25 15:49:07 +02001025 ins_mousescroll(MSCR_LEFT);
1026 break;
1027
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001028 case K_MOUSERIGHT: // Scroll wheel right
Bram Moolenaar8d9b40e2010-07-25 15:49:07 +02001029 ins_mousescroll(MSCR_RIGHT);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001030 break;
Bram Moolenaara1cb1d12019-10-17 23:00:07 +02001031
Bram Moolenaarec2da362017-01-21 20:04:22 +01001032 case K_PS:
1033 bracketed_paste(PASTE_INSERT, FALSE, NULL);
1034 if (cmdchar == K_PS)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001035 // invoked from normal mode, bail out
Bram Moolenaarec2da362017-01-21 20:04:22 +01001036 goto doESCkey;
1037 break;
1038 case K_PE:
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001039 // Got K_PE without K_PS, ignore.
Bram Moolenaarec2da362017-01-21 20:04:22 +01001040 break;
1041
Bram Moolenaara23ccb82006-02-27 00:08:02 +00001042#ifdef FEAT_GUI_TABLINE
1043 case K_TABLINE:
1044 case K_TABMENU:
1045 ins_tabline(c);
1046 break;
1047#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001048
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001049 case K_IGNORE: // Something mapped to nothing
Bram Moolenaar071d4272004-06-13 20:20:40 +00001050 break;
1051
Bram Moolenaare32c3c42022-01-15 18:26:04 +00001052 case K_COMMAND: // <Cmd>command<CR>
1053 case K_SCRIPT_COMMAND: // <ScriptCmd>command<CR>
1054 do_cmdkey_command(c, 0);
Bram Moolenaare41decc2020-11-14 21:34:59 +01001055#ifdef FEAT_TERMINAL
1056 if (term_use_loop())
1057 // Started a terminal that gets the input, exit Insert mode.
1058 goto doESCkey;
1059#endif
Bram Moolenaar957cf672020-11-12 14:21:06 +01001060 break;
1061
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001062 case K_CURSORHOLD: // Didn't type something for a while.
Bram Moolenaar9fa95062018-08-08 22:08:32 +02001063 ins_apply_autocmds(EVENT_CURSORHOLDI);
Bram Moolenaar754b5602006-02-09 23:53:20 +00001064 did_cursorhold = TRUE;
Bram Moolenaar5a9357d2021-10-03 16:22:05 +01001065 // If CTRL-G U was used apply it to the next typed key.
1066 if (dont_sync_undo == TRUE)
1067 dont_sync_undo = MAYBE;
Bram Moolenaar754b5602006-02-09 23:53:20 +00001068 break;
Bram Moolenaar754b5602006-02-09 23:53:20 +00001069
Bram Moolenaar4f974752019-02-17 17:44:42 +01001070#ifdef FEAT_GUI_MSWIN
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001071 // On MS-Windows ignore <M-F4>, we get it when closing the window
1072 // was cancelled.
Bram Moolenaar4770d092006-01-12 23:22:24 +00001073 case K_F4:
1074 if (mod_mask != MOD_MASK_ALT)
1075 goto normalchar;
1076 break;
1077#endif
1078
Bram Moolenaar071d4272004-06-13 20:20:40 +00001079#ifdef FEAT_GUI
1080 case K_VER_SCROLLBAR:
1081 ins_scroll();
1082 break;
1083
1084 case K_HOR_SCROLLBAR:
1085 ins_horscroll();
1086 break;
1087#endif
1088
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001089 case K_HOME: // <Home>
Bram Moolenaar071d4272004-06-13 20:20:40 +00001090 case K_KHOME:
Bram Moolenaar071d4272004-06-13 20:20:40 +00001091 case K_S_HOME:
1092 case K_C_HOME:
1093 ins_home(c);
1094 break;
1095
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001096 case K_END: // <End>
Bram Moolenaar071d4272004-06-13 20:20:40 +00001097 case K_KEND:
Bram Moolenaar071d4272004-06-13 20:20:40 +00001098 case K_S_END:
1099 case K_C_END:
1100 ins_end(c);
1101 break;
1102
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001103 case K_LEFT: // <Left>
Bram Moolenaarbc7aa852005-03-06 23:38:09 +00001104 if (mod_mask & (MOD_MASK_SHIFT|MOD_MASK_CTRL))
1105 ins_s_left();
1106 else
Bram Moolenaar75bf3d22019-03-26 22:46:05 +01001107 ins_left();
Bram Moolenaar071d4272004-06-13 20:20:40 +00001108 break;
1109
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001110 case K_S_LEFT: // <S-Left>
Bram Moolenaar071d4272004-06-13 20:20:40 +00001111 case K_C_LEFT:
1112 ins_s_left();
1113 break;
1114
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001115 case K_RIGHT: // <Right>
Bram Moolenaarbc7aa852005-03-06 23:38:09 +00001116 if (mod_mask & (MOD_MASK_SHIFT|MOD_MASK_CTRL))
1117 ins_s_right();
1118 else
Bram Moolenaar75bf3d22019-03-26 22:46:05 +01001119 ins_right();
Bram Moolenaar071d4272004-06-13 20:20:40 +00001120 break;
1121
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001122 case K_S_RIGHT: // <S-Right>
Bram Moolenaar071d4272004-06-13 20:20:40 +00001123 case K_C_RIGHT:
1124 ins_s_right();
1125 break;
1126
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001127 case K_UP: // <Up>
Bram Moolenaarc7453f52006-02-10 23:20:28 +00001128 if (pum_visible())
1129 goto docomplete;
Bram Moolenaarbc7aa852005-03-06 23:38:09 +00001130 if (mod_mask & MOD_MASK_SHIFT)
1131 ins_pageup();
1132 else
1133 ins_up(FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001134 break;
1135
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001136 case K_S_UP: // <S-Up>
Bram Moolenaar071d4272004-06-13 20:20:40 +00001137 case K_PAGEUP:
1138 case K_KPAGEUP:
Bram Moolenaare3226be2005-12-18 22:10:00 +00001139 if (pum_visible())
1140 goto docomplete;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001141 ins_pageup();
1142 break;
1143
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001144 case K_DOWN: // <Down>
Bram Moolenaarc7453f52006-02-10 23:20:28 +00001145 if (pum_visible())
1146 goto docomplete;
Bram Moolenaarbc7aa852005-03-06 23:38:09 +00001147 if (mod_mask & MOD_MASK_SHIFT)
1148 ins_pagedown();
1149 else
1150 ins_down(FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001151 break;
1152
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001153 case K_S_DOWN: // <S-Down>
Bram Moolenaar071d4272004-06-13 20:20:40 +00001154 case K_PAGEDOWN:
1155 case K_KPAGEDOWN:
Bram Moolenaare3226be2005-12-18 22:10:00 +00001156 if (pum_visible())
1157 goto docomplete;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001158 ins_pagedown();
1159 break;
1160
1161#ifdef FEAT_DND
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001162 case K_DROP: // drag-n-drop event
Bram Moolenaar071d4272004-06-13 20:20:40 +00001163 ins_drop();
1164 break;
1165#endif
1166
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001167 case K_S_TAB: // When not mapped, use like a normal TAB
Bram Moolenaar071d4272004-06-13 20:20:40 +00001168 c = TAB;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001169 // FALLTHROUGH
Bram Moolenaar071d4272004-06-13 20:20:40 +00001170
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001171 case TAB: // TAB or Complete patterns along path
Bram Moolenaare2c453d2019-08-21 14:37:09 +02001172#if defined(FEAT_FIND_ID)
Bram Moolenaar7591bb32019-03-30 13:53:47 +01001173 if (ctrl_x_mode_path_patterns())
Bram Moolenaar071d4272004-06-13 20:20:40 +00001174 goto docomplete;
1175#endif
1176 inserted_space = FALSE;
1177 if (ins_tab())
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001178 goto normalchar; // insert TAB as a normal char
Bram Moolenaar071d4272004-06-13 20:20:40 +00001179 auto_format(FALSE, TRUE);
1180 break;
1181
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001182 case K_KENTER: // <Enter>
Bram Moolenaar071d4272004-06-13 20:20:40 +00001183 c = CAR;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001184 // FALLTHROUGH
Bram Moolenaar071d4272004-06-13 20:20:40 +00001185 case CAR:
1186 case NL:
Bram Moolenaar4033c552017-09-16 20:54:51 +02001187#if defined(FEAT_QUICKFIX)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001188 // In a quickfix window a <CR> jumps to the error under the
1189 // cursor.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001190 if (bt_quickfix(curbuf) && c == CAR)
1191 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001192 if (curwin->w_llist_ref == NULL) // quickfix window
Bram Moolenaard12f5c12006-01-25 22:10:52 +00001193 do_cmdline_cmd((char_u *)".cc");
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001194 else // location list window
Bram Moolenaard12f5c12006-01-25 22:10:52 +00001195 do_cmdline_cmd((char_u *)".ll");
Bram Moolenaar071d4272004-06-13 20:20:40 +00001196 break;
1197 }
1198#endif
1199#ifdef FEAT_CMDWIN
1200 if (cmdwin_type != 0)
1201 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001202 // Execute the command in the cmdline window.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001203 cmdwin_result = CAR;
1204 goto doESCkey;
1205 }
1206#endif
Bram Moolenaarf2732452018-06-03 14:47:35 +02001207#ifdef FEAT_JOB_CHANNEL
1208 if (bt_prompt(curbuf))
1209 {
Bram Moolenaarf2732452018-06-03 14:47:35 +02001210 invoke_prompt_callback();
Bram Moolenaar891e1fd2018-06-06 18:02:39 +02001211 if (!bt_prompt(curbuf))
1212 // buffer changed to a non-prompt buffer, get out of
1213 // Insert mode
Bram Moolenaarf2732452018-06-03 14:47:35 +02001214 goto doESCkey;
1215 break;
1216 }
1217#endif
Bram Moolenaar24a2d722018-04-24 19:36:43 +02001218 if (ins_eol(c) == FAIL && !p_im)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001219 goto doESCkey; // out of memory
Bram Moolenaar071d4272004-06-13 20:20:40 +00001220 auto_format(FALSE, FALSE);
1221 inserted_space = FALSE;
1222 break;
1223
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001224 case Ctrl_K: // digraph or keyword completion
Bram Moolenaar7591bb32019-03-30 13:53:47 +01001225 if (ctrl_x_mode_dictionary())
Bram Moolenaar071d4272004-06-13 20:20:40 +00001226 {
Bram Moolenaar4be06f92005-07-29 22:36:03 +00001227 if (has_compl_option(TRUE))
1228 goto docomplete;
1229 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001230 }
Bram Moolenaare2c453d2019-08-21 14:37:09 +02001231#ifdef FEAT_DIGRAPHS
Bram Moolenaar071d4272004-06-13 20:20:40 +00001232 c = ins_digraph();
1233 if (c == NUL)
1234 break;
Bram Moolenaar4be06f92005-07-29 22:36:03 +00001235#endif
Bram Moolenaare2c453d2019-08-21 14:37:09 +02001236 goto normalchar;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001237
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001238 case Ctrl_X: // Enter CTRL-X mode
Bram Moolenaar572cb562005-08-05 21:35:02 +00001239 ins_ctrl_x();
1240 break;
1241
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001242 case Ctrl_RSB: // Tag name completion after ^X
Bram Moolenaar7591bb32019-03-30 13:53:47 +01001243 if (!ctrl_x_mode_tags())
Bram Moolenaar071d4272004-06-13 20:20:40 +00001244 goto normalchar;
1245 goto docomplete;
1246
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001247 case Ctrl_F: // File name completion after ^X
Bram Moolenaar7591bb32019-03-30 13:53:47 +01001248 if (!ctrl_x_mode_files())
Bram Moolenaar071d4272004-06-13 20:20:40 +00001249 goto normalchar;
1250 goto docomplete;
Bram Moolenaar488c6512005-08-11 20:09:58 +00001251
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001252 case 's': // Spelling completion after ^X
Bram Moolenaar488c6512005-08-11 20:09:58 +00001253 case Ctrl_S:
Bram Moolenaar7591bb32019-03-30 13:53:47 +01001254 if (!ctrl_x_mode_spell())
Bram Moolenaar488c6512005-08-11 20:09:58 +00001255 goto normalchar;
1256 goto docomplete;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001257
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001258 case Ctrl_L: // Whole line completion after ^X
Bram Moolenaar7591bb32019-03-30 13:53:47 +01001259 if (!ctrl_x_mode_whole_line())
Bram Moolenaar071d4272004-06-13 20:20:40 +00001260 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001261 // CTRL-L with 'insertmode' set: Leave Insert mode
Bram Moolenaar071d4272004-06-13 20:20:40 +00001262 if (p_im)
1263 {
1264 if (echeck_abbr(Ctrl_L + ABBR_OFF))
1265 break;
1266 goto doESCkey;
1267 }
1268 goto normalchar;
1269 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001270 // FALLTHROUGH
Bram Moolenaar071d4272004-06-13 20:20:40 +00001271
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001272 case Ctrl_P: // Do previous/next pattern completion
Bram Moolenaar071d4272004-06-13 20:20:40 +00001273 case Ctrl_N:
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001274 // if 'complete' is empty then plain ^P is no longer special,
1275 // but it is under other ^X modes
Bram Moolenaar071d4272004-06-13 20:20:40 +00001276 if (*curbuf->b_p_cpt == NUL
Bram Moolenaar7591bb32019-03-30 13:53:47 +01001277 && (ctrl_x_mode_normal() || ctrl_x_mode_whole_line())
Yegappan Lakshmanand94fbfc2022-01-04 17:01:44 +00001278 && !compl_status_local())
Bram Moolenaar071d4272004-06-13 20:20:40 +00001279 goto normalchar;
1280
1281docomplete:
Bram Moolenaar031e0dd2009-07-09 16:15:16 +00001282 compl_busy = TRUE;
Bram Moolenaara6c07602017-03-05 21:18:27 +01001283#ifdef FEAT_FOLDING
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001284 disable_fold_update++; // don't redraw folds here
Bram Moolenaara6c07602017-03-05 21:18:27 +01001285#endif
Bram Moolenaar8aefbe02016-02-23 20:13:16 +01001286 if (ins_complete(c, TRUE) == FAIL)
Yegappan Lakshmanand94fbfc2022-01-04 17:01:44 +00001287 compl_status_clear();
Bram Moolenaara6c07602017-03-05 21:18:27 +01001288#ifdef FEAT_FOLDING
Bram Moolenaar429fcfb2016-04-14 16:22:04 +02001289 disable_fold_update--;
Bram Moolenaara6c07602017-03-05 21:18:27 +01001290#endif
Bram Moolenaar031e0dd2009-07-09 16:15:16 +00001291 compl_busy = FALSE;
Bram Moolenaarde5cf282022-05-14 11:52:23 +01001292 can_si = may_do_si(); // allow smartindenting
Bram Moolenaar071d4272004-06-13 20:20:40 +00001293 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001294
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001295 case Ctrl_Y: // copy from previous line or scroll down
1296 case Ctrl_E: // copy from next line or scroll up
Bram Moolenaar4be06f92005-07-29 22:36:03 +00001297 c = ins_ctrl_ey(c);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001298 break;
1299
1300 default:
1301#ifdef UNIX
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001302 if (c == intr_char) // special interrupt char
Bram Moolenaar071d4272004-06-13 20:20:40 +00001303 goto do_intr;
1304#endif
1305
Bram Moolenaare659c952011-05-19 17:25:41 +02001306normalchar:
Bram Moolenaar071d4272004-06-13 20:20:40 +00001307 /*
Bram Moolenaar84a05ac2013-05-06 04:24:17 +02001308 * Insert a normal character.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001309 */
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01001310#if defined(FEAT_EVAL)
Bram Moolenaare659c952011-05-19 17:25:41 +02001311 if (!p_paste)
1312 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001313 // Trigger InsertCharPre.
Bram Moolenaarf5876f12012-02-29 18:22:08 +01001314 char_u *str = do_insert_char_pre(c);
1315 char_u *p;
1316
1317 if (str != NULL)
Bram Moolenaare659c952011-05-19 17:25:41 +02001318 {
Bram Moolenaarf5876f12012-02-29 18:22:08 +01001319 if (*str != NUL && stop_arrow() != FAIL)
Bram Moolenaare659c952011-05-19 17:25:41 +02001320 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001321 // Insert the new value of v:char literally.
Bram Moolenaar91acfff2017-03-12 19:22:36 +01001322 for (p = str; *p != NUL; MB_PTR_ADV(p))
Bram Moolenaare659c952011-05-19 17:25:41 +02001323 {
Bram Moolenaarf5876f12012-02-29 18:22:08 +01001324 c = PTR2CHAR(p);
1325 if (c == CAR || c == K_KENTER || c == NL)
1326 ins_eol(c);
1327 else
1328 ins_char(c);
Bram Moolenaare659c952011-05-19 17:25:41 +02001329 }
Bram Moolenaarf5876f12012-02-29 18:22:08 +01001330 AppendToRedobuffLit(str, -1);
Bram Moolenaare659c952011-05-19 17:25:41 +02001331 }
Bram Moolenaarf5876f12012-02-29 18:22:08 +01001332 vim_free(str);
1333 c = NUL;
Bram Moolenaare659c952011-05-19 17:25:41 +02001334 }
1335
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001336 // If the new value is already inserted or an empty string
1337 // then don't insert any character.
Bram Moolenaare659c952011-05-19 17:25:41 +02001338 if (c == NUL)
1339 break;
1340 }
1341#endif
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001342 // Try to perform smart-indenting.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001343 ins_try_si(c);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001344
1345 if (c == ' ')
1346 {
1347 inserted_space = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001348 if (inindent(0))
1349 can_cindent = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001350 if (Insstart_blank_vcol == MAXCOL
1351 && curwin->w_cursor.lnum == Insstart.lnum)
1352 Insstart_blank_vcol = get_nolist_virtcol();
1353 }
1354
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001355 // Insert a normal character and check for abbreviations on a
1356 // special character. Let CTRL-] expand abbreviations without
1357 // inserting it.
Bram Moolenaare0ebfd72012-04-05 16:07:06 +02001358 if (vim_iswordc(c) || (!echeck_abbr(
Bram Moolenaar13505972019-01-24 15:04:48 +01001359 // Add ABBR_OFF for characters above 0x100, this is
1360 // what check_abbr() expects.
1361 (has_mbyte && c >= 0x100) ? (c + ABBR_OFF) : c)
1362 && c != Ctrl_RSB))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001363 {
1364 insert_special(c, FALSE, FALSE);
1365#ifdef FEAT_RIGHTLEFT
1366 revins_legal++;
1367 revins_chars++;
1368#endif
1369 }
1370
1371 auto_format(FALSE, TRUE);
1372
1373#ifdef FEAT_FOLDING
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001374 // When inserting a character the cursor line must never be in a
1375 // closed fold.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001376 foldOpenCursor();
1377#endif
1378 break;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001379 } // end of switch (c)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001380
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001381 // If typed something may trigger CursorHoldI again.
Bram Moolenaar245c4102016-04-20 17:37:41 +02001382 if (c != K_CURSORHOLD
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01001383#ifdef FEAT_COMPL_FUNC
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001384 // but not in CTRL-X mode, a script can't restore the state
Bram Moolenaar7591bb32019-03-30 13:53:47 +01001385 && ctrl_x_mode_normal()
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01001386#endif
Bram Moolenaar245c4102016-04-20 17:37:41 +02001387 )
Bram Moolenaard29a9ee2006-09-14 09:07:34 +00001388 did_cursorhold = FALSE;
Bram Moolenaard29a9ee2006-09-14 09:07:34 +00001389
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001390 // If the cursor was moved we didn't just insert a space
Bram Moolenaar071d4272004-06-13 20:20:40 +00001391 if (arrow_used)
1392 inserted_space = FALSE;
1393
Bram Moolenaare2c453d2019-08-21 14:37:09 +02001394 if (can_cindent && cindent_on() && ctrl_x_mode_normal())
Bram Moolenaar071d4272004-06-13 20:20:40 +00001395 {
1396force_cindent:
1397 /*
1398 * Indent now if a key was typed that is in 'cinkeys'.
1399 */
1400 if (in_cinkeys(c, ' ', line_is_white))
1401 {
1402 if (stop_arrow() == OK)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001403 // re-indent the current line
Bram Moolenaar071d4272004-06-13 20:20:40 +00001404 do_c_expr_indent();
1405 }
1406 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001407
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001408 } // for (;;)
1409 // NOTREACHED
Bram Moolenaar071d4272004-06-13 20:20:40 +00001410}
1411
Bram Moolenaar7591bb32019-03-30 13:53:47 +01001412 int
1413ins_need_undo_get(void)
1414{
1415 return ins_need_undo;
1416}
1417
Bram Moolenaar071d4272004-06-13 20:20:40 +00001418/*
1419 * Redraw for Insert mode.
1420 * This is postponed until getting the next character to make '$' in the 'cpo'
1421 * option work correctly.
1422 * Only redraw when there are no characters available. This speeds up
1423 * inserting sequences of characters (e.g., for CTRL-R).
1424 */
Bram Moolenaar7591bb32019-03-30 13:53:47 +01001425 void
Bram Moolenaar3397f742019-06-02 18:40:06 +02001426ins_redraw(int ready) // not busy with something
Bram Moolenaar071d4272004-06-13 20:20:40 +00001427{
Bram Moolenaarb2c03502010-07-02 20:20:09 +02001428#ifdef FEAT_CONCEAL
1429 linenr_T conceal_old_cursor_line = 0;
1430 linenr_T conceal_new_cursor_line = 0;
1431 int conceal_update_lines = FALSE;
1432#endif
1433
Bram Moolenaare21b6b22014-01-14 12:17:02 +01001434 if (char_avail())
1435 return;
1436
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001437 // Trigger CursorMoved if the cursor moved. Not when the popup menu is
1438 // visible, the command might delete it.
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01001439 if (ready && (has_cursormovedI()
Bram Moolenaar05ad5ff2019-11-30 22:48:27 +01001440# ifdef FEAT_PROP_POPUP
Bram Moolenaar3397f742019-06-02 18:40:06 +02001441 || popup_visible
1442# endif
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01001443# if defined(FEAT_CONCEAL)
1444 || curwin->w_p_cole > 0
Bram Moolenaarb2c03502010-07-02 20:20:09 +02001445# endif
Bram Moolenaare21b6b22014-01-14 12:17:02 +01001446 )
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01001447 && !EQUAL_POS(last_cursormoved, curwin->w_cursor)
Bram Moolenaare2c453d2019-08-21 14:37:09 +02001448 && !pum_visible())
Bram Moolenaare21b6b22014-01-14 12:17:02 +01001449 {
1450# ifdef FEAT_SYN_HL
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001451 // Need to update the screen first, to make sure syntax
1452 // highlighting is correct after making a change (e.g., inserting
1453 // a "(". The autocommand may also require a redraw, so it's done
1454 // again below, unfortunately.
Bram Moolenaare21b6b22014-01-14 12:17:02 +01001455 if (syntax_present(curwin) && must_redraw)
1456 update_screen(0);
1457# endif
Bram Moolenaare21b6b22014-01-14 12:17:02 +01001458 if (has_cursormovedI())
Bram Moolenaarf068dca2016-02-09 21:24:46 +01001459 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001460 // Make sure curswant is correct, an autocommand may call
1461 // getcurpos().
Bram Moolenaarf068dca2016-02-09 21:24:46 +01001462 update_curswant();
Bram Moolenaar9fa95062018-08-08 22:08:32 +02001463 ins_apply_autocmds(EVENT_CURSORMOVEDI);
Bram Moolenaarf068dca2016-02-09 21:24:46 +01001464 }
Bram Moolenaar05ad5ff2019-11-30 22:48:27 +01001465#ifdef FEAT_PROP_POPUP
Bram Moolenaar3397f742019-06-02 18:40:06 +02001466 if (popup_visible)
1467 popup_check_cursor_pos();
1468#endif
Bram Moolenaare21b6b22014-01-14 12:17:02 +01001469# ifdef FEAT_CONCEAL
1470 if (curwin->w_p_cole > 0)
1471 {
1472 conceal_old_cursor_line = last_cursormoved.lnum;
1473 conceal_new_cursor_line = curwin->w_cursor.lnum;
1474 conceal_update_lines = TRUE;
1475 }
1476# endif
1477 last_cursormoved = curwin->w_cursor;
1478 }
Bram Moolenaare21b6b22014-01-14 12:17:02 +01001479
Christian Brabandtdb3b4462021-10-16 11:58:55 +01001480 // Trigger TextChangedI if b_changedtick_i differs.
Bram Moolenaare21b6b22014-01-14 12:17:02 +01001481 if (ready && has_textchangedI()
Christian Brabandtdb3b4462021-10-16 11:58:55 +01001482 && curbuf->b_last_changedtick_i != CHANGEDTICK(curbuf)
Bram Moolenaare2c453d2019-08-21 14:37:09 +02001483 && !pum_visible())
Bram Moolenaare21b6b22014-01-14 12:17:02 +01001484 {
Bram Moolenaar6ba3ec12018-06-16 15:32:38 +02001485 aco_save_T aco;
Bram Moolenaar9fa95062018-08-08 22:08:32 +02001486 varnumber_T tick = CHANGEDTICK(curbuf);
Bram Moolenaar91d2e782018-08-07 19:05:01 +02001487
Bram Moolenaar6ba3ec12018-06-16 15:32:38 +02001488 // save and restore curwin and curbuf, in case the autocmd changes them
1489 aucmd_prepbuf(&aco, curbuf);
Bram Moolenaar5a093432018-02-10 18:15:19 +01001490 apply_autocmds(EVENT_TEXTCHANGEDI, NULL, NULL, FALSE, curbuf);
Bram Moolenaar6ba3ec12018-06-16 15:32:38 +02001491 aucmd_restbuf(&aco);
Christian Brabandtdb3b4462021-10-16 11:58:55 +01001492 curbuf->b_last_changedtick_i = CHANGEDTICK(curbuf);
Bram Moolenaar9fa95062018-08-08 22:08:32 +02001493 if (tick != CHANGEDTICK(curbuf)) // see ins_apply_autocmds()
1494 u_save(curwin->w_cursor.lnum,
1495 (linenr_T)(curwin->w_cursor.lnum + 1));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001496 }
Bram Moolenaar5a093432018-02-10 18:15:19 +01001497
Christian Brabandtdb3b4462021-10-16 11:58:55 +01001498 // Trigger TextChangedP if b_changedtick_pum differs. When the popupmenu
1499 // closes TextChangedI will need to trigger for backwards compatibility,
1500 // thus use different b_last_changedtick* variables.
Bram Moolenaar5a093432018-02-10 18:15:19 +01001501 if (ready && has_textchangedP()
1502 && curbuf->b_last_changedtick_pum != CHANGEDTICK(curbuf)
1503 && pum_visible())
1504 {
Bram Moolenaar6ba3ec12018-06-16 15:32:38 +02001505 aco_save_T aco;
Bram Moolenaar9fa95062018-08-08 22:08:32 +02001506 varnumber_T tick = CHANGEDTICK(curbuf);
Bram Moolenaar6ba3ec12018-06-16 15:32:38 +02001507
1508 // save and restore curwin and curbuf, in case the autocmd changes them
1509 aucmd_prepbuf(&aco, curbuf);
Bram Moolenaar5a093432018-02-10 18:15:19 +01001510 apply_autocmds(EVENT_TEXTCHANGEDP, NULL, NULL, FALSE, curbuf);
Bram Moolenaar6ba3ec12018-06-16 15:32:38 +02001511 aucmd_restbuf(&aco);
Bram Moolenaar5a093432018-02-10 18:15:19 +01001512 curbuf->b_last_changedtick_pum = CHANGEDTICK(curbuf);
Bram Moolenaar9fa95062018-08-08 22:08:32 +02001513 if (tick != CHANGEDTICK(curbuf)) // see ins_apply_autocmds()
1514 u_save(curwin->w_cursor.lnum,
1515 (linenr_T)(curwin->w_cursor.lnum + 1));
Bram Moolenaar5a093432018-02-10 18:15:19 +01001516 }
Bram Moolenaare21b6b22014-01-14 12:17:02 +01001517
LemonBoy09371822022-04-08 15:18:45 +01001518 if (ready)
zeertzjqd58862d2022-04-12 11:32:48 +01001519 may_trigger_winscrolled();
LemonBoy09371822022-04-08 15:18:45 +01001520
Bram Moolenaar8aeec402019-09-15 23:02:04 +02001521 // Trigger SafeState if nothing is pending.
1522 may_trigger_safestate(ready
1523 && !ins_compl_active()
1524 && !pum_visible());
1525
Bram Moolenaar535d5b62019-01-11 20:45:36 +01001526#if defined(FEAT_CONCEAL)
Bram Moolenaare21b6b22014-01-14 12:17:02 +01001527 if ((conceal_update_lines
1528 && (conceal_old_cursor_line != conceal_new_cursor_line
1529 || conceal_cursor_line(curwin)))
1530 || need_cursor_line_redraw)
1531 {
1532 if (conceal_old_cursor_line != conceal_new_cursor_line)
Bram Moolenaar535d5b62019-01-11 20:45:36 +01001533 redrawWinline(curwin, conceal_old_cursor_line);
1534 redrawWinline(curwin, conceal_new_cursor_line == 0
1535 ? curwin->w_cursor.lnum : conceal_new_cursor_line);
Bram Moolenaare21b6b22014-01-14 12:17:02 +01001536 curwin->w_valid &= ~VALID_CROW;
Bram Moolenaar535d5b62019-01-11 20:45:36 +01001537 need_cursor_line_redraw = FALSE;
Bram Moolenaare21b6b22014-01-14 12:17:02 +01001538 }
Bram Moolenaar535d5b62019-01-11 20:45:36 +01001539#endif
1540 if (must_redraw)
1541 update_screen(0);
1542 else if (clear_cmdline || redraw_cmdline)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001543 showmode(); // clear cmdline and show mode
Bram Moolenaare21b6b22014-01-14 12:17:02 +01001544 showruler(FALSE);
1545 setcursor();
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001546 emsg_on_display = FALSE; // may remove error message now
Bram Moolenaar071d4272004-06-13 20:20:40 +00001547}
1548
1549/*
1550 * Handle a CTRL-V or CTRL-Q typed in Insert mode.
1551 */
1552 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01001553ins_ctrl_v(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001554{
1555 int c;
Bram Moolenaar9c520cb2011-05-10 14:22:16 +02001556 int did_putchar = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001557
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001558 // may need to redraw when no more chars available now
Bram Moolenaar754b5602006-02-09 23:53:20 +00001559 ins_redraw(FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001560
1561 if (redrawing() && !char_avail())
Bram Moolenaar9c520cb2011-05-10 14:22:16 +02001562 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00001563 edit_putchar('^', TRUE);
Bram Moolenaar9c520cb2011-05-10 14:22:16 +02001564 did_putchar = TRUE;
1565 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001566 AppendToRedobuff((char_u *)CTRL_V_STR); // CTRL-V
Bram Moolenaar071d4272004-06-13 20:20:40 +00001567
1568#ifdef FEAT_CMDL_INFO
1569 add_to_showcmd_c(Ctrl_V);
1570#endif
1571
Bram Moolenaar0684e362020-12-03 19:54:42 +01001572 // Do not change any modifyOtherKeys ESC sequence to a normal key for
1573 // CTRL-SHIFT-V.
1574 c = get_literal(mod_mask & MOD_MASK_SHIFT);
Bram Moolenaar9c520cb2011-05-10 14:22:16 +02001575 if (did_putchar)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001576 // when the line fits in 'columns' the '^' is at the start of the next
1577 // line and will not removed by the redraw
Bram Moolenaar9c520cb2011-05-10 14:22:16 +02001578 edit_unputchar();
Bram Moolenaar071d4272004-06-13 20:20:40 +00001579#ifdef FEAT_CMDL_INFO
1580 clear_showcmd();
1581#endif
Bram Moolenaarfc4ea2a2019-11-26 19:33:22 +01001582
Bram Moolenaar071d4272004-06-13 20:20:40 +00001583 insert_special(c, FALSE, TRUE);
1584#ifdef FEAT_RIGHTLEFT
1585 revins_chars++;
1586 revins_legal++;
1587#endif
1588}
1589
1590/*
Bram Moolenaarfc4ea2a2019-11-26 19:33:22 +01001591 * After getting an ESC or CSI for a literal key: If the typeahead buffer
1592 * contains a modifyOtherKeys sequence then decode it and return the result.
1593 * Otherwise return "c".
1594 * Note that this doesn't wait for characters, they must be in the typeahead
1595 * buffer already.
1596 */
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02001597 static int
Bram Moolenaarfc4ea2a2019-11-26 19:33:22 +01001598decodeModifyOtherKeys(int c)
1599{
1600 char_u *p = typebuf.tb_buf + typebuf.tb_off;
1601 int idx;
1602 int form = 0;
1603 int argidx = 0;
1604 int arg[2] = {0, 0};
1605
1606 // Recognize:
1607 // form 0: {lead}{key};{modifier}u
1608 // form 1: {lead}27;{modifier};{key}~
Bram Moolenaar82aa6e02021-01-17 22:04:02 +01001609 if (typebuf.tb_len >= 4 && (c == CSI || (c == ESC && *p == '[')))
Bram Moolenaarfc4ea2a2019-11-26 19:33:22 +01001610 {
1611 idx = (*p == '[');
1612 if (p[idx] == '2' && p[idx + 1] == '7' && p[idx + 2] == ';')
1613 {
1614 form = 1;
1615 idx += 3;
1616 }
1617 while (idx < typebuf.tb_len && argidx < 2)
1618 {
1619 if (p[idx] == ';')
1620 ++argidx;
1621 else if (VIM_ISDIGIT(p[idx]))
1622 arg[argidx] = arg[argidx] * 10 + (p[idx] - '0');
1623 else
1624 break;
1625 ++idx;
1626 }
1627 if (idx < typebuf.tb_len
1628 && p[idx] == (form == 1 ? '~' : 'u')
1629 && argidx == 1)
1630 {
1631 // Match, consume the code.
1632 typebuf.tb_off += idx + 1;
1633 typebuf.tb_len -= idx + 1;
Bram Moolenaare49b4bb2020-03-11 13:01:40 +01001634#if defined(FEAT_CLIENTSERVER) || defined(FEAT_EVAL)
1635 if (typebuf.tb_len == 0)
1636 typebuf_was_filled = FALSE;
1637#endif
Bram Moolenaarfc4ea2a2019-11-26 19:33:22 +01001638
1639 mod_mask = decode_modifiers(arg[!form]);
Bram Moolenaar975a8802020-06-06 22:36:24 +02001640 c = merge_modifyOtherKeys(arg[form], &mod_mask);
Bram Moolenaarfc4ea2a2019-11-26 19:33:22 +01001641 }
1642 }
1643
1644 return c;
1645}
1646
1647/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00001648 * Put a character directly onto the screen. It's not stored in a buffer.
1649 * Used while handling CTRL-K, CTRL-V, etc. in Insert mode.
1650 */
1651static int pc_status;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001652#define PC_STATUS_UNSET 0 // pc_bytes was not set
Dominique Pelleaf4a61a2021-12-27 17:21:41 +00001653#define PC_STATUS_RIGHT 1 // right half of double-wide char
1654#define PC_STATUS_LEFT 2 // left half of double-wide char
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001655#define PC_STATUS_SET 3 // pc_bytes was filled
1656static char_u pc_bytes[MB_MAXBYTES + 1]; // saved bytes
Bram Moolenaar071d4272004-06-13 20:20:40 +00001657static int pc_attr;
1658static int pc_row;
1659static int pc_col;
1660
1661 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01001662edit_putchar(int c, int highlight)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001663{
1664 int attr;
1665
1666 if (ScreenLines != NULL)
1667 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001668 update_topline(); // just in case w_topline isn't valid
Bram Moolenaar071d4272004-06-13 20:20:40 +00001669 validate_cursor();
1670 if (highlight)
Bram Moolenaar8820b482017-03-16 17:23:31 +01001671 attr = HL_ATTR(HLF_8);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001672 else
1673 attr = 0;
1674 pc_row = W_WINROW(curwin) + curwin->w_wrow;
Bram Moolenaar53f81742017-09-22 14:35:51 +02001675 pc_col = curwin->w_wincol;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001676 pc_status = PC_STATUS_UNSET;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001677#ifdef FEAT_RIGHTLEFT
1678 if (curwin->w_p_rl)
1679 {
Bram Moolenaar02631462017-09-22 15:20:32 +02001680 pc_col += curwin->w_width - 1 - curwin->w_wcol;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001681 if (has_mbyte)
1682 {
1683 int fix_col = mb_fix_col(pc_col, pc_row);
1684
1685 if (fix_col != pc_col)
1686 {
1687 screen_putchar(' ', pc_row, fix_col, attr);
1688 --curwin->w_wcol;
1689 pc_status = PC_STATUS_RIGHT;
1690 }
1691 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001692 }
1693 else
1694#endif
1695 {
1696 pc_col += curwin->w_wcol;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001697 if (mb_lefthalve(pc_row, pc_col))
1698 pc_status = PC_STATUS_LEFT;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001699 }
1700
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001701 // save the character to be able to put it back
Bram Moolenaar071d4272004-06-13 20:20:40 +00001702 if (pc_status == PC_STATUS_UNSET)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001703 {
1704 screen_getbytes(pc_row, pc_col, pc_bytes, &pc_attr);
1705 pc_status = PC_STATUS_SET;
1706 }
1707 screen_putchar(c, pc_row, pc_col, attr);
1708 }
1709}
1710
Dominique Pelle748b3082022-01-08 12:41:16 +00001711#if defined(FEAT_JOB_CHANNEL) || defined(PROTO)
Bram Moolenaarf2732452018-06-03 14:47:35 +02001712/*
Bram Moolenaar8b5866d2020-09-05 15:48:51 +02001713 * Set the insert start position for when using a prompt buffer.
Bram Moolenaar077cc7a2020-09-04 16:35:35 +02001714 */
Bram Moolenaar8b5866d2020-09-05 15:48:51 +02001715 void
1716set_insstart(linenr_T lnum, int col)
Bram Moolenaar077cc7a2020-09-04 16:35:35 +02001717{
Bram Moolenaar8b5866d2020-09-05 15:48:51 +02001718 Insstart.lnum = lnum;
1719 Insstart.col = col;
1720 Insstart_orig = Insstart;
1721 Insstart_textlen = Insstart.col;
1722 Insstart_blank_vcol = MAXCOL;
1723 arrow_used = FALSE;
Bram Moolenaar077cc7a2020-09-04 16:35:35 +02001724}
Dominique Pelle748b3082022-01-08 12:41:16 +00001725#endif
Bram Moolenaar077cc7a2020-09-04 16:35:35 +02001726
1727/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00001728 * Undo the previous edit_putchar().
1729 */
1730 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01001731edit_unputchar(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001732{
1733 if (pc_status != PC_STATUS_UNSET && pc_row >= msg_scrolled)
1734 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00001735 if (pc_status == PC_STATUS_RIGHT)
1736 ++curwin->w_wcol;
1737 if (pc_status == PC_STATUS_RIGHT || pc_status == PC_STATUS_LEFT)
Bram Moolenaarae12f4b2019-01-09 20:51:04 +01001738 redrawWinline(curwin, curwin->w_cursor.lnum);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001739 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00001740 screen_puts(pc_bytes, pc_row - msg_scrolled, pc_col, pc_attr);
1741 }
1742}
1743
1744/*
1745 * Called when p_dollar is set: display a '$' at the end of the changed text
1746 * Only works when cursor is in the line that changes.
1747 */
1748 void
Bram Moolenaare98c88c2022-08-16 14:51:53 +01001749display_dollar(colnr_T col_arg)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001750{
Bram Moolenaare98c88c2022-08-16 14:51:53 +01001751 colnr_T col = col_arg < 0 ? 0 : col_arg;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001752 colnr_T save_col;
1753
1754 if (!redrawing())
1755 return;
1756
1757 cursor_off();
1758 save_col = curwin->w_cursor.col;
1759 curwin->w_cursor.col = col;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001760 if (has_mbyte)
1761 {
1762 char_u *p;
1763
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001764 // If on the last byte of a multi-byte move to the first byte.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001765 p = ml_get_curline();
1766 curwin->w_cursor.col -= (*mb_head_off)(p, p + col);
1767 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001768 curs_columns(FALSE); // recompute w_wrow and w_wcol
Bram Moolenaar02631462017-09-22 15:20:32 +02001769 if (curwin->w_wcol < curwin->w_width)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001770 {
1771 edit_putchar('$', FALSE);
1772 dollar_vcol = curwin->w_virtcol;
1773 }
1774 curwin->w_cursor.col = save_col;
1775}
1776
1777/*
1778 * Call this function before moving the cursor from the normal insert position
1779 * in insert mode.
1780 */
Bram Moolenaarb20b9e12019-09-21 20:48:04 +02001781 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01001782undisplay_dollar(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001783{
Bram Moolenaar76b9b362012-02-04 23:35:00 +01001784 if (dollar_vcol >= 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001785 {
Bram Moolenaar76b9b362012-02-04 23:35:00 +01001786 dollar_vcol = -1;
Bram Moolenaarae12f4b2019-01-09 20:51:04 +01001787 redrawWinline(curwin, curwin->w_cursor.lnum);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001788 }
1789}
1790
1791/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00001792 * Truncate the space at the end of a line. This is to be used only in an
Bram Moolenaar24959102022-05-07 20:01:16 +01001793 * insert mode. It handles fixing the replace stack for MODE_REPLACE and
1794 * MODE_VREPLACE modes.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001795 */
1796 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01001797truncate_spaces(char_u *line)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001798{
1799 int i;
1800
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001801 // find start of trailing white space
Bram Moolenaar1c465442017-03-12 20:10:05 +01001802 for (i = (int)STRLEN(line) - 1; i >= 0 && VIM_ISWHITE(line[i]); i--)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001803 {
1804 if (State & REPLACE_FLAG)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001805 replace_join(0); // remove a NUL from the replace stack
Bram Moolenaar071d4272004-06-13 20:20:40 +00001806 }
1807 line[i + 1] = NUL;
1808}
1809
Bram Moolenaar071d4272004-06-13 20:20:40 +00001810/*
Bram Moolenaar24959102022-05-07 20:01:16 +01001811 * Backspace the cursor until the given column. Handles MODE_REPLACE and
1812 * MODE_VREPLACE modes correctly. May also be used when not in insert mode at
1813 * all. Will attempt not to go before "col" even when there is a composing
Bram Moolenaar0f6c9482009-01-13 11:29:48 +00001814 * character.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001815 */
1816 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01001817backspace_until_column(int col)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001818{
1819 while ((int)curwin->w_cursor.col > col)
1820 {
1821 curwin->w_cursor.col--;
1822 if (State & REPLACE_FLAG)
Bram Moolenaar0f6c9482009-01-13 11:29:48 +00001823 replace_do_bs(col);
1824 else if (!del_char_after_col(col))
1825 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001826 }
1827}
Bram Moolenaar071d4272004-06-13 20:20:40 +00001828
Bram Moolenaar0f6c9482009-01-13 11:29:48 +00001829/*
1830 * Like del_char(), but make sure not to go before column "limit_col".
1831 * Only matters when there are composing characters.
1832 * Return TRUE when something was deleted.
1833 */
1834 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01001835del_char_after_col(int limit_col UNUSED)
Bram Moolenaar0f6c9482009-01-13 11:29:48 +00001836{
Bram Moolenaar0f6c9482009-01-13 11:29:48 +00001837 if (enc_utf8 && limit_col >= 0)
1838 {
Bram Moolenaar0ab2a882009-05-13 10:51:08 +00001839 colnr_T ecol = curwin->w_cursor.col + 1;
Bram Moolenaar0f6c9482009-01-13 11:29:48 +00001840
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001841 // Make sure the cursor is at the start of a character, but
1842 // skip forward again when going too far back because of a
1843 // composing character.
Bram Moolenaar0f6c9482009-01-13 11:29:48 +00001844 mb_adjust_cursor();
Bram Moolenaar5b3e4602009-02-04 10:20:58 +00001845 while (curwin->w_cursor.col < (colnr_T)limit_col)
Bram Moolenaar0f6c9482009-01-13 11:29:48 +00001846 {
1847 int l = utf_ptr2len(ml_get_cursor());
1848
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001849 if (l == 0) // end of line
Bram Moolenaar0f6c9482009-01-13 11:29:48 +00001850 break;
1851 curwin->w_cursor.col += l;
1852 }
1853 if (*ml_get_cursor() == NUL || curwin->w_cursor.col == ecol)
1854 return FALSE;
Bram Moolenaar0ab2a882009-05-13 10:51:08 +00001855 del_bytes((long)((int)ecol - curwin->w_cursor.col), FALSE, TRUE);
Bram Moolenaar0f6c9482009-01-13 11:29:48 +00001856 }
1857 else
Bram Moolenaar0f6c9482009-01-13 11:29:48 +00001858 (void)del_char(FALSE);
1859 return TRUE;
1860}
1861
Bram Moolenaar071d4272004-06-13 20:20:40 +00001862/*
1863 * Next character is interpreted literally.
1864 * A one, two or three digit decimal number is interpreted as its byte value.
1865 * If one or two digits are entered, the next character is given to vungetc().
1866 * For Unicode a character > 255 may be returned.
Bram Moolenaar0684e362020-12-03 19:54:42 +01001867 * If "noReduceKeys" is TRUE do not change any modifyOtherKeys ESC sequence
1868 * into a normal key, return ESC.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001869 */
1870 int
Bram Moolenaar0684e362020-12-03 19:54:42 +01001871get_literal(int noReduceKeys)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001872{
1873 int cc;
1874 int nc;
1875 int i;
1876 int hex = FALSE;
1877 int octal = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001878 int unicode = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001879
1880 if (got_int)
1881 return Ctrl_C;
1882
1883#ifdef FEAT_GUI
1884 /*
1885 * In GUI there is no point inserting the internal code for a special key.
1886 * It is more useful to insert the string "<KEY>" instead. This would
1887 * probably be useful in a text window too, but it would not be
1888 * vi-compatible (maybe there should be an option for it?) -- webb
1889 */
1890 if (gui.in_use)
zeertzjqbad8a012022-04-29 16:44:00 +01001891 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00001892 ++allow_keys;
zeertzjqbad8a012022-04-29 16:44:00 +01001893 if (noReduceKeys)
1894 ++no_reduce_keys;
1895 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001896#endif
1897#ifdef USE_ON_FLY_SCROLL
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001898 dont_scroll = TRUE; // disallow scrolling here
Bram Moolenaar071d4272004-06-13 20:20:40 +00001899#endif
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001900 ++no_mapping; // don't map the next key hits
Bram Moolenaar071d4272004-06-13 20:20:40 +00001901 cc = 0;
1902 i = 0;
1903 for (;;)
1904 {
Bram Moolenaar61abfd12007-09-13 16:26:47 +00001905 nc = plain_vgetc();
Bram Moolenaar0684e362020-12-03 19:54:42 +01001906 if ((nc == ESC || nc == CSI) && !noReduceKeys)
1907 nc = decodeModifyOtherKeys(nc);
1908
zeertzjq502d8ae2022-01-24 15:27:50 +00001909 if ((mod_mask & ~MOD_MASK_SHIFT) != 0)
1910 // A character with non-Shift modifiers should not be a valid
1911 // character for i_CTRL-V_digit.
1912 break;
1913
Bram Moolenaar071d4272004-06-13 20:20:40 +00001914#ifdef FEAT_CMDL_INFO
Bram Moolenaar24959102022-05-07 20:01:16 +01001915 if ((State & MODE_CMDLINE) == 0 && MB_BYTE2LEN_CHECK(nc) == 1)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001916 add_to_showcmd(nc);
1917#endif
1918 if (nc == 'x' || nc == 'X')
1919 hex = TRUE;
1920 else if (nc == 'o' || nc == 'O')
1921 octal = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001922 else if (nc == 'u' || nc == 'U')
1923 unicode = nc;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001924 else
1925 {
Bram Moolenaar13505972019-01-24 15:04:48 +01001926 if (hex || unicode != 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001927 {
1928 if (!vim_isxdigit(nc))
1929 break;
1930 cc = cc * 16 + hex2nr(nc);
1931 }
1932 else if (octal)
1933 {
1934 if (nc < '0' || nc > '7')
1935 break;
1936 cc = cc * 8 + nc - '0';
1937 }
1938 else
1939 {
1940 if (!VIM_ISDIGIT(nc))
1941 break;
1942 cc = cc * 10 + nc - '0';
1943 }
1944
1945 ++i;
1946 }
1947
Bram Moolenaar13505972019-01-24 15:04:48 +01001948 if (cc > 255 && unicode == 0)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001949 cc = 255; // limit range to 0-255
Bram Moolenaar071d4272004-06-13 20:20:40 +00001950 nc = 0;
1951
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001952 if (hex) // hex: up to two chars
Bram Moolenaar071d4272004-06-13 20:20:40 +00001953 {
1954 if (i >= 2)
1955 break;
1956 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001957 else if (unicode) // Unicode: up to four or eight chars
Bram Moolenaar071d4272004-06-13 20:20:40 +00001958 {
1959 if ((unicode == 'u' && i >= 4) || (unicode == 'U' && i >= 8))
1960 break;
1961 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001962 else if (i >= 3) // decimal or octal: up to three chars
Bram Moolenaar071d4272004-06-13 20:20:40 +00001963 break;
1964 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001965 if (i == 0) // no number entered
Bram Moolenaar071d4272004-06-13 20:20:40 +00001966 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001967 if (nc == K_ZERO) // NUL is stored as NL
Bram Moolenaar071d4272004-06-13 20:20:40 +00001968 {
1969 cc = '\n';
1970 nc = 0;
1971 }
1972 else
1973 {
1974 cc = nc;
1975 nc = 0;
1976 }
1977 }
1978
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001979 if (cc == 0) // NUL is stored as NL
Bram Moolenaar071d4272004-06-13 20:20:40 +00001980 cc = '\n';
Bram Moolenaar217ad922005-03-20 22:37:15 +00001981 if (enc_dbcs && (cc & 0xff) == 0)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001982 cc = '?'; // don't accept an illegal DBCS char, the NUL in the
1983 // second byte will cause trouble!
Bram Moolenaar071d4272004-06-13 20:20:40 +00001984
1985 --no_mapping;
1986#ifdef FEAT_GUI
1987 if (gui.in_use)
zeertzjqbad8a012022-04-29 16:44:00 +01001988 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00001989 --allow_keys;
zeertzjqbad8a012022-04-29 16:44:00 +01001990 if (noReduceKeys)
1991 --no_reduce_keys;
1992 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001993#endif
1994 if (nc)
zeertzjq502d8ae2022-01-24 15:27:50 +00001995 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00001996 vungetc(nc);
zeertzjq502d8ae2022-01-24 15:27:50 +00001997 // A character typed with i_CTRL-V_digit cannot have modifiers.
1998 mod_mask = 0;
1999 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002000 got_int = FALSE; // CTRL-C typed after CTRL-V is not an interrupt
Bram Moolenaar071d4272004-06-13 20:20:40 +00002001 return cc;
2002}
2003
2004/*
2005 * Insert character, taking care of special keys and mod_mask
2006 */
2007 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01002008insert_special(
2009 int c,
2010 int allow_modmask,
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002011 int ctrlv) // c was typed after CTRL-V
Bram Moolenaar071d4272004-06-13 20:20:40 +00002012{
2013 char_u *p;
2014 int len;
2015
2016 /*
2017 * Special function key, translate into "<Key>". Up to the last '>' is
2018 * inserted with ins_str(), so as not to replace characters in replace
2019 * mode.
2020 * Only use mod_mask for special keys, to avoid things like <S-Space>,
2021 * unless 'allow_modmask' is TRUE.
2022 */
Bram Moolenaard0573012017-10-28 21:11:06 +02002023#ifdef MACOS_X
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002024 // Command-key never produces a normal key
Bram Moolenaar071d4272004-06-13 20:20:40 +00002025 if (mod_mask & MOD_MASK_CMD)
2026 allow_modmask = TRUE;
2027#endif
2028 if (IS_SPECIAL(c) || (mod_mask && allow_modmask))
2029 {
2030 p = get_special_key_name(c, mod_mask);
2031 len = (int)STRLEN(p);
2032 c = p[len - 1];
2033 if (len > 2)
2034 {
2035 if (stop_arrow() == FAIL)
2036 return;
2037 p[len - 1] = NUL;
2038 ins_str(p);
Bram Moolenaarebefac62005-12-28 22:39:57 +00002039 AppendToRedobuffLit(p, -1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002040 ctrlv = FALSE;
2041 }
2042 }
2043 if (stop_arrow() == OK)
2044 insertchar(c, ctrlv ? INSCHAR_CTRLV : 0, -1);
2045}
2046
2047/*
2048 * Special characters in this context are those that need processing other
2049 * than the simple insertion that can be performed here. This includes ESC
2050 * which terminates the insert, and CR/NL which need special processing to
2051 * open up a new line. This routine tries to optimize insertions performed by
2052 * the "redo", "undo" or "put" commands, so it needs to know when it should
2053 * stop and defer processing to the "normal" mechanism.
2054 * '0' and '^' are special, because they can be followed by CTRL-D.
2055 */
Bram Moolenaar424bcae2022-01-31 14:59:41 +00002056#define ISSPECIAL(c) ((c) < ' ' || (c) >= DEL || (c) == '0' || (c) == '^')
Bram Moolenaar071d4272004-06-13 20:20:40 +00002057
Bram Moolenaarbfe3bf82012-06-13 17:28:55 +02002058/*
2059 * "flags": INSCHAR_FORMAT - force formatting
2060 * INSCHAR_CTRLV - char typed just after CTRL-V
2061 * INSCHAR_NO_FEX - don't use 'formatexpr'
2062 *
2063 * NOTE: passes the flags value straight through to internal_format() which,
2064 * beside INSCHAR_FORMAT (above), is also looking for these:
2065 * INSCHAR_DO_COM - format comments
2066 * INSCHAR_COM_LIST - format comments with num list or 2nd line indent
2067 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002068 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01002069insertchar(
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002070 int c, // character to insert or NUL
2071 int flags, // INSCHAR_FORMAT, etc.
2072 int second_indent) // indent for second line if >= 0
Bram Moolenaar071d4272004-06-13 20:20:40 +00002073{
Bram Moolenaar071d4272004-06-13 20:20:40 +00002074 int textwidth;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002075 char_u *p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002076 int fo_ins_blank;
Bram Moolenaar0f8dd842015-03-08 14:48:49 +01002077 int force_format = flags & INSCHAR_FORMAT;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002078
Bram Moolenaar0f8dd842015-03-08 14:48:49 +01002079 textwidth = comp_textwidth(force_format);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002080 fo_ins_blank = has_format_option(FO_INS_BLANK);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002081
2082 /*
2083 * Try to break the line in two or more pieces when:
2084 * - Always do this if we have been called to do formatting only.
2085 * - Always do this when 'formatoptions' has the 'a' flag and the line
2086 * ends in white space.
2087 * - Otherwise:
2088 * - Don't do this if inserting a blank
2089 * - Don't do this if an existing character is being replaced, unless
Bram Moolenaar24959102022-05-07 20:01:16 +01002090 * we're in MODE_VREPLACE state.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002091 * - Do this if the cursor is not on the line where insert started
2092 * or - 'formatoptions' doesn't have 'l' or the line was not too long
2093 * before the insert.
2094 * - 'formatoptions' doesn't have 'b' or a blank was inserted at or
2095 * before 'textwidth'
2096 */
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00002097 if (textwidth > 0
Bram Moolenaar0f8dd842015-03-08 14:48:49 +01002098 && (force_format
Bram Moolenaar1c465442017-03-12 20:10:05 +01002099 || (!VIM_ISWHITE(c)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002100 && !((State & REPLACE_FLAG)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002101 && !(State & VREPLACE_FLAG)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002102 && *ml_get_cursor() != NUL)
2103 && (curwin->w_cursor.lnum != Insstart.lnum
2104 || ((!has_format_option(FO_INS_LONG)
2105 || Insstart_textlen <= (colnr_T)textwidth)
2106 && (!fo_ins_blank
2107 || Insstart_blank_vcol <= (colnr_T)textwidth
2108 ))))))
2109 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002110 // Format with 'formatexpr' when it's set. Use internal formatting
2111 // when 'formatexpr' isn't set or it returns non-zero.
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00002112#if defined(FEAT_EVAL)
Bram Moolenaar0f8dd842015-03-08 14:48:49 +01002113 int do_internal = TRUE;
2114 colnr_T virtcol = get_nolist_virtcol()
2115 + char2cells(c != NUL ? c : gchar_cursor());
Bram Moolenaarf3442e72006-10-10 13:49:10 +00002116
Bram Moolenaar0f8dd842015-03-08 14:48:49 +01002117 if (*curbuf->b_p_fex != NUL && (flags & INSCHAR_NO_FEX) == 0
2118 && (force_format || virtcol > (colnr_T)textwidth))
Bram Moolenaarf3442e72006-10-10 13:49:10 +00002119 {
2120 do_internal = (fex_format(curwin->w_cursor.lnum, 1L, c) != 0);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002121 // It may be required to save for undo again, e.g. when setline()
2122 // was called.
Bram Moolenaarf3442e72006-10-10 13:49:10 +00002123 ins_need_undo = TRUE;
2124 }
2125 if (do_internal)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002126#endif
Bram Moolenaar97b98102009-11-17 16:41:01 +00002127 internal_format(textwidth, second_indent, flags, c == NUL, c);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002128 }
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00002129
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002130 if (c == NUL) // only formatting was wanted
Bram Moolenaar071d4272004-06-13 20:20:40 +00002131 return;
2132
Bram Moolenaar8c96af92019-09-28 19:05:57 +02002133 // Check whether this character should end a comment.
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +00002134 if (did_ai && c == end_comment_pending)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002135 {
2136 char_u *line;
Bram Moolenaar8c96af92019-09-28 19:05:57 +02002137 char_u lead_end[COM_MAX_LEN]; // end-comment string
Bram Moolenaar071d4272004-06-13 20:20:40 +00002138 int middle_len, end_len;
2139 int i;
2140
2141 /*
2142 * Need to remove existing (middle) comment leader and insert end
2143 * comment leader. First, check what comment leader we can find.
2144 */
Bram Moolenaar81340392012-06-06 16:12:59 +02002145 i = get_leader_len(line = ml_get_curline(), &p, FALSE, TRUE);
Bram Moolenaar8c96af92019-09-28 19:05:57 +02002146 if (i > 0 && vim_strchr(p, COM_MIDDLE) != NULL) // Just checking
Bram Moolenaar071d4272004-06-13 20:20:40 +00002147 {
Bram Moolenaar8c96af92019-09-28 19:05:57 +02002148 // Skip middle-comment string
2149 while (*p && p[-1] != ':') // find end of middle flags
Bram Moolenaar071d4272004-06-13 20:20:40 +00002150 ++p;
2151 middle_len = copy_option_part(&p, lead_end, COM_MAX_LEN, ",");
Bram Moolenaar8c96af92019-09-28 19:05:57 +02002152 // Don't count trailing white space for middle_len
Bram Moolenaar1c465442017-03-12 20:10:05 +01002153 while (middle_len > 0 && VIM_ISWHITE(lead_end[middle_len - 1]))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002154 --middle_len;
2155
Bram Moolenaar8c96af92019-09-28 19:05:57 +02002156 // Find the end-comment string
2157 while (*p && p[-1] != ':') // find end of end flags
Bram Moolenaar071d4272004-06-13 20:20:40 +00002158 ++p;
2159 end_len = copy_option_part(&p, lead_end, COM_MAX_LEN, ",");
2160
Bram Moolenaar8c96af92019-09-28 19:05:57 +02002161 // Skip white space before the cursor
Bram Moolenaar071d4272004-06-13 20:20:40 +00002162 i = curwin->w_cursor.col;
Bram Moolenaar1c465442017-03-12 20:10:05 +01002163 while (--i >= 0 && VIM_ISWHITE(line[i]))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002164 ;
2165 i++;
2166
Bram Moolenaar8c96af92019-09-28 19:05:57 +02002167 // Skip to before the middle leader
Bram Moolenaar071d4272004-06-13 20:20:40 +00002168 i -= middle_len;
2169
Bram Moolenaar8c96af92019-09-28 19:05:57 +02002170 // Check some expected things before we go on
Bram Moolenaar071d4272004-06-13 20:20:40 +00002171 if (i >= 0 && lead_end[end_len - 1] == end_comment_pending)
2172 {
Bram Moolenaar8c96af92019-09-28 19:05:57 +02002173 // Backspace over all the stuff we want to replace
Bram Moolenaar071d4272004-06-13 20:20:40 +00002174 backspace_until_column(i);
2175
Bram Moolenaar8c96af92019-09-28 19:05:57 +02002176 // Insert the end-comment string, except for the last
2177 // character, which will get inserted as normal later.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002178 ins_bytes_len(lead_end, end_len - 1);
2179 }
2180 }
2181 }
2182 end_comment_pending = NUL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002183
2184 did_ai = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002185 did_si = FALSE;
2186 can_si = FALSE;
2187 can_si_back = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002188
2189 /*
2190 * If there's any pending input, grab up to INPUT_BUFLEN at once.
2191 * This speeds up normal text input considerably.
2192 * Don't do this when 'cindent' or 'indentexpr' is set, because we might
2193 * need to re-indent at a ':', or any other character (but not what
2194 * 'paste' is set)..
Bram Moolenaarf5876f12012-02-29 18:22:08 +01002195 * Don't do this when there an InsertCharPre autocommand is defined,
2196 * because we need to fire the event for every character.
Bram Moolenaar39de9522018-05-08 22:48:00 +02002197 * Do the check for InsertCharPre before the call to vpeekc() because the
2198 * InsertCharPre autocommand could change the input buffer.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002199 */
2200#ifdef USE_ON_FLY_SCROLL
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002201 dont_scroll = FALSE; // allow scrolling here
Bram Moolenaar071d4272004-06-13 20:20:40 +00002202#endif
2203
2204 if ( !ISSPECIAL(c)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002205 && (!has_mbyte || (*mb_char2len)(c) == 1)
Bram Moolenaar39de9522018-05-08 22:48:00 +02002206 && !has_insertcharpre()
Bram Moolenaar071d4272004-06-13 20:20:40 +00002207 && vpeekc() != NUL
2208 && !(State & REPLACE_FLAG)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002209 && !cindent_on()
Bram Moolenaar071d4272004-06-13 20:20:40 +00002210#ifdef FEAT_RIGHTLEFT
2211 && !p_ri
2212#endif
Bram Moolenaar39de9522018-05-08 22:48:00 +02002213 )
Bram Moolenaar071d4272004-06-13 20:20:40 +00002214 {
2215#define INPUT_BUFLEN 100
2216 char_u buf[INPUT_BUFLEN + 1];
2217 int i;
2218 colnr_T virtcol = 0;
2219
2220 buf[0] = c;
2221 i = 1;
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00002222 if (textwidth > 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002223 virtcol = get_nolist_virtcol();
2224 /*
2225 * Stop the string when:
2226 * - no more chars available
2227 * - finding a special character (command key)
2228 * - buffer is full
2229 * - running into the 'textwidth' boundary
2230 * - need to check for abbreviation: A non-word char after a word-char
2231 */
2232 while ( (c = vpeekc()) != NUL
2233 && !ISSPECIAL(c)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002234 && (!has_mbyte || MB_BYTE2LEN_CHECK(c) == 1)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002235 && i < INPUT_BUFLEN
2236 && (textwidth == 0
2237 || (virtcol += byte2cells(buf[i - 1])) < (colnr_T)textwidth)
2238 && !(!no_abbr && !vim_iswordc(c) && vim_iswordc(buf[i - 1])))
2239 {
2240#ifdef FEAT_RIGHTLEFT
2241 c = vgetc();
2242 if (p_hkmap && KeyTyped)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002243 c = hkmap(c); // Hebrew mode mapping
Bram Moolenaar071d4272004-06-13 20:20:40 +00002244 buf[i++] = c;
2245#else
2246 buf[i++] = vgetc();
2247#endif
2248 }
2249
2250#ifdef FEAT_DIGRAPHS
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002251 do_digraph(-1); // clear digraphs
2252 do_digraph(buf[i-1]); // may be the start of a digraph
Bram Moolenaar071d4272004-06-13 20:20:40 +00002253#endif
2254 buf[i] = NUL;
2255 ins_str(buf);
2256 if (flags & INSCHAR_CTRLV)
2257 {
2258 redo_literal(*buf);
2259 i = 1;
2260 }
2261 else
2262 i = 0;
2263 if (buf[i] != NUL)
Bram Moolenaarebefac62005-12-28 22:39:57 +00002264 AppendToRedobuffLit(buf + i, -1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002265 }
2266 else
2267 {
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00002268 int cc;
2269
Bram Moolenaar071d4272004-06-13 20:20:40 +00002270 if (has_mbyte && (cc = (*mb_char2len)(c)) > 1)
2271 {
2272 char_u buf[MB_MAXBYTES + 1];
2273
2274 (*mb_char2bytes)(c, buf);
2275 buf[cc] = NUL;
2276 ins_char_bytes(buf, cc);
2277 AppendCharToRedobuff(c);
2278 }
2279 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00002280 {
2281 ins_char(c);
2282 if (flags & INSCHAR_CTRLV)
2283 redo_literal(c);
2284 else
2285 AppendCharToRedobuff(c);
2286 }
2287 }
2288}
2289
2290/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00002291 * Put a character in the redo buffer, for when just after a CTRL-V.
2292 */
2293 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01002294redo_literal(int c)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002295{
2296 char_u buf[10];
2297
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002298 // Only digits need special treatment. Translate them into a string of
2299 // three digits.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002300 if (VIM_ISDIGIT(c))
2301 {
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00002302 vim_snprintf((char *)buf, sizeof(buf), "%03d", c);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002303 AppendToRedobuff(buf);
2304 }
2305 else
2306 AppendCharToRedobuff(c);
2307}
2308
2309/*
2310 * start_arrow() is called when an arrow key is used in insert mode.
Bram Moolenaar8aff23a2005-08-19 20:40:30 +00002311 * For undo/redo it resembles hitting the <ESC> key.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002312 */
Bram Moolenaar7591bb32019-03-30 13:53:47 +01002313 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01002314start_arrow(
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002315 pos_T *end_insert_pos) // can be NULL
Bram Moolenaar071d4272004-06-13 20:20:40 +00002316{
Bram Moolenaar8b5f65a2015-09-01 19:26:12 +02002317 start_arrow_common(end_insert_pos, TRUE);
2318}
2319
2320/*
2321 * Like start_arrow() but with end_change argument.
2322 * Will prepare for redo of CTRL-G U if "end_change" is FALSE.
2323 */
2324 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01002325start_arrow_with_change(
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002326 pos_T *end_insert_pos, // can be NULL
2327 int end_change) // end undoable change
Bram Moolenaar8b5f65a2015-09-01 19:26:12 +02002328{
2329 start_arrow_common(end_insert_pos, end_change);
2330 if (!end_change)
2331 {
2332 AppendCharToRedobuff(Ctrl_G);
2333 AppendCharToRedobuff('U');
2334 }
2335}
2336
2337 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01002338start_arrow_common(
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002339 pos_T *end_insert_pos, // can be NULL
2340 int end_change) // end undoable change
Bram Moolenaar8b5f65a2015-09-01 19:26:12 +02002341{
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002342 if (!arrow_used && end_change) // something has been inserted
Bram Moolenaar071d4272004-06-13 20:20:40 +00002343 {
2344 AppendToRedobuff(ESC_STR);
Bram Moolenaarf332a652013-11-04 04:20:33 +01002345 stop_insert(end_insert_pos, FALSE, FALSE);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002346 arrow_used = TRUE; // this means we stopped the current insert
Bram Moolenaar071d4272004-06-13 20:20:40 +00002347 }
Bram Moolenaarb9a02fc2006-03-12 22:08:12 +00002348#ifdef FEAT_SPELL
Bram Moolenaar217ad922005-03-20 22:37:15 +00002349 check_spell_redraw();
2350#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002351}
2352
Bram Moolenaarb9a02fc2006-03-12 22:08:12 +00002353#ifdef FEAT_SPELL
Bram Moolenaar217ad922005-03-20 22:37:15 +00002354/*
2355 * If we skipped highlighting word at cursor, do it now.
2356 * It may be skipped again, thus reset spell_redraw_lnum first.
2357 */
2358 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01002359check_spell_redraw(void)
Bram Moolenaar217ad922005-03-20 22:37:15 +00002360{
2361 if (spell_redraw_lnum != 0)
2362 {
2363 linenr_T lnum = spell_redraw_lnum;
2364
2365 spell_redraw_lnum = 0;
Bram Moolenaarae12f4b2019-01-09 20:51:04 +01002366 redrawWinline(curwin, lnum);
Bram Moolenaar217ad922005-03-20 22:37:15 +00002367 }
2368}
Bram Moolenaar8aff23a2005-08-19 20:40:30 +00002369
Bram Moolenaar217ad922005-03-20 22:37:15 +00002370#endif
2371
Bram Moolenaar071d4272004-06-13 20:20:40 +00002372/*
2373 * stop_arrow() is called before a change is made in insert mode.
2374 * If an arrow key has been used, start a new insertion.
2375 * Returns FAIL if undo is impossible, shouldn't insert then.
2376 */
2377 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01002378stop_arrow(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002379{
2380 if (arrow_used)
2381 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002382 Insstart = curwin->w_cursor; // new insertion starts here
Bram Moolenaar1fc7e972014-08-16 18:13:03 +02002383 if (Insstart.col > Insstart_orig.col && !ins_need_undo)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002384 // Don't update the original insert position when moved to the
2385 // right, except when nothing was inserted yet.
Bram Moolenaar1fc7e972014-08-16 18:13:03 +02002386 update_Insstart_orig = FALSE;
2387 Insstart_textlen = (colnr_T)linetabsize(ml_get_curline());
2388
Bram Moolenaar071d4272004-06-13 20:20:40 +00002389 if (u_save_cursor() == OK)
2390 {
2391 arrow_used = FALSE;
2392 ins_need_undo = FALSE;
2393 }
Bram Moolenaar1fc7e972014-08-16 18:13:03 +02002394
Bram Moolenaar071d4272004-06-13 20:20:40 +00002395 ai_col = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002396 if (State & VREPLACE_FLAG)
2397 {
2398 orig_line_count = curbuf->b_ml.ml_line_count;
2399 vr_lines_changed = 1;
2400 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002401 ResetRedobuff();
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002402 AppendToRedobuff((char_u *)"1i"); // pretend we start an insertion
Bram Moolenaara9b1e742005-12-19 22:14:58 +00002403 new_insert_skip = 2;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002404 }
2405 else if (ins_need_undo)
2406 {
2407 if (u_save_cursor() == OK)
2408 ins_need_undo = FALSE;
2409 }
2410
2411#ifdef FEAT_FOLDING
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002412 // Always open fold at the cursor line when inserting something.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002413 foldOpenCursor();
2414#endif
2415
2416 return (arrow_used || ins_need_undo ? FAIL : OK);
2417}
2418
2419/*
Bram Moolenaareb3593b2006-04-22 22:33:57 +00002420 * Do a few things to stop inserting.
2421 * "end_insert_pos" is where insert ended. It is NULL when we already jumped
2422 * to another window/buffer.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002423 */
2424 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01002425stop_insert(
2426 pos_T *end_insert_pos,
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002427 int esc, // called by ins_esc()
2428 int nomove) // <c-\><c-o>, don't move cursor
Bram Moolenaar071d4272004-06-13 20:20:40 +00002429{
Bram Moolenaar83c465c2005-12-16 21:53:56 +00002430 int cc;
2431 char_u *ptr;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002432
2433 stop_redo_ins();
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002434 replace_flush(); // abandon replace stack
Bram Moolenaar071d4272004-06-13 20:20:40 +00002435
2436 /*
Bram Moolenaar83c465c2005-12-16 21:53:56 +00002437 * Save the inserted text for later redo with ^@ and CTRL-A.
2438 * Don't do it when "restart_edit" was set and nothing was inserted,
2439 * otherwise CTRL-O w and then <Left> will clear "last_insert".
Bram Moolenaar071d4272004-06-13 20:20:40 +00002440 */
Bram Moolenaar83c465c2005-12-16 21:53:56 +00002441 ptr = get_inserted();
Bram Moolenaarf4cd3e82005-12-22 22:47:02 +00002442 if (did_restart_edit == 0 || (ptr != NULL
2443 && (int)STRLEN(ptr) > new_insert_skip))
Bram Moolenaar83c465c2005-12-16 21:53:56 +00002444 {
2445 vim_free(last_insert);
2446 last_insert = ptr;
2447 last_insert_skip = new_insert_skip;
2448 }
2449 else
2450 vim_free(ptr);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002451
Bram Moolenaareb3593b2006-04-22 22:33:57 +00002452 if (!arrow_used && end_insert_pos != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002453 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002454 // Auto-format now. It may seem strange to do this when stopping an
2455 // insertion (or moving the cursor), but it's required when appending
2456 // a line and having it end in a space. But only do it when something
2457 // was actually inserted, otherwise undo won't work.
Bram Moolenaarf4b8e572004-06-24 15:53:16 +00002458 if (!ins_need_undo && has_format_option(FO_AUTO))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002459 {
Bram Moolenaarf4b8e572004-06-24 15:53:16 +00002460 pos_T tpos = curwin->w_cursor;
2461
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002462 // When the cursor is at the end of the line after a space the
2463 // formatting will move it to the following word. Avoid that by
2464 // moving the cursor onto the space.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002465 cc = 'x';
2466 if (curwin->w_cursor.col > 0 && gchar_cursor() == NUL)
2467 {
2468 dec_cursor();
2469 cc = gchar_cursor();
Bram Moolenaar1c465442017-03-12 20:10:05 +01002470 if (!VIM_ISWHITE(cc))
Bram Moolenaarf4b8e572004-06-24 15:53:16 +00002471 curwin->w_cursor = tpos;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002472 }
2473
2474 auto_format(TRUE, FALSE);
2475
Bram Moolenaar1c465442017-03-12 20:10:05 +01002476 if (VIM_ISWHITE(cc))
Bram Moolenaarf4b8e572004-06-24 15:53:16 +00002477 {
2478 if (gchar_cursor() != NUL)
2479 inc_cursor();
Bram Moolenaar29ddebe2019-01-26 17:28:26 +01002480 // If the cursor is still at the same character, also keep
2481 // the "coladd".
Bram Moolenaarf4b8e572004-06-24 15:53:16 +00002482 if (gchar_cursor() == NUL
2483 && curwin->w_cursor.lnum == tpos.lnum
2484 && curwin->w_cursor.col == tpos.col)
2485 curwin->w_cursor.coladd = tpos.coladd;
Bram Moolenaarf4b8e572004-06-24 15:53:16 +00002486 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002487 }
2488
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002489 // If a space was inserted for auto-formatting, remove it now.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002490 check_auto_format(TRUE);
2491
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002492 // If we just did an auto-indent, remove the white space from the end
2493 // of the line, and put the cursor back.
2494 // Do this when ESC was used or moving the cursor up/down.
2495 // Check for the old position still being valid, just in case the text
2496 // got changed unexpectedly.
Bram Moolenaarf332a652013-11-04 04:20:33 +01002497 if (!nomove && did_ai && (esc || (vim_strchr(p_cpo, CPO_INDENT) == NULL
Bram Moolenaar4be50682009-05-26 09:02:10 +00002498 && curwin->w_cursor.lnum != end_insert_pos->lnum))
2499 && end_insert_pos->lnum <= curbuf->b_ml.ml_line_count)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002500 {
Bram Moolenaarf4b8e572004-06-24 15:53:16 +00002501 pos_T tpos = curwin->w_cursor;
2502
2503 curwin->w_cursor = *end_insert_pos;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002504 check_cursor_col(); // make sure it is not past the line
Bram Moolenaar39f05632006-03-19 22:15:26 +00002505 for (;;)
2506 {
2507 if (gchar_cursor() == NUL && curwin->w_cursor.col > 0)
2508 --curwin->w_cursor.col;
2509 cc = gchar_cursor();
Bram Moolenaar1c465442017-03-12 20:10:05 +01002510 if (!VIM_ISWHITE(cc))
Bram Moolenaar39f05632006-03-19 22:15:26 +00002511 break;
Bram Moolenaar4be50682009-05-26 09:02:10 +00002512 if (del_char(TRUE) == FAIL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002513 break; // should not happen
Bram Moolenaar39f05632006-03-19 22:15:26 +00002514 }
Bram Moolenaarf4b8e572004-06-24 15:53:16 +00002515 if (curwin->w_cursor.lnum != tpos.lnum)
2516 curwin->w_cursor = tpos;
Bram Moolenaar2f31e392014-10-31 19:20:36 +01002517 else
2518 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002519 // reset tpos, could have been invalidated in the loop above
Bram Moolenaaref6875b2014-11-12 18:59:25 +01002520 tpos = curwin->w_cursor;
Bram Moolenaar2f31e392014-10-31 19:20:36 +01002521 tpos.col++;
2522 if (cc != NUL && gchar_pos(&tpos) == NUL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002523 ++curwin->w_cursor.col; // put cursor back on the NUL
Bram Moolenaar2f31e392014-10-31 19:20:36 +01002524 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002525
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002526 // <C-S-Right> may have started Visual mode, adjust the position for
2527 // deleted characters.
Bram Moolenaar7ce5b2b2022-05-16 19:40:59 +01002528 if (VIsual_active)
2529 check_visual_pos();
Bram Moolenaar071d4272004-06-13 20:20:40 +00002530 }
2531 }
2532 did_ai = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002533 did_si = FALSE;
2534 can_si = FALSE;
2535 can_si_back = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002536
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002537 // Set '[ and '] to the inserted text. When end_insert_pos is NULL we are
2538 // now in a different buffer.
Bram Moolenaareb3593b2006-04-22 22:33:57 +00002539 if (end_insert_pos != NULL)
2540 {
2541 curbuf->b_op_start = Insstart;
Bram Moolenaarb1d90a32014-02-22 23:03:55 +01002542 curbuf->b_op_start_orig = Insstart_orig;
Bram Moolenaareb3593b2006-04-22 22:33:57 +00002543 curbuf->b_op_end = *end_insert_pos;
2544 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002545}
2546
2547/*
2548 * Set the last inserted text to a single character.
2549 * Used for the replace command.
2550 */
2551 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01002552set_last_insert(int c)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002553{
2554 char_u *s;
2555
2556 vim_free(last_insert);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002557 last_insert = alloc(MB_MAXBYTES * 3 + 5);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002558 if (last_insert != NULL)
2559 {
2560 s = last_insert;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002561 // Use the CTRL-V only when entering a special char
Bram Moolenaar071d4272004-06-13 20:20:40 +00002562 if (c < ' ' || c == DEL)
2563 *s++ = Ctrl_V;
2564 s = add_char2buf(c, s);
2565 *s++ = ESC;
2566 *s++ = NUL;
2567 last_insert_skip = 0;
2568 }
2569}
2570
Bram Moolenaarf461c8e2005-06-25 23:04:51 +00002571#if defined(EXITFREE) || defined(PROTO)
2572 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01002573free_last_insert(void)
Bram Moolenaarf461c8e2005-06-25 23:04:51 +00002574{
Bram Moolenaard23a8232018-02-10 18:45:26 +01002575 VIM_CLEAR(last_insert);
Bram Moolenaarf461c8e2005-06-25 23:04:51 +00002576}
2577#endif
2578
Bram Moolenaar071d4272004-06-13 20:20:40 +00002579/*
2580 * Add character "c" to buffer "s". Escape the special meaning of K_SPECIAL
2581 * and CSI. Handle multi-byte characters.
2582 * Returns a pointer to after the added bytes.
2583 */
2584 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01002585add_char2buf(int c, char_u *s)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002586{
Bram Moolenaar9a920d82012-06-01 15:21:02 +02002587 char_u temp[MB_MAXBYTES + 1];
Bram Moolenaar071d4272004-06-13 20:20:40 +00002588 int i;
2589 int len;
2590
2591 len = (*mb_char2bytes)(c, temp);
2592 for (i = 0; i < len; ++i)
2593 {
2594 c = temp[i];
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002595 // Need to escape K_SPECIAL and CSI like in the typeahead buffer.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002596 if (c == K_SPECIAL)
2597 {
2598 *s++ = K_SPECIAL;
2599 *s++ = KS_SPECIAL;
2600 *s++ = KE_FILLER;
2601 }
2602#ifdef FEAT_GUI
2603 else if (c == CSI)
2604 {
2605 *s++ = CSI;
2606 *s++ = KS_EXTRA;
2607 *s++ = (int)KE_CSI;
2608 }
2609#endif
2610 else
2611 *s++ = c;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002612 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002613 return s;
2614}
2615
2616/*
2617 * move cursor to start of line
2618 * if flags & BL_WHITE move to first non-white
2619 * if flags & BL_SOL move to first non-white if startofline is set,
2620 * otherwise keep "curswant" column
2621 * if flags & BL_FIX don't leave the cursor on a NUL.
2622 */
2623 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01002624beginline(int flags)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002625{
2626 if ((flags & BL_SOL) && !p_sol)
2627 coladvance(curwin->w_curswant);
2628 else
2629 {
2630 curwin->w_cursor.col = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002631 curwin->w_cursor.coladd = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002632
2633 if (flags & (BL_WHITE | BL_SOL))
2634 {
2635 char_u *ptr;
2636
Bram Moolenaar1c465442017-03-12 20:10:05 +01002637 for (ptr = ml_get_curline(); VIM_ISWHITE(*ptr)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002638 && !((flags & BL_FIX) && ptr[1] == NUL); ++ptr)
2639 ++curwin->w_cursor.col;
2640 }
2641 curwin->w_set_curswant = TRUE;
2642 }
2643}
2644
2645/*
2646 * oneright oneleft cursor_down cursor_up
2647 *
2648 * Move one char {right,left,down,up}.
Bram Moolenaar2eb25da2006-03-16 21:43:34 +00002649 * Doesn't move onto the NUL past the end of the line, unless it is allowed.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002650 * Return OK when successful, FAIL when we hit a line of file boundary.
2651 */
2652
2653 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01002654oneright(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002655{
2656 char_u *ptr;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002657 int l;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002658
Bram Moolenaar071d4272004-06-13 20:20:40 +00002659 if (virtual_active())
2660 {
2661 pos_T prevpos = curwin->w_cursor;
2662
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002663 // Adjust for multi-wide char (excluding TAB)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002664 ptr = ml_get_cursor();
Bram Moolenaar13505972019-01-24 15:04:48 +01002665 coladvance(getviscol() + ((*ptr != TAB
2666 && vim_isprintc((*mb_ptr2char)(ptr)))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002667 ? ptr2cells(ptr) : 1));
2668 curwin->w_set_curswant = TRUE;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002669 // Return OK if the cursor moved, FAIL otherwise (at window edge).
Bram Moolenaar071d4272004-06-13 20:20:40 +00002670 return (prevpos.col != curwin->w_cursor.col
2671 || prevpos.coladd != curwin->w_cursor.coladd) ? OK : FAIL;
2672 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002673
2674 ptr = ml_get_cursor();
Bram Moolenaar2eb25da2006-03-16 21:43:34 +00002675 if (*ptr == NUL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002676 return FAIL; // already at the very end
Bram Moolenaar2eb25da2006-03-16 21:43:34 +00002677
Bram Moolenaar2eb25da2006-03-16 21:43:34 +00002678 if (has_mbyte)
2679 l = (*mb_ptr2len)(ptr);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002680 else
Bram Moolenaar2eb25da2006-03-16 21:43:34 +00002681 l = 1;
2682
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002683 // move "l" bytes right, but don't end up on the NUL, unless 'virtualedit'
2684 // contains "onemore".
Gary Johnson53ba05b2021-07-26 22:19:10 +02002685 if (ptr[l] == NUL && (get_ve_flags() & VE_ONEMORE) == 0)
Bram Moolenaar2eb25da2006-03-16 21:43:34 +00002686 return FAIL;
2687 curwin->w_cursor.col += l;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002688
2689 curwin->w_set_curswant = TRUE;
2690 return OK;
2691}
2692
2693 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01002694oneleft(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002695{
Bram Moolenaar071d4272004-06-13 20:20:40 +00002696 if (virtual_active())
2697 {
Bram Moolenaar29ddebe2019-01-26 17:28:26 +01002698#ifdef FEAT_LINEBREAK
Bram Moolenaar071d4272004-06-13 20:20:40 +00002699 int width;
Bram Moolenaar29ddebe2019-01-26 17:28:26 +01002700#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002701 int v = getviscol();
2702
2703 if (v == 0)
2704 return FAIL;
2705
Bram Moolenaar29ddebe2019-01-26 17:28:26 +01002706#ifdef FEAT_LINEBREAK
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002707 // We might get stuck on 'showbreak', skip over it.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002708 width = 1;
2709 for (;;)
2710 {
2711 coladvance(v - width);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002712 // getviscol() is slow, skip it when 'showbreak' is empty,
2713 // 'breakindent' is not set and there are no multi-byte
2714 // characters
Bram Moolenaaree857022019-11-09 23:26:40 +01002715 if ((*get_showbreak_value(curwin) == NUL && !curwin->w_p_bri
Bram Moolenaar13505972019-01-24 15:04:48 +01002716 && !has_mbyte) || getviscol() < v)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002717 break;
2718 ++width;
2719 }
Bram Moolenaar29ddebe2019-01-26 17:28:26 +01002720#else
Bram Moolenaar071d4272004-06-13 20:20:40 +00002721 coladvance(v - 1);
Bram Moolenaar29ddebe2019-01-26 17:28:26 +01002722#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002723
2724 if (curwin->w_cursor.coladd == 1)
2725 {
2726 char_u *ptr;
2727
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002728 // Adjust for multi-wide char (not a TAB)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002729 ptr = ml_get_cursor();
Bram Moolenaar13505972019-01-24 15:04:48 +01002730 if (*ptr != TAB && vim_isprintc((*mb_ptr2char)(ptr))
2731 && ptr2cells(ptr) > 1)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002732 curwin->w_cursor.coladd = 0;
2733 }
2734
2735 curwin->w_set_curswant = TRUE;
2736 return OK;
2737 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002738
2739 if (curwin->w_cursor.col == 0)
2740 return FAIL;
2741
2742 curwin->w_set_curswant = TRUE;
2743 --curwin->w_cursor.col;
2744
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002745 // if the character on the left of the current cursor is a multi-byte
2746 // character, move to its first byte
Bram Moolenaar071d4272004-06-13 20:20:40 +00002747 if (has_mbyte)
2748 mb_adjust_cursor();
Bram Moolenaar071d4272004-06-13 20:20:40 +00002749 return OK;
2750}
2751
2752 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01002753cursor_up(
2754 long n,
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002755 int upd_topline) // When TRUE: update topline
Bram Moolenaar071d4272004-06-13 20:20:40 +00002756{
2757 linenr_T lnum;
2758
2759 if (n > 0)
2760 {
2761 lnum = curwin->w_cursor.lnum;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002762 // This fails if the cursor is already in the first line or the count
2763 // is larger than the line number and '-' is in 'cpoptions'
Bram Moolenaar7c626922005-02-07 22:01:03 +00002764 if (lnum <= 1 || (n >= lnum && vim_strchr(p_cpo, CPO_MINUS) != NULL))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002765 return FAIL;
2766 if (n >= lnum)
2767 lnum = 1;
2768 else
2769#ifdef FEAT_FOLDING
2770 if (hasAnyFolding(curwin))
2771 {
2772 /*
2773 * Count each sequence of folded lines as one logical line.
2774 */
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002775 // go to the start of the current fold
Bram Moolenaar071d4272004-06-13 20:20:40 +00002776 (void)hasFolding(lnum, &lnum, NULL);
2777
2778 while (n--)
2779 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002780 // move up one line
Bram Moolenaar071d4272004-06-13 20:20:40 +00002781 --lnum;
2782 if (lnum <= 1)
2783 break;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002784 // If we entered a fold, move to the beginning, unless in
2785 // Insert mode or when 'foldopen' contains "all": it will open
2786 // in a moment.
Bram Moolenaar24959102022-05-07 20:01:16 +01002787 if (n > 0 || !((State & MODE_INSERT) || (fdo_flags & FDO_ALL)))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002788 (void)hasFolding(lnum, &lnum, NULL);
2789 }
2790 if (lnum < 1)
2791 lnum = 1;
2792 }
2793 else
2794#endif
2795 lnum -= n;
2796 curwin->w_cursor.lnum = lnum;
2797 }
2798
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002799 // try to advance to the column we want to be at
Bram Moolenaar071d4272004-06-13 20:20:40 +00002800 coladvance(curwin->w_curswant);
2801
2802 if (upd_topline)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002803 update_topline(); // make sure curwin->w_topline is valid
Bram Moolenaar071d4272004-06-13 20:20:40 +00002804
2805 return OK;
2806}
2807
2808/*
2809 * Cursor down a number of logical lines.
2810 */
2811 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01002812cursor_down(
2813 long n,
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002814 int upd_topline) // When TRUE: update topline
Bram Moolenaar071d4272004-06-13 20:20:40 +00002815{
2816 linenr_T lnum;
2817
2818 if (n > 0)
2819 {
2820 lnum = curwin->w_cursor.lnum;
2821#ifdef FEAT_FOLDING
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002822 // Move to last line of fold, will fail if it's the end-of-file.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002823 (void)hasFolding(lnum, NULL, &lnum);
2824#endif
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002825 // This fails if the cursor is already in the last line or would move
2826 // beyond the last line and '-' is in 'cpoptions'
Bram Moolenaar7c626922005-02-07 22:01:03 +00002827 if (lnum >= curbuf->b_ml.ml_line_count
2828 || (lnum + n > curbuf->b_ml.ml_line_count
2829 && vim_strchr(p_cpo, CPO_MINUS) != NULL))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002830 return FAIL;
2831 if (lnum + n >= curbuf->b_ml.ml_line_count)
2832 lnum = curbuf->b_ml.ml_line_count;
2833 else
2834#ifdef FEAT_FOLDING
2835 if (hasAnyFolding(curwin))
2836 {
2837 linenr_T last;
2838
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002839 // count each sequence of folded lines as one logical line
Bram Moolenaar071d4272004-06-13 20:20:40 +00002840 while (n--)
2841 {
2842 if (hasFolding(lnum, NULL, &last))
2843 lnum = last + 1;
2844 else
2845 ++lnum;
2846 if (lnum >= curbuf->b_ml.ml_line_count)
2847 break;
2848 }
2849 if (lnum > curbuf->b_ml.ml_line_count)
2850 lnum = curbuf->b_ml.ml_line_count;
2851 }
2852 else
2853#endif
2854 lnum += n;
2855 curwin->w_cursor.lnum = lnum;
2856 }
2857
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002858 // try to advance to the column we want to be at
Bram Moolenaar071d4272004-06-13 20:20:40 +00002859 coladvance(curwin->w_curswant);
2860
2861 if (upd_topline)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002862 update_topline(); // make sure curwin->w_topline is valid
Bram Moolenaar071d4272004-06-13 20:20:40 +00002863
2864 return OK;
2865}
2866
2867/*
2868 * Stuff the last inserted text in the read buffer.
2869 * Last_insert actually is a copy of the redo buffer, so we
2870 * first have to remove the command.
2871 */
2872 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01002873stuff_inserted(
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002874 int c, // Command character to be inserted
2875 long count, // Repeat this many times
2876 int no_esc) // Don't add an ESC at the end
Bram Moolenaar071d4272004-06-13 20:20:40 +00002877{
2878 char_u *esc_ptr;
2879 char_u *ptr;
2880 char_u *last_ptr;
2881 char_u last = NUL;
2882
2883 ptr = get_last_insert();
2884 if (ptr == NULL)
2885 {
Bram Moolenaare29a27f2021-07-20 21:07:36 +02002886 emsg(_(e_no_inserted_text_yet));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002887 return FAIL;
2888 }
2889
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002890 // may want to stuff the command character, to start Insert mode
Bram Moolenaar071d4272004-06-13 20:20:40 +00002891 if (c != NUL)
2892 stuffcharReadbuff(c);
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +00002893 if ((esc_ptr = vim_strrchr(ptr, ESC)) != NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002894 *esc_ptr = NUL; // remove the ESC
Bram Moolenaar071d4272004-06-13 20:20:40 +00002895
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002896 // when the last char is either "0" or "^" it will be quoted if no ESC
2897 // comes after it OR if it will inserted more than once and "ptr"
2898 // starts with ^D. -- Acevedo
Bram Moolenaar071d4272004-06-13 20:20:40 +00002899 last_ptr = (esc_ptr ? esc_ptr : ptr + STRLEN(ptr)) - 1;
2900 if (last_ptr >= ptr && (*last_ptr == '0' || *last_ptr == '^')
2901 && (no_esc || (*ptr == Ctrl_D && count > 1)))
2902 {
2903 last = *last_ptr;
2904 *last_ptr = NUL;
2905 }
2906
2907 do
2908 {
2909 stuffReadbuff(ptr);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002910 // a trailing "0" is inserted as "<C-V>048", "^" as "<C-V>^"
Bram Moolenaar071d4272004-06-13 20:20:40 +00002911 if (last)
Bram Moolenaar424bcae2022-01-31 14:59:41 +00002912 stuffReadbuff(
2913 (char_u *)(last == '0' ? "\026\060\064\070" : "\026^"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002914 }
2915 while (--count > 0);
2916
2917 if (last)
2918 *last_ptr = last;
2919
2920 if (esc_ptr != NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002921 *esc_ptr = ESC; // put the ESC back
Bram Moolenaar071d4272004-06-13 20:20:40 +00002922
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002923 // may want to stuff a trailing ESC, to get out of Insert mode
Bram Moolenaar071d4272004-06-13 20:20:40 +00002924 if (!no_esc)
2925 stuffcharReadbuff(ESC);
2926
2927 return OK;
2928}
2929
2930 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01002931get_last_insert(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002932{
2933 if (last_insert == NULL)
2934 return NULL;
2935 return last_insert + last_insert_skip;
2936}
2937
2938/*
2939 * Get last inserted string, and remove trailing <Esc>.
2940 * Returns pointer to allocated memory (must be freed) or NULL.
2941 */
2942 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01002943get_last_insert_save(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002944{
2945 char_u *s;
2946 int len;
2947
2948 if (last_insert == NULL)
2949 return NULL;
2950 s = vim_strsave(last_insert + last_insert_skip);
2951 if (s != NULL)
2952 {
2953 len = (int)STRLEN(s);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002954 if (len > 0 && s[len - 1] == ESC) // remove trailing ESC
Bram Moolenaar071d4272004-06-13 20:20:40 +00002955 s[len - 1] = NUL;
2956 }
2957 return s;
2958}
2959
2960/*
2961 * Check the word in front of the cursor for an abbreviation.
2962 * Called when the non-id character "c" has been entered.
2963 * When an abbreviation is recognized it is removed from the text and
2964 * the replacement string is inserted in typebuf.tb_buf[], followed by "c".
2965 */
2966 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01002967echeck_abbr(int c)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002968{
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002969 // Don't check for abbreviation in paste mode, when disabled and just
2970 // after moving around with cursor keys.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002971 if (p_paste || no_abbr || arrow_used)
2972 return FALSE;
2973
2974 return check_abbr(c, ml_get_curline(), curwin->w_cursor.col,
2975 curwin->w_cursor.lnum == Insstart.lnum ? Insstart.col : 0);
2976}
2977
2978/*
2979 * replace-stack functions
2980 *
2981 * When replacing characters, the replaced characters are remembered for each
2982 * new character. This is used to re-insert the old text when backspacing.
2983 *
2984 * There is a NUL headed list of characters for each character that is
2985 * currently in the file after the insertion point. When BS is used, one NUL
2986 * headed list is put back for the deleted character.
2987 *
2988 * For a newline, there are two NUL headed lists. One contains the characters
2989 * that the NL replaced. The extra one stores the characters after the cursor
2990 * that were deleted (always white space).
2991 *
2992 * Replace_offset is normally 0, in which case replace_push will add a new
2993 * character at the end of the stack. If replace_offset is not 0, that many
2994 * characters will be left on the stack above the newly inserted character.
2995 */
2996
Bram Moolenaar6c0b44b2005-06-01 21:56:33 +00002997static char_u *replace_stack = NULL;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002998static long replace_stack_nr = 0; // next entry in replace stack
2999static long replace_stack_len = 0; // max. number of entries
Bram Moolenaar071d4272004-06-13 20:20:40 +00003000
3001 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01003002replace_push(
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003003 int c) // character that is replaced (NUL is none)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003004{
3005 char_u *p;
3006
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003007 if (replace_stack_nr < replace_offset) // nothing to do
Bram Moolenaar071d4272004-06-13 20:20:40 +00003008 return;
3009 if (replace_stack_len <= replace_stack_nr)
3010 {
3011 replace_stack_len += 50;
Bram Moolenaar3397f742019-06-02 18:40:06 +02003012 p = ALLOC_MULT(char_u, replace_stack_len);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003013 if (p == NULL) // out of memory
Bram Moolenaar071d4272004-06-13 20:20:40 +00003014 {
3015 replace_stack_len -= 50;
3016 return;
3017 }
3018 if (replace_stack != NULL)
3019 {
3020 mch_memmove(p, replace_stack,
3021 (size_t)(replace_stack_nr * sizeof(char_u)));
3022 vim_free(replace_stack);
3023 }
3024 replace_stack = p;
3025 }
3026 p = replace_stack + replace_stack_nr - replace_offset;
3027 if (replace_offset)
3028 mch_memmove(p + 1, p, (size_t)(replace_offset * sizeof(char_u)));
3029 *p = c;
3030 ++replace_stack_nr;
3031}
3032
Bram Moolenaar2c994e82008-01-02 16:49:36 +00003033/*
3034 * Push a character onto the replace stack. Handles a multi-byte character in
3035 * reverse byte order, so that the first byte is popped off first.
3036 * Return the number of bytes done (includes composing characters).
3037 */
3038 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01003039replace_push_mb(char_u *p)
Bram Moolenaar2c994e82008-01-02 16:49:36 +00003040{
3041 int l = (*mb_ptr2len)(p);
3042 int j;
3043
3044 for (j = l - 1; j >= 0; --j)
3045 replace_push(p[j]);
3046 return l;
3047}
Bram Moolenaar2c994e82008-01-02 16:49:36 +00003048
Bram Moolenaar071d4272004-06-13 20:20:40 +00003049/*
3050 * Pop one item from the replace stack.
3051 * return -1 if stack empty
3052 * return replaced character or NUL otherwise
3053 */
3054 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01003055replace_pop(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003056{
3057 if (replace_stack_nr == 0)
3058 return -1;
3059 return (int)replace_stack[--replace_stack_nr];
3060}
3061
3062/*
3063 * Join the top two items on the replace stack. This removes to "off"'th NUL
3064 * encountered.
3065 */
Bram Moolenaar14c01f82019-10-09 22:53:08 +02003066 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01003067replace_join(
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003068 int off) // offset for which NUL to remove
Bram Moolenaar071d4272004-06-13 20:20:40 +00003069{
3070 int i;
3071
3072 for (i = replace_stack_nr; --i >= 0; )
3073 if (replace_stack[i] == NUL && off-- <= 0)
3074 {
3075 --replace_stack_nr;
3076 mch_memmove(replace_stack + i, replace_stack + i + 1,
3077 (size_t)(replace_stack_nr - i));
3078 return;
3079 }
3080}
3081
3082/*
3083 * Pop bytes from the replace stack until a NUL is found, and insert them
Bram Moolenaar24959102022-05-07 20:01:16 +01003084 * before the cursor. Can only be used in MODE_REPLACE or MODE_VREPLACE state.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003085 */
3086 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01003087replace_pop_ins(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003088{
3089 int cc;
3090 int oldState = State;
3091
Bram Moolenaar24959102022-05-07 20:01:16 +01003092 State = MODE_NORMAL; // don't want MODE_REPLACE here
Bram Moolenaar071d4272004-06-13 20:20:40 +00003093 while ((cc = replace_pop()) > 0)
3094 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00003095 mb_replace_pop_ins(cc);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003096 dec_cursor();
3097 }
3098 State = oldState;
3099}
3100
Bram Moolenaar071d4272004-06-13 20:20:40 +00003101/*
3102 * Insert bytes popped from the replace stack. "cc" is the first byte. If it
3103 * indicates a multi-byte char, pop the other bytes too.
3104 */
3105 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01003106mb_replace_pop_ins(int cc)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003107{
3108 int n;
Bram Moolenaar9a920d82012-06-01 15:21:02 +02003109 char_u buf[MB_MAXBYTES + 1];
Bram Moolenaar071d4272004-06-13 20:20:40 +00003110 int i;
3111 int c;
3112
3113 if (has_mbyte && (n = MB_BYTE2LEN(cc)) > 1)
3114 {
3115 buf[0] = cc;
3116 for (i = 1; i < n; ++i)
3117 buf[i] = replace_pop();
3118 ins_bytes_len(buf, n);
3119 }
3120 else
3121 ins_char(cc);
3122
3123 if (enc_utf8)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003124 // Handle composing chars.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003125 for (;;)
3126 {
3127 c = replace_pop();
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003128 if (c == -1) // stack empty
Bram Moolenaar071d4272004-06-13 20:20:40 +00003129 break;
3130 if ((n = MB_BYTE2LEN(c)) == 1)
3131 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003132 // Not a multi-byte char, put it back.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003133 replace_push(c);
3134 break;
3135 }
zeertzjq8c979602022-04-07 15:08:01 +01003136
3137 buf[0] = c;
3138 for (i = 1; i < n; ++i)
3139 buf[i] = replace_pop();
3140 if (utf_iscomposing(utf_ptr2char(buf)))
3141 ins_bytes_len(buf, n);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003142 else
3143 {
zeertzjq8c979602022-04-07 15:08:01 +01003144 // Not a composing char, put it back.
3145 for (i = n - 1; i >= 0; --i)
3146 replace_push(buf[i]);
3147 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003148 }
zeertzjq8c979602022-04-07 15:08:01 +01003149
Bram Moolenaar071d4272004-06-13 20:20:40 +00003150 }
3151}
Bram Moolenaar071d4272004-06-13 20:20:40 +00003152
3153/*
3154 * make the replace stack empty
3155 * (called when exiting replace mode)
3156 */
3157 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01003158replace_flush(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003159{
Bram Moolenaard23a8232018-02-10 18:45:26 +01003160 VIM_CLEAR(replace_stack);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003161 replace_stack_len = 0;
3162 replace_stack_nr = 0;
3163}
3164
3165/*
3166 * Handle doing a BS for one character.
3167 * cc < 0: replace stack empty, just move cursor
3168 * cc == 0: character was inserted, delete it
3169 * cc > 0: character was replaced, put cc (first byte of original char) back
3170 * and check for more characters to be put back
Bram Moolenaar0f6c9482009-01-13 11:29:48 +00003171 * When "limit_col" is >= 0, don't delete before this column. Matters when
3172 * using composing characters, use del_char_after_col() instead of del_char().
Bram Moolenaar071d4272004-06-13 20:20:40 +00003173 */
3174 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01003175replace_do_bs(int limit_col)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003176{
3177 int cc;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003178 int orig_len = 0;
3179 int ins_len;
3180 int orig_vcols = 0;
3181 colnr_T start_vcol;
3182 char_u *p;
3183 int i;
3184 int vcol;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003185
3186 cc = replace_pop();
3187 if (cc > 0)
3188 {
Bram Moolenaar05ad5ff2019-11-30 22:48:27 +01003189#ifdef FEAT_PROP_POPUP
Bram Moolenaar6d11f3b2019-01-06 17:44:38 +01003190 size_t len_before = 0; // init to shut up GCC
Bram Moolenaar196d1572019-01-02 23:47:18 +01003191
3192 if (curbuf->b_has_textprop)
3193 {
3194 // Do not adjust text properties for individual delete and insert
3195 // operations, do it afterwards on the resulting text.
3196 len_before = STRLEN(ml_get_curline());
3197 ++text_prop_frozen;
3198 }
3199#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003200 if (State & VREPLACE_FLAG)
3201 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003202 // Get the number of screen cells used by the character we are
3203 // going to delete.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003204 getvcol(curwin, &curwin->w_cursor, NULL, &start_vcol, NULL);
3205 orig_vcols = chartabsize(ml_get_cursor(), start_vcol);
3206 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003207 if (has_mbyte)
3208 {
Bram Moolenaar0f6c9482009-01-13 11:29:48 +00003209 (void)del_char_after_col(limit_col);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003210 if (State & VREPLACE_FLAG)
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00003211 orig_len = (int)STRLEN(ml_get_cursor());
Bram Moolenaar071d4272004-06-13 20:20:40 +00003212 replace_push(cc);
3213 }
3214 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00003215 {
3216 pchar_cursor(cc);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003217 if (State & VREPLACE_FLAG)
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00003218 orig_len = (int)STRLEN(ml_get_cursor()) - 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003219 }
3220 replace_pop_ins();
3221
Bram Moolenaar071d4272004-06-13 20:20:40 +00003222 if (State & VREPLACE_FLAG)
3223 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003224 // Get the number of screen cells used by the inserted characters
Bram Moolenaar071d4272004-06-13 20:20:40 +00003225 p = ml_get_cursor();
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00003226 ins_len = (int)STRLEN(p) - orig_len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003227 vcol = start_vcol;
3228 for (i = 0; i < ins_len; ++i)
3229 {
3230 vcol += chartabsize(p + i, vcol);
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00003231 i += (*mb_ptr2len)(p) - 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003232 }
3233 vcol -= start_vcol;
3234
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003235 // Delete spaces that were inserted after the cursor to keep the
3236 // text aligned.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003237 curwin->w_cursor.col += ins_len;
3238 while (vcol > orig_vcols && gchar_cursor() == ' ')
3239 {
3240 del_char(FALSE);
3241 ++orig_vcols;
3242 }
3243 curwin->w_cursor.col -= ins_len;
3244 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003245
Bram Moolenaar196d1572019-01-02 23:47:18 +01003246 // mark the buffer as changed and prepare for displaying
Bram Moolenaar071d4272004-06-13 20:20:40 +00003247 changed_bytes(curwin->w_cursor.lnum, curwin->w_cursor.col);
Bram Moolenaar196d1572019-01-02 23:47:18 +01003248
Bram Moolenaar05ad5ff2019-11-30 22:48:27 +01003249#ifdef FEAT_PROP_POPUP
Bram Moolenaar196d1572019-01-02 23:47:18 +01003250 if (curbuf->b_has_textprop)
3251 {
3252 size_t len_now = STRLEN(ml_get_curline());
3253
3254 --text_prop_frozen;
3255 adjust_prop_columns(curwin->w_cursor.lnum, curwin->w_cursor.col,
Bram Moolenaarf3333b02019-05-19 22:53:40 +02003256 (int)(len_now - len_before), 0);
Bram Moolenaar196d1572019-01-02 23:47:18 +01003257 }
3258#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003259 }
3260 else if (cc == 0)
Bram Moolenaar0f6c9482009-01-13 11:29:48 +00003261 (void)del_char_after_col(limit_col);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003262}
3263
Bram Moolenaar071d4272004-06-13 20:20:40 +00003264#if defined(FEAT_RIGHTLEFT) || defined(PROTO)
3265/*
3266 * Map Hebrew keyboard when in hkmap mode.
3267 */
3268 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01003269hkmap(int c)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003270{
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003271 if (p_hkmapp) // phonetic mapping, by Ilya Dogolazky
Bram Moolenaar071d4272004-06-13 20:20:40 +00003272 {
3273 enum {hALEF=0, BET, GIMEL, DALET, HEI, VAV, ZAIN, HET, TET, IUD,
3274 KAFsofit, hKAF, LAMED, MEMsofit, MEM, NUNsofit, NUN, SAMEH, AIN,
3275 PEIsofit, PEI, ZADIsofit, ZADI, KOF, RESH, hSHIN, TAV};
3276 static char_u map[26] =
3277 {(char_u)hALEF/*a*/, (char_u)BET /*b*/, (char_u)hKAF /*c*/,
3278 (char_u)DALET/*d*/, (char_u)-1 /*e*/, (char_u)PEIsofit/*f*/,
3279 (char_u)GIMEL/*g*/, (char_u)HEI /*h*/, (char_u)IUD /*i*/,
3280 (char_u)HET /*j*/, (char_u)KOF /*k*/, (char_u)LAMED /*l*/,
3281 (char_u)MEM /*m*/, (char_u)NUN /*n*/, (char_u)SAMEH /*o*/,
3282 (char_u)PEI /*p*/, (char_u)-1 /*q*/, (char_u)RESH /*r*/,
3283 (char_u)ZAIN /*s*/, (char_u)TAV /*t*/, (char_u)TET /*u*/,
3284 (char_u)VAV /*v*/, (char_u)hSHIN/*w*/, (char_u)-1 /*x*/,
3285 (char_u)AIN /*y*/, (char_u)ZADI /*z*/};
3286
3287 if (c == 'N' || c == 'M' || c == 'P' || c == 'C' || c == 'Z')
3288 return (int)(map[CharOrd(c)] - 1 + p_aleph);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003289 // '-1'='sofit'
Bram Moolenaar071d4272004-06-13 20:20:40 +00003290 else if (c == 'x')
3291 return 'X';
3292 else if (c == 'q')
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003293 return '\''; // {geresh}={'}
Bram Moolenaar071d4272004-06-13 20:20:40 +00003294 else if (c == 246)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003295 return ' '; // \"o --> ' ' for a german keyboard
Bram Moolenaar071d4272004-06-13 20:20:40 +00003296 else if (c == 228)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003297 return ' '; // \"a --> ' ' -- / --
Bram Moolenaar071d4272004-06-13 20:20:40 +00003298 else if (c == 252)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003299 return ' '; // \"u --> ' ' -- / --
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003300 // NOTE: islower() does not do the right thing for us on Linux so we
3301 // do this the same was as 5.7 and previous, so it works correctly on
3302 // all systems. Specifically, the e.g. Delete and Arrow keys are
3303 // munged and won't work if e.g. searching for Hebrew text.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003304 else if (c >= 'a' && c <= 'z')
Bram Moolenaar071d4272004-06-13 20:20:40 +00003305 return (int)(map[CharOrdLow(c)] + p_aleph);
3306 else
3307 return c;
3308 }
3309 else
3310 {
3311 switch (c)
3312 {
3313 case '`': return ';';
3314 case '/': return '.';
3315 case '\'': return ',';
3316 case 'q': return '/';
3317 case 'w': return '\'';
3318
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003319 // Hebrew letters - set offset from 'a'
Bram Moolenaar071d4272004-06-13 20:20:40 +00003320 case ',': c = '{'; break;
3321 case '.': c = 'v'; break;
3322 case ';': c = 't'; break;
3323 default: {
3324 static char str[] = "zqbcxlsjphmkwonu ydafe rig";
3325
Bram Moolenaar071d4272004-06-13 20:20:40 +00003326 if (c < 'a' || c > 'z')
Bram Moolenaar071d4272004-06-13 20:20:40 +00003327 return c;
3328 c = str[CharOrdLow(c)];
3329 break;
3330 }
3331 }
3332
3333 return (int)(CharOrdLow(c) + p_aleph);
3334 }
3335}
3336#endif
3337
3338 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01003339ins_reg(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003340{
3341 int need_redraw = FALSE;
3342 int regname;
3343 int literally = 0;
Bram Moolenaarf193fff2006-04-27 00:02:13 +00003344 int vis_active = VIsual_active;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003345
3346 /*
3347 * If we are going to wait for a character, show a '"'.
3348 */
3349 pc_status = PC_STATUS_UNSET;
3350 if (redrawing() && !char_avail())
3351 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003352 // may need to redraw when no more chars available now
Bram Moolenaar754b5602006-02-09 23:53:20 +00003353 ins_redraw(FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003354
3355 edit_putchar('"', TRUE);
3356#ifdef FEAT_CMDL_INFO
3357 add_to_showcmd_c(Ctrl_R);
3358#endif
3359 }
3360
3361#ifdef USE_ON_FLY_SCROLL
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003362 dont_scroll = TRUE; // disallow scrolling here
Bram Moolenaar071d4272004-06-13 20:20:40 +00003363#endif
3364
3365 /*
3366 * Don't map the register name. This also prevents the mode message to be
3367 * deleted when ESC is hit.
3368 */
3369 ++no_mapping;
Bram Moolenaar38571a02019-11-26 14:28:15 +01003370 ++allow_keys;
Bram Moolenaar61abfd12007-09-13 16:26:47 +00003371 regname = plain_vgetc();
Bram Moolenaar071d4272004-06-13 20:20:40 +00003372 LANGMAP_ADJUST(regname, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003373 if (regname == Ctrl_R || regname == Ctrl_O || regname == Ctrl_P)
3374 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003375 // Get a third key for literal register insertion
Bram Moolenaar071d4272004-06-13 20:20:40 +00003376 literally = regname;
3377#ifdef FEAT_CMDL_INFO
3378 add_to_showcmd_c(literally);
3379#endif
Bram Moolenaar61abfd12007-09-13 16:26:47 +00003380 regname = plain_vgetc();
Bram Moolenaar071d4272004-06-13 20:20:40 +00003381 LANGMAP_ADJUST(regname, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003382 }
3383 --no_mapping;
Bram Moolenaar38571a02019-11-26 14:28:15 +01003384 --allow_keys;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003385
3386#ifdef FEAT_EVAL
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003387 // Don't call u_sync() while typing the expression or giving an error
3388 // message for it. Only call it explicitly.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003389 ++no_u_sync;
3390 if (regname == '=')
3391 {
Bram Moolenaar9e26f7d2019-01-22 22:08:09 +01003392 pos_T curpos = curwin->w_cursor;
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01003393# ifdef HAVE_INPUT_METHOD
Bram Moolenaar071d4272004-06-13 20:20:40 +00003394 int im_on = im_get_status();
Bram Moolenaar8f999f12005-01-25 22:12:55 +00003395# endif
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003396 // Sync undo when evaluating the expression calls setline() or
3397 // append(), so that it can be undone separately.
Bram Moolenaar3c1e9c22013-07-04 20:25:41 +02003398 u_sync_once = 2;
Bram Moolenaar5737ca22013-06-27 22:21:24 +02003399
Bram Moolenaar071d4272004-06-13 20:20:40 +00003400 regname = get_expr_register();
Bram Moolenaar9e26f7d2019-01-22 22:08:09 +01003401
3402 // Cursor may be moved back a column.
3403 curwin->w_cursor = curpos;
3404 check_cursor();
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01003405# ifdef HAVE_INPUT_METHOD
Bram Moolenaar9e26f7d2019-01-22 22:08:09 +01003406 // Restore the Input Method.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003407 if (im_on)
3408 im_set_active(TRUE);
Bram Moolenaar8f999f12005-01-25 22:12:55 +00003409# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003410 }
Bram Moolenaar677ee682005-01-27 14:41:15 +00003411 if (regname == NUL || !valid_yank_reg(regname, FALSE))
3412 {
Bram Moolenaar165bc692015-07-21 17:53:25 +02003413 vim_beep(BO_REG);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003414 need_redraw = TRUE; // remove the '"'
Bram Moolenaar677ee682005-01-27 14:41:15 +00003415 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003416 else
3417 {
3418#endif
3419 if (literally == Ctrl_O || literally == Ctrl_P)
3420 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003421 // Append the command to the redo buffer.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003422 AppendCharToRedobuff(Ctrl_R);
3423 AppendCharToRedobuff(literally);
3424 AppendCharToRedobuff(regname);
3425
Bram Moolenaarc3516f72020-09-08 22:45:35 +02003426 do_put(regname, NULL, BACKWARD, 1L,
Bram Moolenaar071d4272004-06-13 20:20:40 +00003427 (literally == Ctrl_P ? PUT_FIXINDENT : 0) | PUT_CURSEND);
3428 }
3429 else if (insert_reg(regname, literally) == FAIL)
3430 {
Bram Moolenaar165bc692015-07-21 17:53:25 +02003431 vim_beep(BO_REG);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003432 need_redraw = TRUE; // remove the '"'
Bram Moolenaar071d4272004-06-13 20:20:40 +00003433 }
Bram Moolenaar8f999f12005-01-25 22:12:55 +00003434 else if (stop_insert_mode)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003435 // When the '=' register was used and a function was invoked that
3436 // did ":stopinsert" then stuff_empty() returns FALSE but we won't
3437 // insert anything, need to remove the '"'
Bram Moolenaar8f999f12005-01-25 22:12:55 +00003438 need_redraw = TRUE;
3439
Bram Moolenaar071d4272004-06-13 20:20:40 +00003440#ifdef FEAT_EVAL
3441 }
3442 --no_u_sync;
Bram Moolenaar3c1e9c22013-07-04 20:25:41 +02003443 if (u_sync_once == 1)
3444 ins_need_undo = TRUE;
3445 u_sync_once = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003446#endif
3447#ifdef FEAT_CMDL_INFO
3448 clear_showcmd();
3449#endif
3450
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003451 // If the inserted register is empty, we need to remove the '"'
Bram Moolenaar071d4272004-06-13 20:20:40 +00003452 if (need_redraw || stuff_empty())
3453 edit_unputchar();
Bram Moolenaarf193fff2006-04-27 00:02:13 +00003454
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003455 // Disallow starting Visual mode here, would get a weird mode.
Bram Moolenaarf193fff2006-04-27 00:02:13 +00003456 if (!vis_active && VIsual_active)
3457 end_visual_mode();
Bram Moolenaar071d4272004-06-13 20:20:40 +00003458}
3459
3460/*
3461 * CTRL-G commands in Insert mode.
3462 */
3463 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01003464ins_ctrl_g(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003465{
3466 int c;
3467
Bram Moolenaare2c453d2019-08-21 14:37:09 +02003468 // Right after CTRL-X the cursor will be after the ruler.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003469 setcursor();
Bram Moolenaar071d4272004-06-13 20:20:40 +00003470
3471 /*
3472 * Don't map the second key. This also prevents the mode message to be
3473 * deleted when ESC is hit.
3474 */
3475 ++no_mapping;
Bram Moolenaar38571a02019-11-26 14:28:15 +01003476 ++allow_keys;
Bram Moolenaar61abfd12007-09-13 16:26:47 +00003477 c = plain_vgetc();
Bram Moolenaar071d4272004-06-13 20:20:40 +00003478 --no_mapping;
Bram Moolenaar38571a02019-11-26 14:28:15 +01003479 --allow_keys;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003480 switch (c)
3481 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003482 // CTRL-G k and CTRL-G <Up>: cursor up to Insstart.col
Bram Moolenaar071d4272004-06-13 20:20:40 +00003483 case K_UP:
3484 case Ctrl_K:
3485 case 'k': ins_up(TRUE);
3486 break;
3487
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003488 // CTRL-G j and CTRL-G <Down>: cursor down to Insstart.col
Bram Moolenaar071d4272004-06-13 20:20:40 +00003489 case K_DOWN:
3490 case Ctrl_J:
3491 case 'j': ins_down(TRUE);
3492 break;
3493
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003494 // CTRL-G u: start new undoable edit
Bram Moolenaar779b74b2006-04-10 14:55:34 +00003495 case 'u': u_sync(TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003496 ins_need_undo = TRUE;
Bram Moolenaara40ceaf2006-01-13 22:35:40 +00003497
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003498 // Need to reset Insstart, esp. because a BS that joins
3499 // a line to the previous one must save for undo.
Bram Moolenaarb1d90a32014-02-22 23:03:55 +01003500 update_Insstart_orig = FALSE;
Bram Moolenaara40ceaf2006-01-13 22:35:40 +00003501 Insstart = curwin->w_cursor;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003502 break;
3503
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003504 // CTRL-G U: do not break undo with the next char
Bram Moolenaar8b5f65a2015-09-01 19:26:12 +02003505 case 'U':
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003506 // Allow one left/right cursor movement with the next char,
3507 // without breaking undo.
Bram Moolenaar8b5f65a2015-09-01 19:26:12 +02003508 dont_sync_undo = MAYBE;
3509 break;
3510
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003511 // Unknown CTRL-G command, reserved for future expansion.
Bram Moolenaar165bc692015-07-21 17:53:25 +02003512 default: vim_beep(BO_CTRLG);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003513 }
3514}
3515
3516/*
Bram Moolenaar4be06f92005-07-29 22:36:03 +00003517 * CTRL-^ in Insert mode.
3518 */
3519 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01003520ins_ctrl_hat(void)
Bram Moolenaar4be06f92005-07-29 22:36:03 +00003521{
Bram Moolenaar24959102022-05-07 20:01:16 +01003522 if (map_to_exists_mode((char_u *)"", MODE_LANGMAP, FALSE))
Bram Moolenaar4be06f92005-07-29 22:36:03 +00003523 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003524 // ":lmap" mappings exists, Toggle use of ":lmap" mappings.
Bram Moolenaar24959102022-05-07 20:01:16 +01003525 if (State & MODE_LANGMAP)
Bram Moolenaar4be06f92005-07-29 22:36:03 +00003526 {
3527 curbuf->b_p_iminsert = B_IMODE_NONE;
Bram Moolenaar24959102022-05-07 20:01:16 +01003528 State &= ~MODE_LANGMAP;
Bram Moolenaar4be06f92005-07-29 22:36:03 +00003529 }
3530 else
3531 {
3532 curbuf->b_p_iminsert = B_IMODE_LMAP;
Bram Moolenaar24959102022-05-07 20:01:16 +01003533 State |= MODE_LANGMAP;
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01003534#ifdef HAVE_INPUT_METHOD
Bram Moolenaar4be06f92005-07-29 22:36:03 +00003535 im_set_active(FALSE);
3536#endif
3537 }
3538 }
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01003539#ifdef HAVE_INPUT_METHOD
Bram Moolenaar4be06f92005-07-29 22:36:03 +00003540 else
3541 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003542 // There are no ":lmap" mappings, toggle IM
Bram Moolenaar4be06f92005-07-29 22:36:03 +00003543 if (im_get_status())
3544 {
3545 curbuf->b_p_iminsert = B_IMODE_NONE;
3546 im_set_active(FALSE);
3547 }
3548 else
3549 {
3550 curbuf->b_p_iminsert = B_IMODE_IM;
Bram Moolenaar24959102022-05-07 20:01:16 +01003551 State &= ~MODE_LANGMAP;
Bram Moolenaar4be06f92005-07-29 22:36:03 +00003552 im_set_active(TRUE);
3553 }
3554 }
3555#endif
3556 set_iminsert_global();
3557 showmode();
3558#ifdef FEAT_GUI
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003559 // may show different cursor shape or color
Bram Moolenaar4be06f92005-07-29 22:36:03 +00003560 if (gui.in_use)
3561 gui_update_cursor(TRUE, FALSE);
3562#endif
Bram Moolenaar4033c552017-09-16 20:54:51 +02003563#if defined(FEAT_KEYMAP)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003564 // Show/unshow value of 'keymap' in status lines.
Bram Moolenaar4be06f92005-07-29 22:36:03 +00003565 status_redraw_curbuf();
3566#endif
3567}
3568
3569/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00003570 * Handle ESC in insert mode.
3571 * Returns TRUE when leaving insert mode, FALSE when going to repeat the
3572 * insert.
3573 */
3574 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01003575ins_esc(
3576 long *count,
3577 int cmdchar,
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003578 int nomove) // don't move cursor
Bram Moolenaar071d4272004-06-13 20:20:40 +00003579{
3580 int temp;
3581 static int disabled_redraw = FALSE;
Bram Moolenaar644b49f2021-09-16 22:32:15 +02003582#ifdef FEAT_CONCEAL
3583 // Remember if the cursor line was concealed before changing State.
3584 int cursor_line_was_concealed = curwin->w_p_cole > 0
3585 && conceal_cursor_line(curwin);
3586#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003587
Bram Moolenaarb9a02fc2006-03-12 22:08:12 +00003588#ifdef FEAT_SPELL
Bram Moolenaar4be06f92005-07-29 22:36:03 +00003589 check_spell_redraw();
Bram Moolenaaree09fcc2022-09-25 20:58:30 +01003590
3591 // When text has been changed in this line, possibly the start of the next
3592 // line may have SpellCap that should be removed or it needs to be
3593 // displayed. Schedule the next line for redrawing just in case.
3594 if (spell_check_window(curwin)
3595 && curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count)
3596 redrawWinline(curwin, curwin->w_cursor.lnum + 1);
Bram Moolenaar4be06f92005-07-29 22:36:03 +00003597#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003598
3599 temp = curwin->w_cursor.col;
3600 if (disabled_redraw)
3601 {
3602 --RedrawingDisabled;
3603 disabled_redraw = FALSE;
3604 }
3605 if (!arrow_used)
3606 {
3607 /*
3608 * Don't append the ESC for "r<CR>" and "grx".
Bram Moolenaar12805862005-01-05 22:16:17 +00003609 * When 'insertmode' is set only CTRL-L stops Insert mode. Needed for
3610 * when "count" is non-zero.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003611 */
3612 if (cmdchar != 'r' && cmdchar != 'v')
Bram Moolenaar12805862005-01-05 22:16:17 +00003613 AppendToRedobuff(p_im ? (char_u *)"\014" : ESC_STR);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003614
3615 /*
3616 * Repeating insert may take a long time. Check for
3617 * interrupt now and then.
3618 */
3619 if (*count > 0)
3620 {
3621 line_breakcheck();
3622 if (got_int)
3623 *count = 0;
3624 }
3625
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003626 if (--*count > 0) // repeat what was typed
Bram Moolenaar071d4272004-06-13 20:20:40 +00003627 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003628 // Vi repeats the insert without replacing characters.
Bram Moolenaar4399ef42005-02-12 14:29:27 +00003629 if (vim_strchr(p_cpo, CPO_REPLCNT) != NULL)
3630 State &= ~REPLACE_FLAG;
3631
Bram Moolenaar071d4272004-06-13 20:20:40 +00003632 (void)start_redo_ins();
3633 if (cmdchar == 'r' || cmdchar == 'v')
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003634 stuffRedoReadbuff(ESC_STR); // no ESC in redo buffer
Bram Moolenaar071d4272004-06-13 20:20:40 +00003635 ++RedrawingDisabled;
3636 disabled_redraw = TRUE;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003637 return FALSE; // repeat the insert
Bram Moolenaar071d4272004-06-13 20:20:40 +00003638 }
Bram Moolenaarf332a652013-11-04 04:20:33 +01003639 stop_insert(&curwin->w_cursor, TRUE, nomove);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003640 undisplay_dollar();
3641 }
3642
Bram Moolenaarb53e13a2020-10-21 12:19:53 +02003643 if (cmdchar != 'r' && cmdchar != 'v')
3644 ins_apply_autocmds(EVENT_INSERTLEAVEPRE);
3645
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003646 // When an autoindent was removed, curswant stays after the
3647 // indent
Bram Moolenaar071d4272004-06-13 20:20:40 +00003648 if (restart_edit == NUL && (colnr_T)temp == curwin->w_cursor.col)
3649 curwin->w_set_curswant = TRUE;
3650
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003651 // Remember the last Insert position in the '^ mark.
Bram Moolenaare1004402020-10-24 20:49:43 +02003652 if ((cmdmod.cmod_flags & CMOD_KEEPJUMPS) == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003653 curbuf->b_last_insert = curwin->w_cursor;
3654
3655 /*
3656 * The cursor should end up on the last inserted character.
Bram Moolenaar488c6512005-08-11 20:09:58 +00003657 * Don't do it for CTRL-O, unless past the end of the line.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003658 */
Bram Moolenaar488c6512005-08-11 20:09:58 +00003659 if (!nomove
3660 && (curwin->w_cursor.col != 0
Bram Moolenaar29ddebe2019-01-26 17:28:26 +01003661 || curwin->w_cursor.coladd > 0)
Bram Moolenaar488c6512005-08-11 20:09:58 +00003662 && (restart_edit == NUL
Bram Moolenaarf7ff6e82014-03-23 15:13:05 +01003663 || (gchar_cursor() == NUL && !VIsual_active))
Bram Moolenaar071d4272004-06-13 20:20:40 +00003664#ifdef FEAT_RIGHTLEFT
3665 && !revins_on
3666#endif
3667 )
3668 {
Gary Johnson53ba05b2021-07-26 22:19:10 +02003669 if (curwin->w_cursor.coladd > 0 || get_ve_flags() == VE_ALL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003670 {
3671 oneleft();
3672 if (restart_edit != NUL)
3673 ++curwin->w_cursor.coladd;
3674 }
3675 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00003676 {
3677 --curwin->w_cursor.col;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003678 // Correct cursor for multi-byte character.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003679 if (has_mbyte)
3680 mb_adjust_cursor();
Bram Moolenaar071d4272004-06-13 20:20:40 +00003681 }
3682 }
3683
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01003684#ifdef HAVE_INPUT_METHOD
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003685 // Disable IM to allow typing English directly for Normal mode commands.
3686 // When ":lmap" is enabled don't change 'iminsert' (IM can be enabled as
3687 // well).
Bram Moolenaar24959102022-05-07 20:01:16 +01003688 if (!(State & MODE_LANGMAP))
Bram Moolenaar071d4272004-06-13 20:20:40 +00003689 im_save_status(&curbuf->b_p_iminsert);
3690 im_set_active(FALSE);
3691#endif
3692
Bram Moolenaar24959102022-05-07 20:01:16 +01003693 State = MODE_NORMAL;
LemonBoy2bf52dd2022-04-09 18:17:34 +01003694 may_trigger_modechanged();
zeertzjq8c979602022-04-07 15:08:01 +01003695 // need to position cursor again when on a TAB
3696 if (gchar_cursor() == TAB)
3697 curwin->w_valid &= ~(VALID_WROW|VALID_WCOL|VALID_VIRTCOL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003698
Bram Moolenaar071d4272004-06-13 20:20:40 +00003699 setmouse();
Bram Moolenaar071d4272004-06-13 20:20:40 +00003700#ifdef CURSOR_SHAPE
Bram Moolenaar177c9f22019-11-06 13:59:16 +01003701 ui_cursor_shape(); // may show different cursor shape
Bram Moolenaar071d4272004-06-13 20:20:40 +00003702#endif
Bram Moolenaar48c9f3b2017-01-24 19:08:15 +01003703 if (!p_ek)
Bram Moolenaar177c9f22019-11-06 13:59:16 +01003704 {
Bram Moolenaar1d97db32022-06-04 22:15:54 +01003705 MAY_WANT_TO_LOG_THIS;
3706
Bram Moolenaar177c9f22019-11-06 13:59:16 +01003707 // Re-enable bracketed paste mode.
Bram Moolenaar48c9f3b2017-01-24 19:08:15 +01003708 out_str(T_BE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003709
Bram Moolenaar177c9f22019-11-06 13:59:16 +01003710 // Re-enable modifyOtherKeys.
3711 out_str(T_CTI);
3712 }
Bram Moolenaar644b49f2021-09-16 22:32:15 +02003713#ifdef FEAT_CONCEAL
3714 // Check if the cursor line needs redrawing after changing State. If
3715 // 'concealcursor' is "i" it needs to be redrawn without concealing.
3716 conceal_check_cursor_line(cursor_line_was_concealed);
3717#endif
Bram Moolenaar177c9f22019-11-06 13:59:16 +01003718
Bram Moolenaarad3ec762019-04-21 00:00:13 +02003719 // When recording or for CTRL-O, need to display the new mode.
3720 // Otherwise remove the mode message.
Bram Moolenaar0b6d9112018-05-22 20:35:17 +02003721 if (reg_recording != 0 || restart_edit != NUL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003722 showmode();
Bram Moolenaarabc7c7f2019-04-20 15:10:13 +02003723 else if (p_smd && (got_int || !skip_showmode()))
Bram Moolenaar32526b32019-01-19 17:43:09 +01003724 msg("");
Bram Moolenaar071d4272004-06-13 20:20:40 +00003725
Bram Moolenaar177c9f22019-11-06 13:59:16 +01003726 return TRUE; // exit Insert mode
Bram Moolenaar071d4272004-06-13 20:20:40 +00003727}
3728
3729#ifdef FEAT_RIGHTLEFT
3730/*
3731 * Toggle language: hkmap and revins_on.
3732 * Move to end of reverse inserted text.
3733 */
3734 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01003735ins_ctrl_(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003736{
3737 if (revins_on && revins_chars && revins_scol >= 0)
3738 {
3739 while (gchar_cursor() != NUL && revins_chars--)
3740 ++curwin->w_cursor.col;
3741 }
3742 p_ri = !p_ri;
Bram Moolenaar24959102022-05-07 20:01:16 +01003743 revins_on = (State == MODE_INSERT && p_ri);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003744 if (revins_on)
3745 {
3746 revins_scol = curwin->w_cursor.col;
3747 revins_legal++;
3748 revins_chars = 0;
3749 undisplay_dollar();
3750 }
3751 else
3752 revins_scol = -1;
Bram Moolenaar14184a32019-02-16 15:10:30 +01003753 p_hkmap = curwin->w_p_rl ^ p_ri; // be consistent!
Bram Moolenaar071d4272004-06-13 20:20:40 +00003754 showmode();
3755}
3756#endif
3757
Bram Moolenaar071d4272004-06-13 20:20:40 +00003758/*
3759 * If 'keymodel' contains "startsel", may start selection.
3760 * Returns TRUE when a CTRL-O and other keys stuffed.
3761 */
3762 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01003763ins_start_select(int c)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003764{
zeertzjq101d57b2022-07-31 18:34:32 +01003765 if (!km_startsel)
3766 return FALSE;
3767 switch (c)
3768 {
3769 case K_KHOME:
3770 case K_KEND:
3771 case K_PAGEUP:
3772 case K_KPAGEUP:
3773 case K_PAGEDOWN:
3774 case K_KPAGEDOWN:
Bram Moolenaard0573012017-10-28 21:11:06 +02003775# ifdef MACOS_X
zeertzjq101d57b2022-07-31 18:34:32 +01003776 case K_LEFT:
3777 case K_RIGHT:
3778 case K_UP:
3779 case K_DOWN:
3780 case K_END:
3781 case K_HOME:
Bram Moolenaar071d4272004-06-13 20:20:40 +00003782# endif
zeertzjq101d57b2022-07-31 18:34:32 +01003783 if (!(mod_mask & MOD_MASK_SHIFT))
3784 break;
3785 // FALLTHROUGH
3786 case K_S_LEFT:
3787 case K_S_RIGHT:
3788 case K_S_UP:
3789 case K_S_DOWN:
3790 case K_S_END:
3791 case K_S_HOME:
3792 // Start selection right away, the cursor can move with CTRL-O when
3793 // beyond the end of the line.
3794 start_selection();
Bram Moolenaar071d4272004-06-13 20:20:40 +00003795
zeertzjq101d57b2022-07-31 18:34:32 +01003796 // Execute the key in (insert) Select mode.
3797 stuffcharReadbuff(Ctrl_O);
3798 if (mod_mask)
3799 {
3800 char_u buf[4];
Bram Moolenaar071d4272004-06-13 20:20:40 +00003801
zeertzjq101d57b2022-07-31 18:34:32 +01003802 buf[0] = K_SPECIAL;
3803 buf[1] = KS_MODIFIER;
3804 buf[2] = mod_mask;
3805 buf[3] = NUL;
3806 stuffReadbuff(buf);
3807 }
3808 stuffcharReadbuff(c);
3809 return TRUE;
3810 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003811 return FALSE;
3812}
Bram Moolenaar071d4272004-06-13 20:20:40 +00003813
3814/*
Bram Moolenaar84a05ac2013-05-06 04:24:17 +02003815 * <Insert> key in Insert mode: toggle insert/replace mode.
Bram Moolenaar4be06f92005-07-29 22:36:03 +00003816 */
3817 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01003818ins_insert(int replaceState)
Bram Moolenaar4be06f92005-07-29 22:36:03 +00003819{
Bram Moolenaar14184a32019-02-16 15:10:30 +01003820#ifdef FEAT_EVAL
Bram Moolenaar4be06f92005-07-29 22:36:03 +00003821 set_vim_var_string(VV_INSERTMODE,
Bram Moolenaar1f0bfe52018-07-29 16:09:22 +02003822 (char_u *)((State & REPLACE_FLAG) ? "i"
Bram Moolenaar6ed545e2022-05-09 20:09:23 +01003823 : replaceState == MODE_VREPLACE ? "v" : "r"), 1);
Bram Moolenaar14184a32019-02-16 15:10:30 +01003824#endif
Bram Moolenaar9fa95062018-08-08 22:08:32 +02003825 ins_apply_autocmds(EVENT_INSERTCHANGE);
Bram Moolenaar4be06f92005-07-29 22:36:03 +00003826 if (State & REPLACE_FLAG)
Bram Moolenaar24959102022-05-07 20:01:16 +01003827 State = MODE_INSERT | (State & MODE_LANGMAP);
Bram Moolenaar4be06f92005-07-29 22:36:03 +00003828 else
Bram Moolenaar24959102022-05-07 20:01:16 +01003829 State = replaceState | (State & MODE_LANGMAP);
LemonBoy2bf52dd2022-04-09 18:17:34 +01003830 may_trigger_modechanged();
Bram Moolenaar4be06f92005-07-29 22:36:03 +00003831 AppendCharToRedobuff(K_INS);
3832 showmode();
3833#ifdef CURSOR_SHAPE
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003834 ui_cursor_shape(); // may show different cursor shape
Bram Moolenaar4be06f92005-07-29 22:36:03 +00003835#endif
3836}
3837
3838/*
3839 * Pressed CTRL-O in Insert mode.
3840 */
3841 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01003842ins_ctrl_o(void)
Bram Moolenaar4be06f92005-07-29 22:36:03 +00003843{
Bram Moolenaar4be06f92005-07-29 22:36:03 +00003844 if (State & VREPLACE_FLAG)
3845 restart_edit = 'V';
Bram Moolenaar0684e362020-12-03 19:54:42 +01003846 else if (State & REPLACE_FLAG)
Bram Moolenaar4be06f92005-07-29 22:36:03 +00003847 restart_edit = 'R';
3848 else
3849 restart_edit = 'I';
Bram Moolenaar4be06f92005-07-29 22:36:03 +00003850 if (virtual_active())
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003851 ins_at_eol = FALSE; // cursor always keeps its column
Bram Moolenaar4be06f92005-07-29 22:36:03 +00003852 else
Bram Moolenaar4be06f92005-07-29 22:36:03 +00003853 ins_at_eol = (gchar_cursor() == NUL);
3854}
3855
3856/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00003857 * If the cursor is on an indent, ^T/^D insert/delete one
3858 * shiftwidth. Otherwise ^T/^D behave like a "<<" or ">>".
Bram Moolenaar5b3e4602009-02-04 10:20:58 +00003859 * Always round the indent to 'shiftwidth', this is compatible
Bram Moolenaar071d4272004-06-13 20:20:40 +00003860 * with vi. But vi only supports ^T and ^D after an
3861 * autoindent, we support it everywhere.
3862 */
3863 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01003864ins_shift(int c, int lastc)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003865{
3866 if (stop_arrow() == FAIL)
3867 return;
3868 AppendCharToRedobuff(c);
3869
3870 /*
3871 * 0^D and ^^D: remove all indent.
3872 */
Bram Moolenaar0cbac5b2007-07-29 13:03:35 +00003873 if (c == Ctrl_D && (lastc == '0' || lastc == '^')
3874 && curwin->w_cursor.col > 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003875 {
3876 --curwin->w_cursor.col;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003877 (void)del_char(FALSE); // delete the '^' or '0'
3878 // In Replace mode, restore the characters that '^' or '0' replaced.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003879 if (State & REPLACE_FLAG)
3880 replace_pop_ins();
3881 if (lastc == '^')
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003882 old_indent = get_indent(); // remember curr. indent
Bram Moolenaar21b17e72008-01-16 19:03:13 +00003883 change_indent(INDENT_SET, 0, TRUE, 0, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003884 }
3885 else
Bram Moolenaar21b17e72008-01-16 19:03:13 +00003886 change_indent(c == Ctrl_D ? INDENT_DEC : INDENT_INC, 0, TRUE, 0, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003887
3888 if (did_ai && *skipwhite(ml_get_curline()) != NUL)
3889 did_ai = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003890 did_si = FALSE;
3891 can_si = FALSE;
3892 can_si_back = FALSE;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003893 can_cindent = FALSE; // no cindenting after ^D or ^T
Bram Moolenaar071d4272004-06-13 20:20:40 +00003894}
3895
3896 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01003897ins_del(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003898{
3899 int temp;
3900
3901 if (stop_arrow() == FAIL)
3902 return;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003903 if (gchar_cursor() == NUL) // delete newline
Bram Moolenaar071d4272004-06-13 20:20:40 +00003904 {
3905 temp = curwin->w_cursor.col;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003906 if (!can_bs(BS_EOL) // only if "eol" included
Bram Moolenaard69bd9a2014-04-29 12:15:40 +02003907 || do_join(2, FALSE, TRUE, FALSE, FALSE) == FAIL)
Bram Moolenaar165bc692015-07-21 17:53:25 +02003908 vim_beep(BO_BS);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003909 else
Bram Moolenaar63e82db2018-03-06 12:10:48 +01003910 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00003911 curwin->w_cursor.col = temp;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003912 // Adjust orig_line_count in case more lines have been deleted than
3913 // have been added. That makes sure, that open_line() later
3914 // can access all buffer lines correctly
Bram Moolenaar63e82db2018-03-06 12:10:48 +01003915 if (State & VREPLACE_FLAG &&
3916 orig_line_count > curbuf->b_ml.ml_line_count)
3917 orig_line_count = curbuf->b_ml.ml_line_count;
Bram Moolenaar63e82db2018-03-06 12:10:48 +01003918 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003919 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003920 else if (del_char(FALSE) == FAIL) // delete char under cursor
Bram Moolenaar165bc692015-07-21 17:53:25 +02003921 vim_beep(BO_BS);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003922 did_ai = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003923 did_si = FALSE;
3924 can_si = FALSE;
3925 can_si_back = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003926 AppendCharToRedobuff(K_DEL);
3927}
3928
Bram Moolenaarf5dcf7c2007-12-09 19:26:44 +00003929/*
3930 * Delete one character for ins_bs().
3931 */
3932 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01003933ins_bs_one(colnr_T *vcolp)
Bram Moolenaarf5dcf7c2007-12-09 19:26:44 +00003934{
3935 dec_cursor();
3936 getvcol(curwin, &curwin->w_cursor, vcolp, NULL, NULL);
3937 if (State & REPLACE_FLAG)
3938 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003939 // Don't delete characters before the insert point when in
3940 // Replace mode
Bram Moolenaarf5dcf7c2007-12-09 19:26:44 +00003941 if (curwin->w_cursor.lnum != Insstart.lnum
3942 || curwin->w_cursor.col >= Insstart.col)
Bram Moolenaar0f6c9482009-01-13 11:29:48 +00003943 replace_do_bs(-1);
Bram Moolenaarf5dcf7c2007-12-09 19:26:44 +00003944 }
3945 else
3946 (void)del_char(FALSE);
3947}
3948
Bram Moolenaar071d4272004-06-13 20:20:40 +00003949/*
3950 * Handle Backspace, delete-word and delete-line in Insert mode.
3951 * Return TRUE when backspace was actually used.
3952 */
3953 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01003954ins_bs(
3955 int c,
3956 int mode,
3957 int *inserted_space_p)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003958{
3959 linenr_T lnum;
3960 int cc;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003961 int temp = 0; // init for GCC
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00003962 colnr_T save_col;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003963 colnr_T mincol;
3964 int did_backspace = FALSE;
3965 int in_indent;
3966 int oldState;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003967 int cpc[MAX_MCO]; // composing characters
Bram Moolenaar5d20fbf2021-12-29 16:05:31 +00003968 int call_fix_indent = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003969
3970 /*
3971 * can't delete anything in an empty file
3972 * can't backup past first character in buffer
3973 * can't backup past starting point unless 'backspace' > 1
3974 * can backup to a previous line if 'backspace' == 0
3975 */
Bram Moolenaarb5aedf32017-03-12 18:23:53 +01003976 if ( BUFEMPTY()
Bram Moolenaar071d4272004-06-13 20:20:40 +00003977 || (
3978#ifdef FEAT_RIGHTLEFT
3979 !revins_on &&
3980#endif
3981 ((curwin->w_cursor.lnum == 1 && curwin->w_cursor.col == 0)
3982 || (!can_bs(BS_START)
Bram Moolenaar6f624482020-11-11 20:52:40 +01003983 && ((arrow_used
3984#ifdef FEAT_JOB_CHANNEL
3985 && !bt_prompt(curbuf)
3986#endif
3987 ) || (curwin->w_cursor.lnum == Insstart_orig.lnum
Bram Moolenaar3d1956b2014-04-29 14:44:35 +02003988 && curwin->w_cursor.col <= Insstart_orig.col)))
Bram Moolenaar071d4272004-06-13 20:20:40 +00003989 || (!can_bs(BS_INDENT) && !arrow_used && ai_col > 0
3990 && curwin->w_cursor.col <= ai_col)
3991 || (!can_bs(BS_EOL) && curwin->w_cursor.col == 0))))
3992 {
Bram Moolenaar165bc692015-07-21 17:53:25 +02003993 vim_beep(BO_BS);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003994 return FALSE;
3995 }
3996
3997 if (stop_arrow() == FAIL)
3998 return FALSE;
3999 in_indent = inindent(0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004000 if (in_indent)
4001 can_cindent = FALSE;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004002 end_comment_pending = NUL; // After BS, don't auto-end comment
Bram Moolenaar071d4272004-06-13 20:20:40 +00004003#ifdef FEAT_RIGHTLEFT
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004004 if (revins_on) // put cursor after last inserted char
Bram Moolenaar071d4272004-06-13 20:20:40 +00004005 inc_cursor();
4006#endif
4007
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004008 // Virtualedit:
4009 // BACKSPACE_CHAR eats a virtual space
4010 // BACKSPACE_WORD eats all coladd
4011 // BACKSPACE_LINE eats all coladd and keeps going
Bram Moolenaar071d4272004-06-13 20:20:40 +00004012 if (curwin->w_cursor.coladd > 0)
4013 {
4014 if (mode == BACKSPACE_CHAR)
4015 {
4016 --curwin->w_cursor.coladd;
4017 return TRUE;
4018 }
4019 if (mode == BACKSPACE_WORD)
4020 {
4021 curwin->w_cursor.coladd = 0;
4022 return TRUE;
4023 }
4024 curwin->w_cursor.coladd = 0;
4025 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004026
4027 /*
Bram Moolenaar878c2632017-04-01 15:15:52 +02004028 * Delete newline!
Bram Moolenaar071d4272004-06-13 20:20:40 +00004029 */
4030 if (curwin->w_cursor.col == 0)
4031 {
Bram Moolenaarc3bbad02015-02-17 17:50:26 +01004032 lnum = Insstart.lnum;
Bram Moolenaar3d1956b2014-04-29 14:44:35 +02004033 if (curwin->w_cursor.lnum == lnum
Bram Moolenaar071d4272004-06-13 20:20:40 +00004034#ifdef FEAT_RIGHTLEFT
4035 || revins_on
4036#endif
4037 )
4038 {
4039 if (u_save((linenr_T)(curwin->w_cursor.lnum - 2),
4040 (linenr_T)(curwin->w_cursor.lnum + 1)) == FAIL)
4041 return FALSE;
Bram Moolenaarc3bbad02015-02-17 17:50:26 +01004042 --Insstart.lnum;
Bram Moolenaar04000562017-04-03 21:35:42 +02004043 Insstart.col = (colnr_T)STRLEN(ml_get(Insstart.lnum));
Bram Moolenaar071d4272004-06-13 20:20:40 +00004044 }
4045 /*
4046 * In replace mode:
4047 * cc < 0: NL was inserted, delete it
4048 * cc >= 0: NL was replaced, put original characters back
4049 */
4050 cc = -1;
4051 if (State & REPLACE_FLAG)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004052 cc = replace_pop(); // returns -1 if NL was inserted
Bram Moolenaar071d4272004-06-13 20:20:40 +00004053 /*
4054 * In replace mode, in the line we started replacing, we only move the
4055 * cursor.
4056 */
4057 if ((State & REPLACE_FLAG) && curwin->w_cursor.lnum <= lnum)
4058 {
4059 dec_cursor();
4060 }
4061 else
4062 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00004063 if (!(State & VREPLACE_FLAG)
4064 || curwin->w_cursor.lnum > orig_line_count)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004065 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004066 temp = gchar_cursor(); // remember current char
Bram Moolenaar071d4272004-06-13 20:20:40 +00004067 --curwin->w_cursor.lnum;
Bram Moolenaarc930a3c2005-05-20 21:27:20 +00004068
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004069 // When "aw" is in 'formatoptions' we must delete the space at
4070 // the end of the line, otherwise the line will be broken
4071 // again when auto-formatting.
Bram Moolenaarc930a3c2005-05-20 21:27:20 +00004072 if (has_format_option(FO_AUTO)
4073 && has_format_option(FO_WHITE_PAR))
4074 {
4075 char_u *ptr = ml_get_buf(curbuf, curwin->w_cursor.lnum,
4076 TRUE);
4077 int len;
4078
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00004079 len = (int)STRLEN(ptr);
Bram Moolenaarc930a3c2005-05-20 21:27:20 +00004080 if (len > 0 && ptr[len - 1] == ' ')
4081 ptr[len - 1] = NUL;
4082 }
4083
Bram Moolenaard69bd9a2014-04-29 12:15:40 +02004084 (void)do_join(2, FALSE, FALSE, FALSE, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004085 if (temp == NUL && gchar_cursor() != NUL)
4086 inc_cursor();
4087 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004088 else
4089 dec_cursor();
Bram Moolenaar071d4272004-06-13 20:20:40 +00004090
4091 /*
Bram Moolenaar24959102022-05-07 20:01:16 +01004092 * In MODE_REPLACE mode we have to put back the text that was
4093 * replaced by the NL. On the replace stack is first a
4094 * NUL-terminated sequence of characters that were deleted and then
4095 * the characters that NL replaced.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004096 */
4097 if (State & REPLACE_FLAG)
4098 {
4099 /*
Bram Moolenaar24959102022-05-07 20:01:16 +01004100 * Do the next ins_char() in MODE_NORMAL state, to
Bram Moolenaar071d4272004-06-13 20:20:40 +00004101 * prevent ins_char() from replacing characters and
4102 * avoiding showmatch().
4103 */
4104 oldState = State;
Bram Moolenaar24959102022-05-07 20:01:16 +01004105 State = MODE_NORMAL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004106 /*
4107 * restore characters (blanks) deleted after cursor
4108 */
4109 while (cc > 0)
4110 {
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00004111 save_col = curwin->w_cursor.col;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004112 mb_replace_pop_ins(cc);
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00004113 curwin->w_cursor.col = save_col;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004114 cc = replace_pop();
4115 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004116 // restore the characters that NL replaced
Bram Moolenaar071d4272004-06-13 20:20:40 +00004117 replace_pop_ins();
4118 State = oldState;
4119 }
4120 }
4121 did_ai = FALSE;
4122 }
4123 else
4124 {
4125 /*
4126 * Delete character(s) before the cursor.
4127 */
4128#ifdef FEAT_RIGHTLEFT
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004129 if (revins_on) // put cursor on last inserted char
Bram Moolenaar071d4272004-06-13 20:20:40 +00004130 dec_cursor();
4131#endif
4132 mincol = 0;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004133 // keep indent
Bram Moolenaar9248e6e2007-03-08 12:10:13 +00004134 if (mode == BACKSPACE_LINE
Bram Moolenaar8e145b82022-05-21 20:17:31 +01004135 && (curbuf->b_p_ai || cindent_on())
Bram Moolenaar071d4272004-06-13 20:20:40 +00004136#ifdef FEAT_RIGHTLEFT
4137 && !revins_on
4138#endif
4139 )
4140 {
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00004141 save_col = curwin->w_cursor.col;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004142 beginline(BL_WHITE);
Bram Moolenaar76675562009-11-11 12:22:32 +00004143 if (curwin->w_cursor.col < save_col)
Bram Moolenaar5d20fbf2021-12-29 16:05:31 +00004144 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00004145 mincol = curwin->w_cursor.col;
Bram Moolenaar5d20fbf2021-12-29 16:05:31 +00004146 // should now fix the indent to match with the previous line
4147 call_fix_indent = TRUE;
Bram Moolenaar5d20fbf2021-12-29 16:05:31 +00004148 }
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00004149 curwin->w_cursor.col = save_col;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004150 }
4151
4152 /*
4153 * Handle deleting one 'shiftwidth' or 'softtabstop'.
4154 */
4155 if ( mode == BACKSPACE_CHAR
4156 && ((p_sta && in_indent)
Bram Moolenaar04958cb2018-06-23 19:23:02 +02004157 || ((get_sts_value() != 0
4158#ifdef FEAT_VARTABS
4159 || tabstop_count(curbuf->b_p_vsts_array)
4160#endif
4161 )
Bram Moolenaar7b88a0e2008-01-09 09:14:13 +00004162 && curwin->w_cursor.col > 0
Bram Moolenaar071d4272004-06-13 20:20:40 +00004163 && (*(ml_get_cursor() - 1) == TAB
4164 || (*(ml_get_cursor() - 1) == ' '
4165 && (!*inserted_space_p
4166 || arrow_used))))))
4167 {
4168 int ts;
4169 colnr_T vcol;
4170 colnr_T want_vcol;
Bram Moolenaarf5dcf7c2007-12-09 19:26:44 +00004171 colnr_T start_vcol;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004172
4173 *inserted_space_p = FALSE;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004174 // Compute the virtual column where we want to be. Since
4175 // 'showbreak' may get in the way, need to get the last column of
4176 // the previous character.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004177 getvcol(curwin, &curwin->w_cursor, &vcol, NULL, NULL);
Bram Moolenaarf5dcf7c2007-12-09 19:26:44 +00004178 start_vcol = vcol;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004179 dec_cursor();
4180 getvcol(curwin, &curwin->w_cursor, NULL, NULL, &want_vcol);
4181 inc_cursor();
Bram Moolenaar04958cb2018-06-23 19:23:02 +02004182#ifdef FEAT_VARTABS
4183 if (p_sta && in_indent)
Bram Moolenaarc9fe5ab2018-07-05 22:27:08 +02004184 {
4185 ts = (int)get_sw_value(curbuf);
4186 want_vcol = (want_vcol / ts) * ts;
4187 }
Bram Moolenaar04958cb2018-06-23 19:23:02 +02004188 else
Bram Moolenaar33d5ab32018-07-02 20:51:24 +02004189 want_vcol = tabstop_start(want_vcol, get_sts_value(),
Bram Moolenaar424bcae2022-01-31 14:59:41 +00004190 curbuf->b_p_vsts_array);
Bram Moolenaar04958cb2018-06-23 19:23:02 +02004191#else
Bram Moolenaarc9fe5ab2018-07-05 22:27:08 +02004192 if (p_sta && in_indent)
4193 ts = (int)get_sw_value(curbuf);
4194 else
4195 ts = (int)get_sts_value();
Bram Moolenaar071d4272004-06-13 20:20:40 +00004196 want_vcol = (want_vcol / ts) * ts;
Bram Moolenaar04958cb2018-06-23 19:23:02 +02004197#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004198
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004199 // delete characters until we are at or before want_vcol
Bram Moolenaar0971c7a2022-06-26 12:59:02 +01004200 while (vcol > want_vcol && curwin->w_cursor.col > 0
Bram Moolenaar1c465442017-03-12 20:10:05 +01004201 && (cc = *(ml_get_cursor() - 1), VIM_ISWHITE(cc)))
Bram Moolenaarf5dcf7c2007-12-09 19:26:44 +00004202 ins_bs_one(&vcol);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004203
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004204 // insert extra spaces until we are at want_vcol
Bram Moolenaar071d4272004-06-13 20:20:40 +00004205 while (vcol < want_vcol)
4206 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004207 // Remember the first char we inserted
Bram Moolenaar3d1956b2014-04-29 14:44:35 +02004208 if (curwin->w_cursor.lnum == Insstart_orig.lnum
4209 && curwin->w_cursor.col < Insstart_orig.col)
4210 Insstart_orig.col = curwin->w_cursor.col;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004211
Bram Moolenaar071d4272004-06-13 20:20:40 +00004212 if (State & VREPLACE_FLAG)
4213 ins_char(' ');
4214 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00004215 {
4216 ins_str((char_u *)" ");
Bram Moolenaarf5dcf7c2007-12-09 19:26:44 +00004217 if ((State & REPLACE_FLAG))
4218 replace_push(NUL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004219 }
4220 getvcol(curwin, &curwin->w_cursor, &vcol, NULL, NULL);
4221 }
Bram Moolenaarf5dcf7c2007-12-09 19:26:44 +00004222
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004223 // If we are now back where we started delete one character. Can
4224 // happen when using 'sts' and 'linebreak'.
Bram Moolenaarf5dcf7c2007-12-09 19:26:44 +00004225 if (vcol >= start_vcol)
4226 ins_bs_one(&vcol);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004227 }
4228
4229 /*
Bram Moolenaar05ad5ff2019-11-30 22:48:27 +01004230 * Delete up to starting point, start of line or previous word.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004231 */
Bram Moolenaar310f2d52015-03-24 17:49:51 +01004232 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00004233 {
Bram Moolenaar310f2d52015-03-24 17:49:51 +01004234 int cclass = 0, prev_cclass = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004235
Bram Moolenaar310f2d52015-03-24 17:49:51 +01004236 if (has_mbyte)
4237 cclass = mb_get_class(ml_get_cursor());
Bram Moolenaar310f2d52015-03-24 17:49:51 +01004238 do
4239 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00004240#ifdef FEAT_RIGHTLEFT
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004241 if (!revins_on) // put cursor on char to be deleted
Bram Moolenaar310f2d52015-03-24 17:49:51 +01004242#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004243 dec_cursor();
Bram Moolenaar310f2d52015-03-24 17:49:51 +01004244
4245 cc = gchar_cursor();
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004246 // look multi-byte character class
Bram Moolenaar310f2d52015-03-24 17:49:51 +01004247 if (has_mbyte)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004248 {
Bram Moolenaar310f2d52015-03-24 17:49:51 +01004249 prev_cclass = cclass;
4250 cclass = mb_get_class(ml_get_cursor());
Bram Moolenaar071d4272004-06-13 20:20:40 +00004251 }
Bram Moolenaar310f2d52015-03-24 17:49:51 +01004252
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004253 // start of word?
Bram Moolenaar310f2d52015-03-24 17:49:51 +01004254 if (mode == BACKSPACE_WORD && !vim_isspace(cc))
4255 {
4256 mode = BACKSPACE_WORD_NOT_SPACE;
4257 temp = vim_iswordc(cc);
4258 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004259 // end of word?
Bram Moolenaar310f2d52015-03-24 17:49:51 +01004260 else if (mode == BACKSPACE_WORD_NOT_SPACE
4261 && ((vim_isspace(cc) || vim_iswordc(cc) != temp)
Bram Moolenaar13505972019-01-24 15:04:48 +01004262 || prev_cclass != cclass))
Bram Moolenaar310f2d52015-03-24 17:49:51 +01004263 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00004264#ifdef FEAT_RIGHTLEFT
Bram Moolenaar310f2d52015-03-24 17:49:51 +01004265 if (!revins_on)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004266#endif
Bram Moolenaar310f2d52015-03-24 17:49:51 +01004267 inc_cursor();
4268#ifdef FEAT_RIGHTLEFT
4269 else if (State & REPLACE_FLAG)
4270 dec_cursor();
4271#endif
4272 break;
4273 }
4274 if (State & REPLACE_FLAG)
4275 replace_do_bs(-1);
4276 else
4277 {
Bram Moolenaar310f2d52015-03-24 17:49:51 +01004278 if (enc_utf8 && p_deco)
4279 (void)utfc_ptr2char(ml_get_cursor(), cpc);
Bram Moolenaar310f2d52015-03-24 17:49:51 +01004280 (void)del_char(FALSE);
Bram Moolenaar310f2d52015-03-24 17:49:51 +01004281 /*
4282 * If there are combining characters and 'delcombine' is set
4283 * move the cursor back. Don't back up before the base
4284 * character.
4285 */
4286 if (enc_utf8 && p_deco && cpc[0] != NUL)
4287 inc_cursor();
Bram Moolenaar310f2d52015-03-24 17:49:51 +01004288#ifdef FEAT_RIGHTLEFT
4289 if (revins_chars)
4290 {
4291 revins_chars--;
4292 revins_legal++;
4293 }
4294 if (revins_on && gchar_cursor() == NUL)
4295 break;
4296#endif
4297 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004298 // Just a single backspace?:
Bram Moolenaar310f2d52015-03-24 17:49:51 +01004299 if (mode == BACKSPACE_CHAR)
4300 break;
4301 } while (
4302#ifdef FEAT_RIGHTLEFT
4303 revins_on ||
4304#endif
4305 (curwin->w_cursor.col > mincol
Bram Moolenaaraa0489e2020-04-17 19:41:21 +02004306 && (can_bs(BS_NOSTOP)
4307 || (curwin->w_cursor.lnum != Insstart_orig.lnum
4308 || curwin->w_cursor.col != Insstart_orig.col)
4309 )));
Bram Moolenaar310f2d52015-03-24 17:49:51 +01004310 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004311 did_backspace = TRUE;
4312 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004313 did_si = FALSE;
4314 can_si = FALSE;
4315 can_si_back = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004316 if (curwin->w_cursor.col <= 1)
4317 did_ai = FALSE;
Bram Moolenaar5d20fbf2021-12-29 16:05:31 +00004318
Bram Moolenaar5d20fbf2021-12-29 16:05:31 +00004319 if (call_fix_indent)
4320 fix_indent();
Bram Moolenaar5d20fbf2021-12-29 16:05:31 +00004321
Bram Moolenaar071d4272004-06-13 20:20:40 +00004322 /*
4323 * It's a little strange to put backspaces into the redo
4324 * buffer, but it makes auto-indent a lot easier to deal
4325 * with.
4326 */
4327 AppendCharToRedobuff(c);
4328
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004329 // If deleted before the insertion point, adjust it
Bram Moolenaar3d1956b2014-04-29 14:44:35 +02004330 if (curwin->w_cursor.lnum == Insstart_orig.lnum
Bram Moolenaar891e1fd2018-06-06 18:02:39 +02004331 && curwin->w_cursor.col < Insstart_orig.col)
Bram Moolenaar3d1956b2014-04-29 14:44:35 +02004332 Insstart_orig.col = curwin->w_cursor.col;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004333
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004334 // vi behaviour: the cursor moves backward but the character that
4335 // was there remains visible
4336 // Vim behaviour: the cursor moves backward and the character that
4337 // was there is erased from the screen.
4338 // We can emulate the vi behaviour by pretending there is a dollar
4339 // displayed even when there isn't.
4340 // --pkv Sun Jan 19 01:56:40 EST 2003
Bram Moolenaar76b9b362012-02-04 23:35:00 +01004341 if (vim_strchr(p_cpo, CPO_BACKSPACE) != NULL && dollar_vcol == -1)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004342 dollar_vcol = curwin->w_virtcol;
4343
Bram Moolenaarce3be472008-01-14 19:12:28 +00004344#ifdef FEAT_FOLDING
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004345 // When deleting a char the cursor line must never be in a closed fold.
4346 // E.g., when 'foldmethod' is indent and deleting the first non-white
4347 // char before a Tab.
Bram Moolenaarce3be472008-01-14 19:12:28 +00004348 if (did_backspace)
4349 foldOpenCursor();
4350#endif
4351
Bram Moolenaar071d4272004-06-13 20:20:40 +00004352 return did_backspace;
4353}
4354
Bram Moolenaarec2da362017-01-21 20:04:22 +01004355/*
4356 * Handle receiving P_PS: start paste mode. Inserts the following text up to
4357 * P_PE literally.
4358 * When "drop" is TRUE then consume the text and drop it.
4359 */
4360 int
4361bracketed_paste(paste_mode_T mode, int drop, garray_T *gap)
4362{
4363 int c;
4364 char_u buf[NUMBUFLEN + MB_MAXBYTES];
4365 int idx = 0;
4366 char_u *end = find_termcode((char_u *)"PE");
4367 int ret_char = -1;
4368 int save_allow_keys = allow_keys;
Bram Moolenaar9e817c82017-01-25 21:36:17 +01004369 int save_paste = p_paste;
Bram Moolenaarec2da362017-01-21 20:04:22 +01004370
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004371 // If the end code is too long we can't detect it, read everything.
Bram Moolenaarfe4bbac2020-01-20 21:12:20 +01004372 if (end != NULL && STRLEN(end) >= NUMBUFLEN)
Bram Moolenaarec2da362017-01-21 20:04:22 +01004373 end = NULL;
4374 ++no_mapping;
4375 allow_keys = 0;
Bram Moolenaarfdd71552018-07-28 23:12:05 +02004376 if (!p_paste)
4377 // Also have the side effects of setting 'paste' to make it work much
4378 // faster.
Bram Moolenaar31e5c602022-04-15 13:53:33 +01004379 set_option_value_give_err((char_u *)"paste", TRUE, NULL, 0);
Bram Moolenaar9e817c82017-01-25 21:36:17 +01004380
Bram Moolenaarec2da362017-01-21 20:04:22 +01004381 for (;;)
4382 {
Bram Moolenaarfdd71552018-07-28 23:12:05 +02004383 // When the end is not defined read everything there is.
Bram Moolenaarec2da362017-01-21 20:04:22 +01004384 if (end == NULL && vpeekc() == NUL)
4385 break;
Bram Moolenaarfdd71552018-07-28 23:12:05 +02004386 do
Bram Moolenaarfdd71552018-07-28 23:12:05 +02004387 c = vgetc();
Bram Moolenaarabab0b02019-03-30 18:47:01 +01004388 while (c == K_IGNORE || c == K_VER_SCROLLBAR || c == K_HOR_SCROLLBAR);
Bram Moolenaar98a336d2020-01-20 20:22:30 +01004389 if (c == NUL || got_int || (ex_normal_busy > 0 && c == Ctrl_C))
Bram Moolenaarfdd71552018-07-28 23:12:05 +02004390 // When CTRL-C was encountered the typeahead will be flushed and we
Bram Moolenaar98a336d2020-01-20 20:22:30 +01004391 // won't get the end sequence. Except when using ":normal".
Bram Moolenaarfdd71552018-07-28 23:12:05 +02004392 break;
4393
Bram Moolenaarec2da362017-01-21 20:04:22 +01004394 if (has_mbyte)
4395 idx += (*mb_char2bytes)(c, buf + idx);
4396 else
Bram Moolenaarec2da362017-01-21 20:04:22 +01004397 buf[idx++] = c;
4398 buf[idx] = NUL;
Bram Moolenaar866c6882017-04-07 14:02:01 +02004399 if (end != NULL && STRNCMP(buf, end, idx) == 0)
Bram Moolenaarec2da362017-01-21 20:04:22 +01004400 {
4401 if (end[idx] == NUL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004402 break; // Found the end of paste code.
Bram Moolenaarec2da362017-01-21 20:04:22 +01004403 continue;
4404 }
4405 if (!drop)
4406 {
4407 switch (mode)
4408 {
4409 case PASTE_CMDLINE:
4410 put_on_cmdline(buf, idx, TRUE);
4411 break;
4412
4413 case PASTE_EX:
Bram Moolenaar806d0372022-01-25 20:45:16 +00004414 // add one for the NUL that is going to be appended
4415 if (gap != NULL && ga_grow(gap, idx + 1) == OK)
Bram Moolenaarec2da362017-01-21 20:04:22 +01004416 {
4417 mch_memmove((char *)gap->ga_data + gap->ga_len,
4418 buf, (size_t)idx);
4419 gap->ga_len += idx;
4420 }
4421 break;
4422
4423 case PASTE_INSERT:
4424 if (stop_arrow() == OK)
4425 {
Bram Moolenaar915350e2017-01-24 17:50:52 +01004426 c = buf[0];
4427 if (idx == 1 && (c == CAR || c == K_KENTER || c == NL))
4428 ins_eol(c);
4429 else
Bram Moolenaar076e5022017-01-24 18:58:30 +01004430 {
Bram Moolenaar915350e2017-01-24 17:50:52 +01004431 ins_char_bytes(buf, idx);
Bram Moolenaar076e5022017-01-24 18:58:30 +01004432 AppendToRedobuffLit(buf, idx);
4433 }
Bram Moolenaarec2da362017-01-21 20:04:22 +01004434 }
4435 break;
4436
4437 case PASTE_ONE_CHAR:
4438 if (ret_char == -1)
4439 {
Bram Moolenaarec2da362017-01-21 20:04:22 +01004440 if (has_mbyte)
4441 ret_char = (*mb_ptr2char)(buf);
4442 else
Bram Moolenaarec2da362017-01-21 20:04:22 +01004443 ret_char = buf[0];
4444 }
4445 break;
4446 }
4447 }
4448 idx = 0;
4449 }
Bram Moolenaar9e817c82017-01-25 21:36:17 +01004450
Bram Moolenaarec2da362017-01-21 20:04:22 +01004451 --no_mapping;
4452 allow_keys = save_allow_keys;
Bram Moolenaarfdd71552018-07-28 23:12:05 +02004453 if (!save_paste)
Bram Moolenaar31e5c602022-04-15 13:53:33 +01004454 set_option_value_give_err((char_u *)"paste", FALSE, NULL, 0);
Bram Moolenaarec2da362017-01-21 20:04:22 +01004455
4456 return ret_char;
4457}
4458
Bram Moolenaara23ccb82006-02-27 00:08:02 +00004459#if defined(FEAT_GUI_TABLINE) || defined(PROTO)
Bram Moolenaara94bc432006-03-10 21:42:59 +00004460 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01004461ins_tabline(int c)
Bram Moolenaara23ccb82006-02-27 00:08:02 +00004462{
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004463 // We will be leaving the current window, unless closing another tab.
Bram Moolenaara23ccb82006-02-27 00:08:02 +00004464 if (c != K_TABMENU || current_tabmenu != TABLINE_MENU_CLOSE
4465 || (current_tab != 0 && current_tab != tabpage_index(curtab)))
4466 {
4467 undisplay_dollar();
4468 start_arrow(&curwin->w_cursor);
Bram Moolenaara23ccb82006-02-27 00:08:02 +00004469 can_cindent = TRUE;
Bram Moolenaara23ccb82006-02-27 00:08:02 +00004470 }
4471
4472 if (c == K_TABLINE)
4473 goto_tabpage(current_tab);
4474 else
Bram Moolenaar437df8f2006-04-27 21:47:44 +00004475 {
Bram Moolenaara23ccb82006-02-27 00:08:02 +00004476 handle_tabmenu();
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004477 redraw_statuslines(); // will redraw the tabline when needed
Bram Moolenaar437df8f2006-04-27 21:47:44 +00004478 }
Bram Moolenaara23ccb82006-02-27 00:08:02 +00004479}
4480#endif
4481
4482#if defined(FEAT_GUI) || defined(PROTO)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004483 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01004484ins_scroll(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004485{
4486 pos_T tpos;
4487
4488 undisplay_dollar();
4489 tpos = curwin->w_cursor;
4490 if (gui_do_scroll())
4491 {
4492 start_arrow(&tpos);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004493 can_cindent = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004494 }
4495}
4496
4497 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01004498ins_horscroll(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004499{
4500 pos_T tpos;
4501
4502 undisplay_dollar();
4503 tpos = curwin->w_cursor;
Bram Moolenaar8d9b40e2010-07-25 15:49:07 +02004504 if (gui_do_horiz_scroll(scrollbar_value, FALSE))
Bram Moolenaar071d4272004-06-13 20:20:40 +00004505 {
4506 start_arrow(&tpos);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004507 can_cindent = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004508 }
4509}
4510#endif
4511
4512 static void
Bram Moolenaar75bf3d22019-03-26 22:46:05 +01004513ins_left(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004514{
4515 pos_T tpos;
Bram Moolenaar75bf3d22019-03-26 22:46:05 +01004516 int end_change = dont_sync_undo == FALSE; // end undoable change
Bram Moolenaar071d4272004-06-13 20:20:40 +00004517
4518#ifdef FEAT_FOLDING
4519 if ((fdo_flags & FDO_HOR) && KeyTyped)
4520 foldOpenCursor();
4521#endif
4522 undisplay_dollar();
4523 tpos = curwin->w_cursor;
4524 if (oneleft() == OK)
4525 {
Bram Moolenaar39fecab2006-08-29 14:07:36 +00004526#if defined(FEAT_XIM) && defined(FEAT_GUI_GTK)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004527 // Only call start_arrow() when not busy with preediting, it will
4528 // break undo. K_LEFT is inserted in im_correct_cursor().
Bram Moolenaar5c6dbcb2017-08-30 22:00:20 +02004529 if (p_imst == IM_OVER_THE_SPOT || !im_is_preediting())
Bram Moolenaar39fecab2006-08-29 14:07:36 +00004530#endif
Bram Moolenaar8b5f65a2015-09-01 19:26:12 +02004531 {
4532 start_arrow_with_change(&tpos, end_change);
4533 if (!end_change)
4534 AppendCharToRedobuff(K_LEFT);
4535 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004536#ifdef FEAT_RIGHTLEFT
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004537 // If exit reversed string, position is fixed
Bram Moolenaar071d4272004-06-13 20:20:40 +00004538 if (revins_scol != -1 && (int)curwin->w_cursor.col >= revins_scol)
4539 revins_legal++;
4540 revins_chars++;
4541#endif
4542 }
4543
4544 /*
4545 * if 'whichwrap' set for cursor in insert mode may go to
4546 * previous line
4547 */
4548 else if (vim_strchr(p_ww, '[') != NULL && curwin->w_cursor.lnum > 1)
4549 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004550 // always break undo when moving upwards/downwards, else undo may break
Bram Moolenaar071d4272004-06-13 20:20:40 +00004551 start_arrow(&tpos);
4552 --(curwin->w_cursor.lnum);
4553 coladvance((colnr_T)MAXCOL);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004554 curwin->w_set_curswant = TRUE; // so we stay at the end
Bram Moolenaar071d4272004-06-13 20:20:40 +00004555 }
4556 else
Bram Moolenaar165bc692015-07-21 17:53:25 +02004557 vim_beep(BO_CRSR);
Bram Moolenaar8b5f65a2015-09-01 19:26:12 +02004558 dont_sync_undo = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004559}
4560
4561 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01004562ins_home(int c)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004563{
4564 pos_T tpos;
4565
4566#ifdef FEAT_FOLDING
4567 if ((fdo_flags & FDO_HOR) && KeyTyped)
4568 foldOpenCursor();
4569#endif
4570 undisplay_dollar();
4571 tpos = curwin->w_cursor;
4572 if (c == K_C_HOME)
4573 curwin->w_cursor.lnum = 1;
4574 curwin->w_cursor.col = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004575 curwin->w_cursor.coladd = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004576 curwin->w_curswant = 0;
4577 start_arrow(&tpos);
4578}
4579
4580 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01004581ins_end(int c)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004582{
4583 pos_T tpos;
4584
4585#ifdef FEAT_FOLDING
4586 if ((fdo_flags & FDO_HOR) && KeyTyped)
4587 foldOpenCursor();
4588#endif
4589 undisplay_dollar();
4590 tpos = curwin->w_cursor;
4591 if (c == K_C_END)
4592 curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
4593 coladvance((colnr_T)MAXCOL);
4594 curwin->w_curswant = MAXCOL;
4595
4596 start_arrow(&tpos);
4597}
4598
4599 static void
Bram Moolenaar75bf3d22019-03-26 22:46:05 +01004600ins_s_left()
Bram Moolenaar071d4272004-06-13 20:20:40 +00004601{
Bram Moolenaar75bf3d22019-03-26 22:46:05 +01004602 int end_change = dont_sync_undo == FALSE; // end undoable change
Bram Moolenaar071d4272004-06-13 20:20:40 +00004603#ifdef FEAT_FOLDING
4604 if ((fdo_flags & FDO_HOR) && KeyTyped)
4605 foldOpenCursor();
4606#endif
4607 undisplay_dollar();
4608 if (curwin->w_cursor.lnum > 1 || curwin->w_cursor.col > 0)
4609 {
Bram Moolenaar75bf3d22019-03-26 22:46:05 +01004610 start_arrow_with_change(&curwin->w_cursor, end_change);
4611 if (!end_change)
4612 AppendCharToRedobuff(K_S_LEFT);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004613 (void)bck_word(1L, FALSE, FALSE);
4614 curwin->w_set_curswant = TRUE;
4615 }
4616 else
Bram Moolenaar165bc692015-07-21 17:53:25 +02004617 vim_beep(BO_CRSR);
Bram Moolenaar75bf3d22019-03-26 22:46:05 +01004618 dont_sync_undo = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004619}
4620
4621 static void
Bram Moolenaar75bf3d22019-03-26 22:46:05 +01004622ins_right(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004623{
Bram Moolenaar75bf3d22019-03-26 22:46:05 +01004624 int end_change = dont_sync_undo == FALSE; // end undoable change
4625
Bram Moolenaar071d4272004-06-13 20:20:40 +00004626#ifdef FEAT_FOLDING
4627 if ((fdo_flags & FDO_HOR) && KeyTyped)
4628 foldOpenCursor();
4629#endif
4630 undisplay_dollar();
Bram Moolenaar29ddebe2019-01-26 17:28:26 +01004631 if (gchar_cursor() != NUL || virtual_active())
Bram Moolenaar071d4272004-06-13 20:20:40 +00004632 {
Bram Moolenaar8b5f65a2015-09-01 19:26:12 +02004633 start_arrow_with_change(&curwin->w_cursor, end_change);
4634 if (!end_change)
4635 AppendCharToRedobuff(K_RIGHT);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004636 curwin->w_set_curswant = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004637 if (virtual_active())
4638 oneright();
4639 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00004640 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00004641 if (has_mbyte)
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00004642 curwin->w_cursor.col += (*mb_ptr2len)(ml_get_cursor());
Bram Moolenaar071d4272004-06-13 20:20:40 +00004643 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00004644 ++curwin->w_cursor.col;
4645 }
4646
4647#ifdef FEAT_RIGHTLEFT
4648 revins_legal++;
4649 if (revins_chars)
4650 revins_chars--;
4651#endif
4652 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004653 // if 'whichwrap' set for cursor in insert mode, may move the
4654 // cursor to the next line
Bram Moolenaar071d4272004-06-13 20:20:40 +00004655 else if (vim_strchr(p_ww, ']') != NULL
4656 && curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count)
4657 {
4658 start_arrow(&curwin->w_cursor);
4659 curwin->w_set_curswant = TRUE;
4660 ++curwin->w_cursor.lnum;
4661 curwin->w_cursor.col = 0;
4662 }
4663 else
Bram Moolenaar165bc692015-07-21 17:53:25 +02004664 vim_beep(BO_CRSR);
Bram Moolenaar8b5f65a2015-09-01 19:26:12 +02004665 dont_sync_undo = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004666}
4667
4668 static void
Bram Moolenaar75bf3d22019-03-26 22:46:05 +01004669ins_s_right()
Bram Moolenaar071d4272004-06-13 20:20:40 +00004670{
Bram Moolenaar75bf3d22019-03-26 22:46:05 +01004671 int end_change = dont_sync_undo == FALSE; // end undoable change
Bram Moolenaar071d4272004-06-13 20:20:40 +00004672#ifdef FEAT_FOLDING
4673 if ((fdo_flags & FDO_HOR) && KeyTyped)
4674 foldOpenCursor();
4675#endif
4676 undisplay_dollar();
4677 if (curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count
4678 || gchar_cursor() != NUL)
4679 {
Bram Moolenaar75bf3d22019-03-26 22:46:05 +01004680 start_arrow_with_change(&curwin->w_cursor, end_change);
4681 if (!end_change)
4682 AppendCharToRedobuff(K_S_RIGHT);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004683 (void)fwd_word(1L, FALSE, 0);
4684 curwin->w_set_curswant = TRUE;
4685 }
4686 else
Bram Moolenaar165bc692015-07-21 17:53:25 +02004687 vim_beep(BO_CRSR);
Bram Moolenaar75bf3d22019-03-26 22:46:05 +01004688 dont_sync_undo = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004689}
4690
4691 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01004692ins_up(
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004693 int startcol) // when TRUE move to Insstart.col
Bram Moolenaar071d4272004-06-13 20:20:40 +00004694{
4695 pos_T tpos;
4696 linenr_T old_topline = curwin->w_topline;
4697#ifdef FEAT_DIFF
4698 int old_topfill = curwin->w_topfill;
4699#endif
4700
4701 undisplay_dollar();
4702 tpos = curwin->w_cursor;
4703 if (cursor_up(1L, TRUE) == OK)
4704 {
4705 if (startcol)
4706 coladvance(getvcol_nolist(&Insstart));
4707 if (old_topline != curwin->w_topline
4708#ifdef FEAT_DIFF
4709 || old_topfill != curwin->w_topfill
4710#endif
4711 )
Bram Moolenaara4d158b2022-08-14 14:17:45 +01004712 redraw_later(UPD_VALID);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004713 start_arrow(&tpos);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004714 can_cindent = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004715 }
4716 else
Bram Moolenaar165bc692015-07-21 17:53:25 +02004717 vim_beep(BO_CRSR);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004718}
4719
4720 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01004721ins_pageup(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004722{
4723 pos_T tpos;
4724
4725 undisplay_dollar();
Bram Moolenaar7fc904b2006-04-13 20:37:35 +00004726
Bram Moolenaar7fc904b2006-04-13 20:37:35 +00004727 if (mod_mask & MOD_MASK_CTRL)
4728 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004729 // <C-PageUp>: tab page back
Bram Moolenaarbc444822006-10-17 11:37:50 +00004730 if (first_tabpage->tp_next != NULL)
4731 {
4732 start_arrow(&curwin->w_cursor);
4733 goto_tabpage(-1);
4734 }
Bram Moolenaar7fc904b2006-04-13 20:37:35 +00004735 return;
4736 }
Bram Moolenaar7fc904b2006-04-13 20:37:35 +00004737
Bram Moolenaar071d4272004-06-13 20:20:40 +00004738 tpos = curwin->w_cursor;
4739 if (onepage(BACKWARD, 1L) == OK)
4740 {
4741 start_arrow(&tpos);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004742 can_cindent = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004743 }
4744 else
Bram Moolenaar165bc692015-07-21 17:53:25 +02004745 vim_beep(BO_CRSR);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004746}
4747
4748 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01004749ins_down(
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004750 int startcol) // when TRUE move to Insstart.col
Bram Moolenaar071d4272004-06-13 20:20:40 +00004751{
4752 pos_T tpos;
4753 linenr_T old_topline = curwin->w_topline;
4754#ifdef FEAT_DIFF
4755 int old_topfill = curwin->w_topfill;
4756#endif
4757
4758 undisplay_dollar();
4759 tpos = curwin->w_cursor;
4760 if (cursor_down(1L, TRUE) == OK)
4761 {
4762 if (startcol)
4763 coladvance(getvcol_nolist(&Insstart));
4764 if (old_topline != curwin->w_topline
4765#ifdef FEAT_DIFF
4766 || old_topfill != curwin->w_topfill
4767#endif
4768 )
Bram Moolenaara4d158b2022-08-14 14:17:45 +01004769 redraw_later(UPD_VALID);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004770 start_arrow(&tpos);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004771 can_cindent = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004772 }
4773 else
Bram Moolenaar165bc692015-07-21 17:53:25 +02004774 vim_beep(BO_CRSR);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004775}
4776
4777 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01004778ins_pagedown(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004779{
4780 pos_T tpos;
4781
4782 undisplay_dollar();
Bram Moolenaar7fc904b2006-04-13 20:37:35 +00004783
Bram Moolenaar7fc904b2006-04-13 20:37:35 +00004784 if (mod_mask & MOD_MASK_CTRL)
4785 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004786 // <C-PageDown>: tab page forward
Bram Moolenaarbc444822006-10-17 11:37:50 +00004787 if (first_tabpage->tp_next != NULL)
4788 {
4789 start_arrow(&curwin->w_cursor);
4790 goto_tabpage(0);
4791 }
Bram Moolenaar7fc904b2006-04-13 20:37:35 +00004792 return;
4793 }
Bram Moolenaar7fc904b2006-04-13 20:37:35 +00004794
Bram Moolenaar071d4272004-06-13 20:20:40 +00004795 tpos = curwin->w_cursor;
4796 if (onepage(FORWARD, 1L) == OK)
4797 {
4798 start_arrow(&tpos);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004799 can_cindent = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004800 }
4801 else
Bram Moolenaar165bc692015-07-21 17:53:25 +02004802 vim_beep(BO_CRSR);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004803}
4804
4805#ifdef FEAT_DND
4806 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01004807ins_drop(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004808{
Bram Moolenaarc3516f72020-09-08 22:45:35 +02004809 do_put('~', NULL, BACKWARD, 1L, PUT_CURSEND);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004810}
4811#endif
4812
4813/*
4814 * Handle TAB in Insert or Replace mode.
4815 * Return TRUE when the TAB needs to be inserted like a normal character.
4816 */
4817 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01004818ins_tab(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004819{
4820 int ind;
4821 int i;
4822 int temp;
4823
4824 if (Insstart_blank_vcol == MAXCOL && curwin->w_cursor.lnum == Insstart.lnum)
4825 Insstart_blank_vcol = get_nolist_virtcol();
4826 if (echeck_abbr(TAB + ABBR_OFF))
4827 return FALSE;
4828
4829 ind = inindent(0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004830 if (ind)
4831 can_cindent = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004832
4833 /*
Bram Moolenaar04958cb2018-06-23 19:23:02 +02004834 * When nothing special, insert TAB like a normal character.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004835 */
4836 if (!curbuf->b_p_et
Bram Moolenaar04958cb2018-06-23 19:23:02 +02004837#ifdef FEAT_VARTABS
4838 && !(p_sta && ind
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004839 // These five lines mean 'tabstop' != 'shiftwidth'
Bram Moolenaar04958cb2018-06-23 19:23:02 +02004840 && ((tabstop_count(curbuf->b_p_vts_array) > 1)
4841 || (tabstop_count(curbuf->b_p_vts_array) == 1
Bram Moolenaar6ed545e2022-05-09 20:09:23 +01004842 && tabstop_first(curbuf->b_p_vts_array)
Bram Moolenaar04958cb2018-06-23 19:23:02 +02004843 != get_sw_value(curbuf))
Bram Moolenaar6ed545e2022-05-09 20:09:23 +01004844 || (tabstop_count(curbuf->b_p_vts_array) == 0
4845 && curbuf->b_p_ts != get_sw_value(curbuf))))
Bram Moolenaar04958cb2018-06-23 19:23:02 +02004846 && tabstop_count(curbuf->b_p_vsts_array) == 0
4847#else
Bram Moolenaar6bcbcc52013-11-05 07:13:41 +01004848 && !(p_sta && ind && curbuf->b_p_ts != get_sw_value(curbuf))
Bram Moolenaar04958cb2018-06-23 19:23:02 +02004849#endif
Bram Moolenaar9f340fa2012-10-21 00:10:39 +02004850 && get_sts_value() == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004851 return TRUE;
4852
4853 if (stop_arrow() == FAIL)
4854 return TRUE;
4855
4856 did_ai = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004857 did_si = FALSE;
4858 can_si = FALSE;
4859 can_si_back = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004860 AppendToRedobuff((char_u *)"\t");
4861
Bram Moolenaar04958cb2018-06-23 19:23:02 +02004862#ifdef FEAT_VARTABS
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004863 if (p_sta && ind) // insert tab in indent, use 'shiftwidth'
Bram Moolenaar04958cb2018-06-23 19:23:02 +02004864 {
Bram Moolenaarc9fe5ab2018-07-05 22:27:08 +02004865 temp = (int)get_sw_value(curbuf);
Bram Moolenaar04958cb2018-06-23 19:23:02 +02004866 temp -= get_nolist_virtcol() % temp;
4867 }
Bram Moolenaar33d5ab32018-07-02 20:51:24 +02004868 else if (tabstop_count(curbuf->b_p_vsts_array) > 0 || curbuf->b_p_sts != 0)
Bram Moolenaar6ed545e2022-05-09 20:09:23 +01004869 // use 'softtabstop' when set
Bram Moolenaar33d5ab32018-07-02 20:51:24 +02004870 temp = tabstop_padding(get_nolist_virtcol(), get_sts_value(),
Bram Moolenaar04958cb2018-06-23 19:23:02 +02004871 curbuf->b_p_vsts_array);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004872 else // otherwise use 'tabstop'
Bram Moolenaar04958cb2018-06-23 19:23:02 +02004873 temp = tabstop_padding(get_nolist_virtcol(), curbuf->b_p_ts,
4874 curbuf->b_p_vts_array);
4875#else
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004876 if (p_sta && ind) // insert tab in indent, use 'shiftwidth'
Bram Moolenaar6bcbcc52013-11-05 07:13:41 +01004877 temp = (int)get_sw_value(curbuf);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004878 else if (curbuf->b_p_sts != 0) // use 'softtabstop' when set
Bram Moolenaar9f340fa2012-10-21 00:10:39 +02004879 temp = (int)get_sts_value();
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004880 else // otherwise use 'tabstop'
Bram Moolenaar071d4272004-06-13 20:20:40 +00004881 temp = (int)curbuf->b_p_ts;
4882 temp -= get_nolist_virtcol() % temp;
Bram Moolenaar04958cb2018-06-23 19:23:02 +02004883#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004884
4885 /*
4886 * Insert the first space with ins_char(). It will delete one char in
4887 * replace mode. Insert the rest with ins_str(); it will not delete any
Bram Moolenaar24959102022-05-07 20:01:16 +01004888 * chars. For MODE_VREPLACE state, we use ins_char() for all characters.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004889 */
4890 ins_char(' ');
4891 while (--temp > 0)
4892 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00004893 if (State & VREPLACE_FLAG)
4894 ins_char(' ');
4895 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00004896 {
4897 ins_str((char_u *)" ");
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004898 if (State & REPLACE_FLAG) // no char replaced
Bram Moolenaar071d4272004-06-13 20:20:40 +00004899 replace_push(NUL);
4900 }
4901 }
4902
4903 /*
4904 * When 'expandtab' not set: Replace spaces by TABs where possible.
4905 */
Bram Moolenaar04958cb2018-06-23 19:23:02 +02004906#ifdef FEAT_VARTABS
4907 if (!curbuf->b_p_et && (tabstop_count(curbuf->b_p_vsts_array) > 0
Bram Moolenaar6ed545e2022-05-09 20:09:23 +01004908 || get_sts_value() > 0
Bram Moolenaar04958cb2018-06-23 19:23:02 +02004909 || (p_sta && ind)))
4910#else
Bram Moolenaar9f340fa2012-10-21 00:10:39 +02004911 if (!curbuf->b_p_et && (get_sts_value() || (p_sta && ind)))
Bram Moolenaar04958cb2018-06-23 19:23:02 +02004912#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004913 {
4914 char_u *ptr;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004915 char_u *saved_line = NULL; // init for GCC
Bram Moolenaar071d4272004-06-13 20:20:40 +00004916 pos_T pos;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004917 pos_T fpos;
4918 pos_T *cursor;
4919 colnr_T want_vcol, vcol;
4920 int change_col = -1;
4921 int save_list = curwin->w_p_list;
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01004922 char_u *tab = (char_u *)"\t";
4923 chartabsize_T cts;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004924
4925 /*
Bram Moolenaar24959102022-05-07 20:01:16 +01004926 * Get the current line. For MODE_VREPLACE state, don't make real
4927 * changes yet, just work on a copy of the line.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004928 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004929 if (State & VREPLACE_FLAG)
4930 {
4931 pos = curwin->w_cursor;
4932 cursor = &pos;
4933 saved_line = vim_strsave(ml_get_curline());
4934 if (saved_line == NULL)
4935 return FALSE;
4936 ptr = saved_line + pos.col;
4937 }
4938 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00004939 {
4940 ptr = ml_get_cursor();
4941 cursor = &curwin->w_cursor;
4942 }
4943
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004944 // When 'L' is not in 'cpoptions' a tab always takes up 'ts' spaces.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004945 if (vim_strchr(p_cpo, CPO_LISTWM) == NULL)
4946 curwin->w_p_list = FALSE;
4947
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004948 // Find first white before the cursor
Bram Moolenaar071d4272004-06-13 20:20:40 +00004949 fpos = curwin->w_cursor;
Bram Moolenaar1c465442017-03-12 20:10:05 +01004950 while (fpos.col > 0 && VIM_ISWHITE(ptr[-1]))
Bram Moolenaar071d4272004-06-13 20:20:40 +00004951 {
4952 --fpos.col;
4953 --ptr;
4954 }
4955
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004956 // In Replace mode, don't change characters before the insert point.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004957 if ((State & REPLACE_FLAG)
4958 && fpos.lnum == Insstart.lnum
4959 && fpos.col < Insstart.col)
4960 {
4961 ptr += Insstart.col - fpos.col;
4962 fpos.col = Insstart.col;
4963 }
4964
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004965 // compute virtual column numbers of first white and cursor
Bram Moolenaar071d4272004-06-13 20:20:40 +00004966 getvcol(curwin, &fpos, &vcol, NULL, NULL);
4967 getvcol(curwin, cursor, &want_vcol, NULL, NULL);
4968
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01004969 init_chartabsize_arg(&cts, curwin, 0, vcol, tab, tab);
4970
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004971 // Use as many TABs as possible. Beware of 'breakindent', 'showbreak'
4972 // and 'linebreak' adding extra virtual columns.
Bram Moolenaar1c465442017-03-12 20:10:05 +01004973 while (VIM_ISWHITE(*ptr))
Bram Moolenaar071d4272004-06-13 20:20:40 +00004974 {
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01004975 i = lbr_chartabsize(&cts);
4976 if (cts.cts_vcol + i > want_vcol)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004977 break;
4978 if (*ptr != TAB)
4979 {
4980 *ptr = TAB;
4981 if (change_col < 0)
4982 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004983 change_col = fpos.col; // Column of first change
4984 // May have to adjust Insstart
Bram Moolenaar071d4272004-06-13 20:20:40 +00004985 if (fpos.lnum == Insstart.lnum && fpos.col < Insstart.col)
4986 Insstart.col = fpos.col;
4987 }
4988 }
4989 ++fpos.col;
4990 ++ptr;
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01004991 cts.cts_vcol += i;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004992 }
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01004993 vcol = cts.cts_vcol;
4994 clear_chartabsize_arg(&cts);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004995
4996 if (change_col >= 0)
4997 {
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01004998 int repl_off = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004999
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005000 // Skip over the spaces we need.
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01005001 init_chartabsize_arg(&cts, curwin, 0, vcol, ptr, ptr);
5002 while (cts.cts_vcol < want_vcol && *cts.cts_ptr == ' ')
Bram Moolenaar071d4272004-06-13 20:20:40 +00005003 {
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01005004 cts.cts_vcol += lbr_chartabsize(&cts);
5005 ++cts.cts_ptr;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005006 ++repl_off;
5007 }
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01005008 ptr = cts.cts_ptr;
5009 vcol = cts.cts_vcol;
5010 clear_chartabsize_arg(&cts);
5011
Bram Moolenaar071d4272004-06-13 20:20:40 +00005012 if (vcol > want_vcol)
5013 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005014 // Must have a char with 'showbreak' just before it.
Bram Moolenaar071d4272004-06-13 20:20:40 +00005015 --ptr;
5016 --repl_off;
5017 }
5018 fpos.col += repl_off;
5019
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005020 // Delete following spaces.
Bram Moolenaar071d4272004-06-13 20:20:40 +00005021 i = cursor->col - fpos.col;
5022 if (i > 0)
5023 {
Bram Moolenaar5cb0b932020-01-03 21:25:59 +01005024#ifdef FEAT_PROP_POPUP
5025 if (!(State & VREPLACE_FLAG))
5026 {
Bram Moolenaarac15fd82020-01-09 21:35:48 +01005027 char_u *newp;
5028 int col;
5029
5030 newp = alloc(curbuf->b_ml.ml_line_len - i);
5031 if (newp == NULL)
5032 return FALSE;
5033
5034 col = ptr - curbuf->b_ml.ml_line_ptr;
5035 if (col > 0)
5036 mch_memmove(newp, ptr - col, col);
5037 mch_memmove(newp + col, ptr + i,
5038 curbuf->b_ml.ml_line_len - col - i);
5039
Bram Moolenaarfa4873c2022-06-30 22:13:59 +01005040 if (curbuf->b_ml.ml_flags & (ML_LINE_DIRTY | ML_ALLOCATED))
Bram Moolenaarac15fd82020-01-09 21:35:48 +01005041 vim_free(curbuf->b_ml.ml_line_ptr);
5042 curbuf->b_ml.ml_line_ptr = newp;
Bram Moolenaar5cb0b932020-01-03 21:25:59 +01005043 curbuf->b_ml.ml_line_len -= i;
Bram Moolenaarac15fd82020-01-09 21:35:48 +01005044 curbuf->b_ml.ml_flags =
5045 (curbuf->b_ml.ml_flags | ML_LINE_DIRTY) & ~ML_EMPTY;
Bram Moolenaar5cb0b932020-01-03 21:25:59 +01005046 }
5047 else
5048#endif
5049 STRMOVE(ptr, ptr + i);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005050 // correct replace stack.
Bram Moolenaar1f0bfe52018-07-29 16:09:22 +02005051 if ((State & REPLACE_FLAG) && !(State & VREPLACE_FLAG))
Bram Moolenaar071d4272004-06-13 20:20:40 +00005052 for (temp = i; --temp >= 0; )
5053 replace_join(repl_off);
5054 }
Bram Moolenaar009b2592004-10-24 19:18:58 +00005055#ifdef FEAT_NETBEANS_INTG
Bram Moolenaarb26e6322010-05-22 21:34:09 +02005056 if (netbeans_active())
Bram Moolenaar009b2592004-10-24 19:18:58 +00005057 {
Bram Moolenaar67c53842010-05-22 18:28:27 +02005058 netbeans_removed(curbuf, fpos.lnum, cursor->col, (long)(i + 1));
Bram Moolenaar009b2592004-10-24 19:18:58 +00005059 netbeans_inserted(curbuf, fpos.lnum, cursor->col,
5060 (char_u *)"\t", 1);
5061 }
5062#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005063 cursor->col -= i;
5064
Bram Moolenaar071d4272004-06-13 20:20:40 +00005065 /*
Bram Moolenaar24959102022-05-07 20:01:16 +01005066 * In MODE_VREPLACE state, we haven't changed anything yet. Do it
5067 * now by backspacing over the changed spacing and then inserting
5068 * the new spacing.
Bram Moolenaar071d4272004-06-13 20:20:40 +00005069 */
5070 if (State & VREPLACE_FLAG)
5071 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005072 // Backspace from real cursor to change_col
Bram Moolenaar071d4272004-06-13 20:20:40 +00005073 backspace_until_column(change_col);
5074
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005075 // Insert each char in saved_line from changed_col to
5076 // ptr-cursor
Bram Moolenaar071d4272004-06-13 20:20:40 +00005077 ins_bytes_len(saved_line + change_col,
5078 cursor->col - change_col);
5079 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00005080 }
5081
Bram Moolenaar071d4272004-06-13 20:20:40 +00005082 if (State & VREPLACE_FLAG)
5083 vim_free(saved_line);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005084 curwin->w_p_list = save_list;
5085 }
5086
5087 return FALSE;
5088}
5089
5090/*
5091 * Handle CR or NL in insert mode.
Bram Moolenaar24a2d722018-04-24 19:36:43 +02005092 * Return FAIL when out of memory or can't undo.
Bram Moolenaar071d4272004-06-13 20:20:40 +00005093 */
Bram Moolenaar7591bb32019-03-30 13:53:47 +01005094 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01005095ins_eol(int c)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005096{
5097 int i;
5098
5099 if (echeck_abbr(c + ABBR_OFF))
Bram Moolenaarc3c3e692018-04-26 22:30:33 +02005100 return OK;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005101 if (stop_arrow() == FAIL)
Bram Moolenaarc3c3e692018-04-26 22:30:33 +02005102 return FAIL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005103 undisplay_dollar();
5104
5105 /*
5106 * Strange Vi behaviour: In Replace mode, typing a NL will not delete the
5107 * character under the cursor. Only push a NUL on the replace stack,
5108 * nothing to put back when the NL is deleted.
5109 */
Bram Moolenaar1f0bfe52018-07-29 16:09:22 +02005110 if ((State & REPLACE_FLAG) && !(State & VREPLACE_FLAG))
Bram Moolenaar071d4272004-06-13 20:20:40 +00005111 replace_push(NUL);
5112
5113 /*
Bram Moolenaar24959102022-05-07 20:01:16 +01005114 * In MODE_VREPLACE state, a NL replaces the rest of the line, and starts
Bram Moolenaar071d4272004-06-13 20:20:40 +00005115 * replacing the next line, so we push all of the characters left on the
5116 * line onto the replace stack. This is not done here though, it is done
5117 * in open_line().
5118 */
5119
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005120 // Put cursor on NUL if on the last char and coladd is 1 (happens after
5121 // CTRL-O).
Bram Moolenaarf193fff2006-04-27 00:02:13 +00005122 if (virtual_active() && curwin->w_cursor.coladd > 0)
5123 coladvance(getviscol());
Bram Moolenaarf193fff2006-04-27 00:02:13 +00005124
Bram Moolenaar071d4272004-06-13 20:20:40 +00005125#ifdef FEAT_RIGHTLEFT
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005126 // NL in reverse insert will always start in the end of
5127 // current line.
Bram Moolenaar071d4272004-06-13 20:20:40 +00005128 if (revins_on)
5129 curwin->w_cursor.col += (colnr_T)STRLEN(ml_get_cursor());
5130#endif
5131
5132 AppendToRedobuff(NL_STR);
5133 i = open_line(FORWARD,
Bram Moolenaar6e371ec2021-12-12 14:16:39 +00005134 has_format_option(FO_RET_COMS) ? OPENLINE_DO_COM : 0, old_indent,
5135 NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005136 old_indent = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005137 can_cindent = TRUE;
Bram Moolenaar6ae133b2006-11-01 20:25:45 +00005138#ifdef FEAT_FOLDING
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005139 // When inserting a line the cursor line must never be in a closed fold.
Bram Moolenaar6ae133b2006-11-01 20:25:45 +00005140 foldOpenCursor();
5141#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005142
Bram Moolenaar24a2d722018-04-24 19:36:43 +02005143 return i;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005144}
5145
5146#ifdef FEAT_DIGRAPHS
5147/*
5148 * Handle digraph in insert mode.
5149 * Returns character still to be inserted, or NUL when nothing remaining to be
5150 * done.
5151 */
5152 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01005153ins_digraph(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005154{
5155 int c;
5156 int cc;
Bram Moolenaar9c520cb2011-05-10 14:22:16 +02005157 int did_putchar = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005158
5159 pc_status = PC_STATUS_UNSET;
5160 if (redrawing() && !char_avail())
5161 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005162 // may need to redraw when no more chars available now
Bram Moolenaar754b5602006-02-09 23:53:20 +00005163 ins_redraw(FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005164
5165 edit_putchar('?', TRUE);
Bram Moolenaar9c520cb2011-05-10 14:22:16 +02005166 did_putchar = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005167#ifdef FEAT_CMDL_INFO
5168 add_to_showcmd_c(Ctrl_K);
5169#endif
5170 }
5171
5172#ifdef USE_ON_FLY_SCROLL
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005173 dont_scroll = TRUE; // disallow scrolling here
Bram Moolenaar071d4272004-06-13 20:20:40 +00005174#endif
5175
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005176 // don't map the digraph chars. This also prevents the
5177 // mode message to be deleted when ESC is hit
Bram Moolenaar071d4272004-06-13 20:20:40 +00005178 ++no_mapping;
5179 ++allow_keys;
Bram Moolenaar61abfd12007-09-13 16:26:47 +00005180 c = plain_vgetc();
Bram Moolenaar071d4272004-06-13 20:20:40 +00005181 --no_mapping;
5182 --allow_keys;
Bram Moolenaar9c520cb2011-05-10 14:22:16 +02005183 if (did_putchar)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005184 // when the line fits in 'columns' the '?' is at the start of the next
5185 // line and will not be removed by the redraw
Bram Moolenaar9c520cb2011-05-10 14:22:16 +02005186 edit_unputchar();
Bram Moolenaar26dcc7e2010-07-14 22:35:55 +02005187
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005188 if (IS_SPECIAL(c) || mod_mask) // special key
Bram Moolenaar071d4272004-06-13 20:20:40 +00005189 {
5190#ifdef FEAT_CMDL_INFO
5191 clear_showcmd();
5192#endif
5193 insert_special(c, TRUE, FALSE);
5194 return NUL;
5195 }
5196 if (c != ESC)
5197 {
Bram Moolenaar9c520cb2011-05-10 14:22:16 +02005198 did_putchar = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005199 if (redrawing() && !char_avail())
5200 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005201 // may need to redraw when no more chars available now
Bram Moolenaar754b5602006-02-09 23:53:20 +00005202 ins_redraw(FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005203
5204 if (char2cells(c) == 1)
5205 {
Bram Moolenaar754b5602006-02-09 23:53:20 +00005206 ins_redraw(FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005207 edit_putchar(c, TRUE);
Bram Moolenaar9c520cb2011-05-10 14:22:16 +02005208 did_putchar = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005209 }
5210#ifdef FEAT_CMDL_INFO
5211 add_to_showcmd_c(c);
5212#endif
5213 }
5214 ++no_mapping;
5215 ++allow_keys;
Bram Moolenaar61abfd12007-09-13 16:26:47 +00005216 cc = plain_vgetc();
Bram Moolenaar071d4272004-06-13 20:20:40 +00005217 --no_mapping;
5218 --allow_keys;
Bram Moolenaar9c520cb2011-05-10 14:22:16 +02005219 if (did_putchar)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005220 // when the line fits in 'columns' the '?' is at the start of the
5221 // next line and will not be removed by a redraw
Bram Moolenaar9c520cb2011-05-10 14:22:16 +02005222 edit_unputchar();
Bram Moolenaar071d4272004-06-13 20:20:40 +00005223 if (cc != ESC)
5224 {
5225 AppendToRedobuff((char_u *)CTRL_V_STR);
h-east29b85712021-07-26 21:54:04 +02005226 c = digraph_get(c, cc, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005227#ifdef FEAT_CMDL_INFO
5228 clear_showcmd();
5229#endif
5230 return c;
5231 }
5232 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00005233#ifdef FEAT_CMDL_INFO
5234 clear_showcmd();
5235#endif
5236 return NUL;
5237}
5238#endif
5239
5240/*
5241 * Handle CTRL-E and CTRL-Y in Insert mode: copy char from other line.
5242 * Returns the char to be inserted, or NUL if none found.
5243 */
Bram Moolenaar8320da42012-04-30 18:18:47 +02005244 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01005245ins_copychar(linenr_T lnum)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005246{
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01005247 int c;
5248 char_u *ptr, *prev_ptr;
5249 char_u *line;
5250 chartabsize_T cts;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005251
5252 if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count)
5253 {
Bram Moolenaar165bc692015-07-21 17:53:25 +02005254 vim_beep(BO_COPY);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005255 return NUL;
5256 }
5257
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005258 // try to advance to the cursor column
Bram Moolenaarfa4873c2022-06-30 22:13:59 +01005259 validate_virtcol();
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01005260 line = ml_get(lnum);
5261 prev_ptr = line;
5262 init_chartabsize_arg(&cts, curwin, lnum, 0, line, line);
5263 while (cts.cts_vcol < curwin->w_virtcol && *cts.cts_ptr != NUL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005264 {
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01005265 prev_ptr = cts.cts_ptr;
5266 cts.cts_vcol += lbr_chartabsize_adv(&cts);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005267 }
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01005268 if (cts.cts_vcol > curwin->w_virtcol)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005269 ptr = prev_ptr;
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01005270 else
5271 ptr = cts.cts_ptr;
5272 clear_chartabsize_arg(&cts);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005273
Bram Moolenaar071d4272004-06-13 20:20:40 +00005274 c = (*mb_ptr2char)(ptr);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005275 if (c == NUL)
Bram Moolenaar165bc692015-07-21 17:53:25 +02005276 vim_beep(BO_COPY);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005277 return c;
5278}
5279
Bram Moolenaar4be06f92005-07-29 22:36:03 +00005280/*
5281 * CTRL-Y or CTRL-E typed in Insert mode.
5282 */
5283 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01005284ins_ctrl_ey(int tc)
Bram Moolenaar4be06f92005-07-29 22:36:03 +00005285{
5286 int c = tc;
5287
Bram Moolenaar7591bb32019-03-30 13:53:47 +01005288 if (ctrl_x_mode_scroll())
Bram Moolenaar4be06f92005-07-29 22:36:03 +00005289 {
5290 if (c == Ctrl_Y)
5291 scrolldown_clamp();
5292 else
5293 scrollup_clamp();
Bram Moolenaara4d158b2022-08-14 14:17:45 +01005294 redraw_later(UPD_VALID);
Bram Moolenaar4be06f92005-07-29 22:36:03 +00005295 }
5296 else
Bram Moolenaar4be06f92005-07-29 22:36:03 +00005297 {
5298 c = ins_copychar(curwin->w_cursor.lnum + (c == Ctrl_Y ? -1 : 1));
5299 if (c != NUL)
5300 {
5301 long tw_save;
5302
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005303 // The character must be taken literally, insert like it
5304 // was typed after a CTRL-V, and pretend 'textwidth'
5305 // wasn't set. Digits, 'o' and 'x' are special after a
5306 // CTRL-V, don't use it for these.
Bram Moolenaar4be06f92005-07-29 22:36:03 +00005307 if (c < 256 && !isalnum(c))
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005308 AppendToRedobuff((char_u *)CTRL_V_STR); // CTRL-V
Bram Moolenaar4be06f92005-07-29 22:36:03 +00005309 tw_save = curbuf->b_p_tw;
5310 curbuf->b_p_tw = -1;
5311 insert_special(c, TRUE, FALSE);
5312 curbuf->b_p_tw = tw_save;
5313#ifdef FEAT_RIGHTLEFT
5314 revins_chars++;
5315 revins_legal++;
5316#endif
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005317 c = Ctrl_V; // pretend CTRL-V is last character
Bram Moolenaar4be06f92005-07-29 22:36:03 +00005318 auto_format(FALSE, TRUE);
5319 }
5320 }
5321 return c;
5322}
5323
Bram Moolenaar071d4272004-06-13 20:20:40 +00005324/*
5325 * Get the value that w_virtcol would have when 'list' is off.
5326 * Unless 'cpo' contains the 'L' flag.
5327 */
Bram Moolenaarf9514162018-11-22 03:08:29 +01005328 colnr_T
Bram Moolenaar7454a062016-01-30 15:14:10 +01005329get_nolist_virtcol(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005330{
Bram Moolenaarf9514162018-11-22 03:08:29 +01005331 // check validity of cursor in current buffer
5332 if (curwin->w_buffer == NULL
5333 || curwin->w_buffer->b_ml.ml_mfp == NULL
5334 || curwin->w_cursor.lnum > curwin->w_buffer->b_ml.ml_line_count)
5335 return 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005336 if (curwin->w_p_list && vim_strchr(p_cpo, CPO_LISTWM) == NULL)
5337 return getvcol_nolist(&curwin->w_cursor);
5338 validate_virtcol();
5339 return curwin->w_virtcol;
5340}
Bram Moolenaarf5876f12012-02-29 18:22:08 +01005341
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01005342#if defined(FEAT_EVAL)
Bram Moolenaarf5876f12012-02-29 18:22:08 +01005343/*
5344 * Handle the InsertCharPre autocommand.
5345 * "c" is the character that was typed.
5346 * Return a pointer to allocated memory with the replacement string.
5347 * Return NULL to continue inserting "c".
5348 */
5349 static char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01005350do_insert_char_pre(int c)
Bram Moolenaarf5876f12012-02-29 18:22:08 +01005351{
Bram Moolenaar704984a2012-06-01 14:57:51 +02005352 char_u *res;
Bram Moolenaar704984a2012-06-01 14:57:51 +02005353 char_u buf[MB_MAXBYTES + 1];
Bram Moolenaar8ad16da2019-01-06 15:29:57 +01005354 int save_State = State;
Bram Moolenaarf5876f12012-02-29 18:22:08 +01005355
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005356 // Return quickly when there is nothing to do.
Bram Moolenaarf5876f12012-02-29 18:22:08 +01005357 if (!has_insertcharpre())
5358 return NULL;
5359
Bram Moolenaar704984a2012-06-01 14:57:51 +02005360 if (has_mbyte)
5361 buf[(*mb_char2bytes)(c, buf)] = NUL;
5362 else
Bram Moolenaar704984a2012-06-01 14:57:51 +02005363 {
5364 buf[0] = c;
5365 buf[1] = NUL;
5366 }
5367
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005368 // Lock the text to avoid weird things from happening.
zeertzjqcfe45652022-05-27 17:26:55 +01005369 ++textlock;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005370 set_vim_var_string(VV_CHAR, buf, -1); // set v:char
Bram Moolenaarf5876f12012-02-29 18:22:08 +01005371
Bram Moolenaar704984a2012-06-01 14:57:51 +02005372 res = NULL;
Bram Moolenaar9fa95062018-08-08 22:08:32 +02005373 if (ins_apply_autocmds(EVENT_INSERTCHARPRE))
Bram Moolenaar704984a2012-06-01 14:57:51 +02005374 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005375 // Get the value of v:char. It may be empty or more than one
5376 // character. Only use it when changed, otherwise continue with the
5377 // original character to avoid breaking autoindent.
Bram Moolenaar704984a2012-06-01 14:57:51 +02005378 if (STRCMP(buf, get_vim_var_str(VV_CHAR)) != 0)
5379 res = vim_strsave(get_vim_var_str(VV_CHAR));
5380 }
Bram Moolenaarf5876f12012-02-29 18:22:08 +01005381
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005382 set_vim_var_string(VV_CHAR, NULL, -1); // clear v:char
zeertzjqcfe45652022-05-27 17:26:55 +01005383 --textlock;
Bram Moolenaarf5876f12012-02-29 18:22:08 +01005384
Bram Moolenaar8ad16da2019-01-06 15:29:57 +01005385 // Restore the State, it may have been changed.
5386 State = save_State;
5387
Bram Moolenaarf5876f12012-02-29 18:22:08 +01005388 return res;
5389}
5390#endif
Bram Moolenaar9fa95062018-08-08 22:08:32 +02005391
Bram Moolenaar7591bb32019-03-30 13:53:47 +01005392 int
Bram Moolenaarb20b9e12019-09-21 20:48:04 +02005393get_can_cindent(void)
Bram Moolenaar7591bb32019-03-30 13:53:47 +01005394{
5395 return can_cindent;
5396}
Bram Moolenaarb20b9e12019-09-21 20:48:04 +02005397
5398 void
5399set_can_cindent(int val)
5400{
5401 can_cindent = val;
5402}
Bram Moolenaar7591bb32019-03-30 13:53:47 +01005403
Bram Moolenaar9fa95062018-08-08 22:08:32 +02005404/*
5405 * Trigger "event" and take care of fixing undo.
5406 */
Bram Moolenaar7591bb32019-03-30 13:53:47 +01005407 int
Bram Moolenaar9fa95062018-08-08 22:08:32 +02005408ins_apply_autocmds(event_T event)
5409{
5410 varnumber_T tick = CHANGEDTICK(curbuf);
5411 int r;
5412
5413 r = apply_autocmds(event, NULL, NULL, FALSE, curbuf);
5414
5415 // If u_savesub() was called then we are not prepared to start
5416 // a new line. Call u_save() with no contents to fix that.
Bram Moolenaardb934952020-04-27 20:18:31 +02005417 // Except when leaving Insert mode.
5418 if (event != EVENT_INSERTLEAVE && tick != CHANGEDTICK(curbuf))
Bram Moolenaar9fa95062018-08-08 22:08:32 +02005419 u_save(curwin->w_cursor.lnum, (linenr_T)(curwin->w_cursor.lnum + 1));
5420
5421 return r;
5422}