blob: 70436b31f05e7546813ce55c59006ac3ff40ce13 [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 * ex_getln.c: Functions for entering and editing an Ex command line.
12 */
13
14#include "vim.h"
15
Bram Moolenaar37b15562018-08-14 22:08:25 +020016#ifndef MAX
17# define MAX(x,y) ((x) > (y) ? (x) : (y))
18#endif
19
Bram Moolenaar2f3cd2e2020-09-06 15:54:00 +020020// Return value when handling keys in command-line mode.
21#define CMDLINE_NOT_CHANGED 1
22#define CMDLINE_CHANGED 2
23#define GOTO_NORMAL_MODE 3
Bram Moolenaar9c929712020-09-07 22:05:28 +020024#define PROCESS_NEXT_KEY 4
Bram Moolenaar2f3cd2e2020-09-06 15:54:00 +020025
Bram Moolenaar438d1762018-09-30 17:11:48 +020026// The current cmdline_info. It is initialized in getcmdline() and after that
27// used by other functions. When invoking getcmdline() recursively it needs
28// to be saved with save_cmdline() and restored with restore_cmdline().
Bram Moolenaar66b51422019-08-18 21:44:12 +020029static cmdline_info_T ccline;
Bram Moolenaar071d4272004-06-13 20:20:40 +000030
31#ifdef FEAT_EVAL
Bram Moolenaar217e1b82019-12-01 21:41:28 +010032static int new_cmdpos; // position set by set_cmdline_pos()
Bram Moolenaar071d4272004-06-13 20:20:40 +000033#endif
34
Bram Moolenaar217e1b82019-12-01 21:41:28 +010035static int extra_char = NUL; // extra character to display when redrawing
36 // the command line
Bram Moolenaar6a77d262017-07-16 15:24:01 +020037static int extra_char_shift;
38
Bram Moolenaar071d4272004-06-13 20:20:40 +000039#ifdef FEAT_RIGHTLEFT
Bram Moolenaar217e1b82019-12-01 21:41:28 +010040static int cmd_hkmap = 0; // Hebrew mapping during command line
Bram Moolenaar071d4272004-06-13 20:20:40 +000041#endif
42
Bram Moolenaar9c929712020-09-07 22:05:28 +020043static char_u *getcmdline_int(int firstc, long count, int indent, int clear_ccline);
Bram Moolenaard25c16e2016-01-29 22:13:30 +010044static int cmdline_charsize(int idx);
45static void set_cmdspos(void);
46static void set_cmdspos_cursor(void);
Bram Moolenaard25c16e2016-01-29 22:13:30 +010047static void correct_cmdspos(int idx, int cells);
Bram Moolenaard25c16e2016-01-29 22:13:30 +010048static void alloc_cmdbuff(int len);
Bram Moolenaard25c16e2016-01-29 22:13:30 +010049static void draw_cmdline(int start, int len);
Bram Moolenaar66b51422019-08-18 21:44:12 +020050static void save_cmdline(cmdline_info_T *ccp);
51static void restore_cmdline(cmdline_info_T *ccp);
Bram Moolenaard25c16e2016-01-29 22:13:30 +010052static int cmdline_paste(int regname, int literally, int remcr);
Bram Moolenaard25c16e2016-01-29 22:13:30 +010053static void redrawcmdprompt(void);
Bram Moolenaard25c16e2016-01-29 22:13:30 +010054static int ccheck_abbr(int);
Bram Moolenaard93a7fc2021-01-04 12:42:13 +010055#ifdef FEAT_SEARCH_EXTRA
56static int empty_pattern_magic(char_u *pat, size_t len, magic_T magic_val);
57#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +000058
59#ifdef FEAT_CMDWIN
Bram Moolenaar3bab9392017-04-07 15:42:25 +020060static int open_cmdwin(void);
Bram Moolenaar7bae0b12019-11-21 22:14:18 +010061
zeertzjq9b7d2a92022-08-26 10:33:54 +010062static int cedit_key = -1; // key value of 'cedit' option
Bram Moolenaar071d4272004-06-13 20:20:40 +000063#endif
64
Bram Moolenaarfafcf0d2017-10-19 18:35:51 +020065
Bram Moolenaarfafcf0d2017-10-19 18:35:51 +020066 static void
67trigger_cmd_autocmd(int typechar, int evt)
68{
69 char_u typestr[2];
70
71 typestr[0] = typechar;
72 typestr[1] = NUL;
73 apply_autocmds(evt, typestr, typestr, FALSE, curbuf);
74}
Bram Moolenaarfafcf0d2017-10-19 18:35:51 +020075
Bram Moolenaar071d4272004-06-13 20:20:40 +000076/*
Bram Moolenaarf8e8c062017-10-22 14:44:17 +020077 * Abandon the command line.
78 */
79 static void
80abandon_cmdline(void)
81{
Bram Moolenaard23a8232018-02-10 18:45:26 +010082 VIM_CLEAR(ccline.cmdbuff);
Bram Moolenaarf8e8c062017-10-22 14:44:17 +020083 if (msg_scrolled == 0)
84 compute_cmdrow();
Bram Moolenaar32526b32019-01-19 17:43:09 +010085 msg("");
Bram Moolenaarf8e8c062017-10-22 14:44:17 +020086 redraw_cmdline = TRUE;
87}
88
Bram Moolenaaree219b02017-12-17 14:55:01 +010089#ifdef FEAT_SEARCH_EXTRA
Bram Moolenaarf8e8c062017-10-22 14:44:17 +020090/*
Bram Moolenaar66216052017-12-16 16:33:44 +010091 * Guess that the pattern matches everything. Only finds specific cases, such
92 * as a trailing \|, which can happen while typing a pattern.
93 */
94 static int
Bram Moolenaard93a7fc2021-01-04 12:42:13 +010095empty_pattern(char_u *p, int delim)
Bram Moolenaar66216052017-12-16 16:33:44 +010096{
Bram Moolenaard93a7fc2021-01-04 12:42:13 +010097 size_t n = STRLEN(p);
98 magic_T magic_val = MAGIC_ON;
Bram Moolenaar66216052017-12-16 16:33:44 +010099
Bram Moolenaard93a7fc2021-01-04 12:42:13 +0100100 if (n > 0)
101 (void) skip_regexp_ex(p, delim, magic_isset(), NULL, NULL, &magic_val);
102 else
103 return TRUE;
104
105 return empty_pattern_magic(p, n, magic_val);
106}
107
108 static int
109empty_pattern_magic(char_u *p, size_t len, magic_T magic_val)
110{
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100111 // remove trailing \v and the like
Bram Moolenaard93a7fc2021-01-04 12:42:13 +0100112 while (len >= 2 && p[len - 2] == '\\'
Bram Moolenaar6ed545e2022-05-09 20:09:23 +0100113 && vim_strchr((char_u *)"mMvVcCZ", p[len - 1]) != NULL)
Bram Moolenaard93a7fc2021-01-04 12:42:13 +0100114 len -= 2;
115
116 // true, if the pattern is empty, or the pattern ends with \| and magic is
117 // set (or it ends with '|' and very magic is set)
118 return len == 0 || (len > 1
119 && ((p[len - 2] == '\\'
120 && p[len - 1] == '|' && magic_val == MAGIC_ON)
121 || (p[len - 2] != '\\'
122 && p[len - 1] == '|' && magic_val == MAGIC_ALL)));
Bram Moolenaar66216052017-12-16 16:33:44 +0100123}
124
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200125// Struct to store the viewstate during 'incsearch' highlighting.
Bram Moolenaar9b25af32018-04-28 13:56:09 +0200126typedef struct {
127 colnr_T vs_curswant;
128 colnr_T vs_leftcol;
129 linenr_T vs_topline;
130# ifdef FEAT_DIFF
131 int vs_topfill;
132# endif
133 linenr_T vs_botline;
134 linenr_T vs_empty_rows;
135} viewstate_T;
136
137 static void
138save_viewstate(viewstate_T *vs)
139{
140 vs->vs_curswant = curwin->w_curswant;
141 vs->vs_leftcol = curwin->w_leftcol;
142 vs->vs_topline = curwin->w_topline;
143# ifdef FEAT_DIFF
144 vs->vs_topfill = curwin->w_topfill;
145# endif
146 vs->vs_botline = curwin->w_botline;
147 vs->vs_empty_rows = curwin->w_empty_rows;
148}
149
150 static void
151restore_viewstate(viewstate_T *vs)
152{
153 curwin->w_curswant = vs->vs_curswant;
154 curwin->w_leftcol = vs->vs_leftcol;
155 curwin->w_topline = vs->vs_topline;
156# ifdef FEAT_DIFF
157 curwin->w_topfill = vs->vs_topfill;
158# endif
159 curwin->w_botline = vs->vs_botline;
160 curwin->w_empty_rows = vs->vs_empty_rows;
161}
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200162
163// Struct to store the state of 'incsearch' highlighting.
164typedef struct {
165 pos_T search_start; // where 'incsearch' starts searching
Bram Moolenaar23324a02019-10-01 17:39:04 +0200166 pos_T save_cursor;
Bram Moolenaarf4d61bc2020-11-14 14:22:28 +0100167 int winid; // window where this state is valid
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200168 viewstate_T init_viewstate;
169 viewstate_T old_viewstate;
Bram Moolenaar23324a02019-10-01 17:39:04 +0200170 pos_T match_start;
171 pos_T match_end;
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200172 int did_incsearch;
173 int incsearch_postponed;
Bram Moolenaard93a7fc2021-01-04 12:42:13 +0100174 optmagic_T magic_overruled_save;
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200175} incsearch_state_T;
176
177 static void
178init_incsearch_state(incsearch_state_T *is_state)
179{
Bram Moolenaarf4d61bc2020-11-14 14:22:28 +0100180 is_state->winid = curwin->w_id;
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200181 is_state->match_start = curwin->w_cursor;
182 is_state->did_incsearch = FALSE;
183 is_state->incsearch_postponed = FALSE;
Bram Moolenaarf4e20992020-12-21 19:59:08 +0100184 is_state->magic_overruled_save = magic_overruled;
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200185 CLEAR_POS(&is_state->match_end);
186 is_state->save_cursor = curwin->w_cursor; // may be restored later
187 is_state->search_start = curwin->w_cursor;
188 save_viewstate(&is_state->init_viewstate);
189 save_viewstate(&is_state->old_viewstate);
190}
191
192/*
193 * First move cursor to end of match, then to the start. This
194 * moves the whole match onto the screen when 'nowrap' is set.
195 */
196 static void
197set_search_match(pos_T *t)
198{
199 t->lnum += search_match_lines;
200 t->col = search_match_endcol;
201 if (t->lnum > curbuf->b_ml.ml_line_count)
202 {
203 t->lnum = curbuf->b_ml.ml_line_count;
204 coladvance((colnr_T)MAXCOL);
205 }
206}
207
208/*
209 * Return TRUE when 'incsearch' highlighting is to be done.
Bram Moolenaarb0acacd2018-08-11 16:40:43 +0200210 * Sets search_first_line and search_last_line to the address range.
Bram Moolenaar198cb662018-09-06 21:44:17 +0200211 * May change the last search pattern.
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200212 */
213 static int
Bram Moolenaar3bd8de42020-09-14 16:37:34 +0200214do_incsearch_highlighting(
215 int firstc,
216 int *search_delim,
217 incsearch_state_T *is_state,
218 int *skiplen,
219 int *patlen)
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200220{
Bram Moolenaar111bbd62018-08-18 21:23:05 +0200221 char_u *cmd;
Bram Moolenaare1004402020-10-24 20:49:43 +0200222 cmdmod_T dummy_cmdmod;
Bram Moolenaar111bbd62018-08-18 21:23:05 +0200223 char_u *p;
224 int delim_optional = FALSE;
225 int delim;
226 char_u *end;
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100227 char *dummy;
Bram Moolenaar111bbd62018-08-18 21:23:05 +0200228 exarg_T ea;
229 pos_T save_cursor;
Bram Moolenaar8b0d5ce2018-08-22 23:05:44 +0200230 int use_last_pat;
Bram Moolenaarc6725252019-11-23 21:56:46 +0100231 int retval = FALSE;
Bram Moolenaard93a7fc2021-01-04 12:42:13 +0100232 magic_T magic = 0;
Bram Moolenaar111bbd62018-08-18 21:23:05 +0200233
Bram Moolenaarb0acacd2018-08-11 16:40:43 +0200234 *skiplen = 0;
235 *patlen = ccline.cmdlen;
236
Bram Moolenaar111bbd62018-08-18 21:23:05 +0200237 if (!p_is || cmd_silent)
238 return FALSE;
239
240 // by default search all lines
241 search_first_line = 0;
242 search_last_line = MAXLNUM;
243
244 if (firstc == '/' || firstc == '?')
Bram Moolenaarc036e872020-02-21 21:30:52 +0100245 {
246 *search_delim = firstc;
Bram Moolenaar111bbd62018-08-18 21:23:05 +0200247 return TRUE;
Bram Moolenaarc036e872020-02-21 21:30:52 +0100248 }
Bram Moolenaar111bbd62018-08-18 21:23:05 +0200249 if (firstc != ':')
250 return FALSE;
251
Bram Moolenaarc6725252019-11-23 21:56:46 +0100252 ++emsg_off;
Bram Moolenaara80faa82020-04-12 19:37:17 +0200253 CLEAR_FIELD(ea);
Bram Moolenaar111bbd62018-08-18 21:23:05 +0200254 ea.line1 = 1;
255 ea.line2 = 1;
256 ea.cmd = ccline.cmdbuff;
257 ea.addr_type = ADDR_LINES;
258
Bram Moolenaare1004402020-10-24 20:49:43 +0200259 parse_command_modifiers(&ea, &dummy, &dummy_cmdmod, TRUE);
Bram Moolenaar111bbd62018-08-18 21:23:05 +0200260
Bram Moolenaar3bd8de42020-09-14 16:37:34 +0200261 cmd = skip_range(ea.cmd, TRUE, NULL);
Bram Moolenaar111bbd62018-08-18 21:23:05 +0200262 if (vim_strchr((char_u *)"sgvl", *cmd) == NULL)
Bram Moolenaarc6725252019-11-23 21:56:46 +0100263 goto theend;
Bram Moolenaar111bbd62018-08-18 21:23:05 +0200264
265 // Skip over "substitute" to find the pattern separator.
266 for (p = cmd; ASCII_ISALPHA(*p); ++p)
267 ;
268 if (*skipwhite(p) == NUL)
Bram Moolenaarc6725252019-11-23 21:56:46 +0100269 goto theend;
Bram Moolenaar111bbd62018-08-18 21:23:05 +0200270
271 if (STRNCMP(cmd, "substitute", p - cmd) == 0
272 || STRNCMP(cmd, "smagic", p - cmd) == 0
273 || STRNCMP(cmd, "snomagic", MAX(p - cmd, 3)) == 0
274 || STRNCMP(cmd, "vglobal", p - cmd) == 0)
Bram Moolenaarb0acacd2018-08-11 16:40:43 +0200275 {
Bram Moolenaar111bbd62018-08-18 21:23:05 +0200276 if (*cmd == 's' && cmd[1] == 'm')
Bram Moolenaard93a7fc2021-01-04 12:42:13 +0100277 magic_overruled = OPTION_MAGIC_ON;
Bram Moolenaar111bbd62018-08-18 21:23:05 +0200278 else if (*cmd == 's' && cmd[1] == 'n')
Bram Moolenaard93a7fc2021-01-04 12:42:13 +0100279 magic_overruled = OPTION_MAGIC_OFF;
Bram Moolenaar111bbd62018-08-18 21:23:05 +0200280 }
281 else if (STRNCMP(cmd, "sort", MAX(p - cmd, 3)) == 0)
282 {
Bram Moolenaar333015a2020-04-25 15:54:16 +0200283 // skip over ! and flags
284 if (*p == '!')
285 p = skipwhite(p + 1);
Bram Moolenaar111bbd62018-08-18 21:23:05 +0200286 while (ASCII_ISALPHA(*(p = skipwhite(p))))
287 ++p;
288 if (*p == NUL)
Bram Moolenaarc6725252019-11-23 21:56:46 +0100289 goto theend;
Bram Moolenaar111bbd62018-08-18 21:23:05 +0200290 }
291 else if (STRNCMP(cmd, "vimgrep", MAX(p - cmd, 3)) == 0
292 || STRNCMP(cmd, "vimgrepadd", MAX(p - cmd, 8)) == 0
293 || STRNCMP(cmd, "lvimgrep", MAX(p - cmd, 2)) == 0
294 || STRNCMP(cmd, "lvimgrepadd", MAX(p - cmd, 9)) == 0
295 || STRNCMP(cmd, "global", p - cmd) == 0)
296 {
297 // skip over "!"
298 if (*p == '!')
Bram Moolenaarb0acacd2018-08-11 16:40:43 +0200299 {
Bram Moolenaar111bbd62018-08-18 21:23:05 +0200300 p++;
301 if (*skipwhite(p) == NUL)
Bram Moolenaarc6725252019-11-23 21:56:46 +0100302 goto theend;
Bram Moolenaar111bbd62018-08-18 21:23:05 +0200303 }
304 if (*cmd != 'g')
305 delim_optional = TRUE;
306 }
307 else
Bram Moolenaarc6725252019-11-23 21:56:46 +0100308 goto theend;
Bram Moolenaarb0acacd2018-08-11 16:40:43 +0200309
Bram Moolenaar111bbd62018-08-18 21:23:05 +0200310 p = skipwhite(p);
311 delim = (delim_optional && vim_isIDc(*p)) ? ' ' : *p++;
Bram Moolenaarc036e872020-02-21 21:30:52 +0100312 *search_delim = delim;
Bram Moolenaard93a7fc2021-01-04 12:42:13 +0100313 end = skip_regexp_ex(p, delim, magic_isset(), NULL, NULL, &magic);
Bram Moolenaar33c4dbb2018-08-14 16:06:16 +0200314
Bram Moolenaar8b0d5ce2018-08-22 23:05:44 +0200315 use_last_pat = end == p && *end == delim;
Bram Moolenaar33c4dbb2018-08-14 16:06:16 +0200316
Bram Moolenaar8b0d5ce2018-08-22 23:05:44 +0200317 if (end == p && !use_last_pat)
Bram Moolenaarc6725252019-11-23 21:56:46 +0100318 goto theend;
Bram Moolenaar8b0d5ce2018-08-22 23:05:44 +0200319
320 // Don't do 'hlsearch' highlighting if the pattern matches everything.
321 if (!use_last_pat)
322 {
323 char c = *end;
324 int empty;
325
326 *end = NUL;
Bram Moolenaard93a7fc2021-01-04 12:42:13 +0100327 empty = empty_pattern_magic(p, STRLEN(p), magic);
Bram Moolenaar8b0d5ce2018-08-22 23:05:44 +0200328 *end = c;
329 if (empty)
Bram Moolenaarc6725252019-11-23 21:56:46 +0100330 goto theend;
Bram Moolenaar8b0d5ce2018-08-22 23:05:44 +0200331 }
332
333 // found a non-empty pattern or //
Bram Moolenaar111bbd62018-08-18 21:23:05 +0200334 *skiplen = (int)(p - ccline.cmdbuff);
335 *patlen = (int)(end - p);
Bram Moolenaar264cf5c2018-08-18 21:05:31 +0200336
Bram Moolenaar111bbd62018-08-18 21:23:05 +0200337 // parse the address range
338 save_cursor = curwin->w_cursor;
339 curwin->w_cursor = is_state->search_start;
Bram Moolenaar50eb16c2018-09-15 15:42:40 +0200340 parse_cmd_address(&ea, &dummy, TRUE);
Bram Moolenaar111bbd62018-08-18 21:23:05 +0200341 if (ea.addr_count > 0)
342 {
343 // Allow for reverse match.
344 if (ea.line2 < ea.line1)
345 {
346 search_first_line = ea.line2;
347 search_last_line = ea.line1;
348 }
349 else
350 {
351 search_first_line = ea.line1;
352 search_last_line = ea.line2;
Bram Moolenaarb0acacd2018-08-11 16:40:43 +0200353 }
354 }
Bram Moolenaar111bbd62018-08-18 21:23:05 +0200355 else if (cmd[0] == 's' && cmd[1] != 'o')
356 {
357 // :s defaults to the current line
358 search_first_line = curwin->w_cursor.lnum;
359 search_last_line = curwin->w_cursor.lnum;
360 }
Bram Moolenaarb0acacd2018-08-11 16:40:43 +0200361
Bram Moolenaar111bbd62018-08-18 21:23:05 +0200362 curwin->w_cursor = save_cursor;
Bram Moolenaarc6725252019-11-23 21:56:46 +0100363 retval = TRUE;
364theend:
365 --emsg_off;
366 return retval;
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200367}
368
Bram Moolenaarc7f08b72018-08-12 17:39:14 +0200369 static void
370finish_incsearch_highlighting(
371 int gotesc,
372 incsearch_state_T *is_state,
373 int call_update_screen)
374{
375 if (is_state->did_incsearch)
376 {
377 is_state->did_incsearch = FALSE;
378 if (gotesc)
379 curwin->w_cursor = is_state->save_cursor;
380 else
381 {
382 if (!EQUAL_POS(is_state->save_cursor, is_state->search_start))
383 {
384 // put the '" mark at the original position
385 curwin->w_cursor = is_state->save_cursor;
386 setpcmark();
387 }
388 curwin->w_cursor = is_state->search_start;
389 }
390 restore_viewstate(&is_state->old_viewstate);
391 highlight_match = FALSE;
Bram Moolenaarf13daa42018-08-31 22:09:54 +0200392
393 // by default search all lines
394 search_first_line = 0;
395 search_last_line = MAXLNUM;
396
Bram Moolenaarf4e20992020-12-21 19:59:08 +0100397 magic_overruled = is_state->magic_overruled_save;
Bram Moolenaarf13daa42018-08-31 22:09:54 +0200398
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100399 validate_cursor(); // needed for TAB
Bram Moolenaara4d158b2022-08-14 14:17:45 +0100400 redraw_all_later(UPD_SOME_VALID);
Bram Moolenaarc7f08b72018-08-12 17:39:14 +0200401 if (call_update_screen)
Bram Moolenaara4d158b2022-08-14 14:17:45 +0100402 update_screen(UPD_SOME_VALID);
Bram Moolenaarc7f08b72018-08-12 17:39:14 +0200403 }
404}
405
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200406/*
407 * Do 'incsearch' highlighting if desired.
408 */
409 static void
410may_do_incsearch_highlighting(
411 int firstc,
412 long count,
413 incsearch_state_T *is_state)
414{
Bram Moolenaarb0acacd2018-08-11 16:40:43 +0200415 int skiplen, patlen;
Bram Moolenaar99f043a2018-09-09 15:54:14 +0200416 int found; // do_search() result
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200417 pos_T end_pos;
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200418#ifdef FEAT_RELTIME
Bram Moolenaar92ea26b2019-10-18 20:53:34 +0200419 searchit_arg_T sia;
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200420#endif
Bram Moolenaarc7f08b72018-08-12 17:39:14 +0200421 int next_char;
422 int use_last_pat;
Bram Moolenaar693f7dc2019-06-21 02:30:38 +0200423 int did_do_incsearch = is_state->did_incsearch;
Bram Moolenaarc036e872020-02-21 21:30:52 +0100424 int search_delim;
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200425
Bram Moolenaar198cb662018-09-06 21:44:17 +0200426 // Parsing range may already set the last search pattern.
Bram Moolenaar01a060d2018-11-30 21:57:55 +0100427 // NOTE: must call restore_last_search_pattern() before returning!
Bram Moolenaar198cb662018-09-06 21:44:17 +0200428 save_last_search_pattern();
429
Bram Moolenaara60053b2020-09-03 16:50:13 +0200430 if (!do_incsearch_highlighting(firstc, &search_delim, is_state,
431 &skiplen, &patlen))
Bram Moolenaarc7f08b72018-08-12 17:39:14 +0200432 {
Bram Moolenaar198cb662018-09-06 21:44:17 +0200433 restore_last_search_pattern();
Bram Moolenaarc7f08b72018-08-12 17:39:14 +0200434 finish_incsearch_highlighting(FALSE, is_state, TRUE);
Bram Moolenaar693f7dc2019-06-21 02:30:38 +0200435 if (did_do_incsearch && vpeekc() == NUL)
436 // may have skipped a redraw, do it now
437 redrawcmd();
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200438 return;
Bram Moolenaarc7f08b72018-08-12 17:39:14 +0200439 }
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200440
441 // If there is a character waiting, search and redraw later.
442 if (char_avail())
443 {
Bram Moolenaar198cb662018-09-06 21:44:17 +0200444 restore_last_search_pattern();
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200445 is_state->incsearch_postponed = TRUE;
446 return;
447 }
448 is_state->incsearch_postponed = FALSE;
449
Bram Moolenaarb0acacd2018-08-11 16:40:43 +0200450 if (search_first_line == 0)
451 // start at the original cursor position
452 curwin->w_cursor = is_state->search_start;
Bram Moolenaar1c299432018-10-28 14:36:09 +0100453 else if (search_first_line > curbuf->b_ml.ml_line_count)
454 {
455 // start after the last line
456 curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
457 curwin->w_cursor.col = MAXCOL;
458 }
Bram Moolenaarb0acacd2018-08-11 16:40:43 +0200459 else
460 {
461 // start at the first line in the range
462 curwin->w_cursor.lnum = search_first_line;
463 curwin->w_cursor.col = 0;
464 }
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200465
Bram Moolenaarc7f08b72018-08-12 17:39:14 +0200466 // Use the previous pattern for ":s//".
467 next_char = ccline.cmdbuff[skiplen + patlen];
468 use_last_pat = patlen == 0 && skiplen > 0
469 && ccline.cmdbuff[skiplen - 1] == next_char;
470
471 // If there is no pattern, don't do anything.
472 if (patlen == 0 && !use_last_pat)
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200473 {
Bram Moolenaar99f043a2018-09-09 15:54:14 +0200474 found = 0;
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200475 set_no_hlsearch(TRUE); // turn off previous highlight
Bram Moolenaara4d158b2022-08-14 14:17:45 +0100476 redraw_all_later(UPD_SOME_VALID);
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200477 }
478 else
479 {
480 int search_flags = SEARCH_OPT + SEARCH_NOOF + SEARCH_PEEK;
481
482 cursor_off(); // so the user knows we're busy
483 out_flush();
484 ++emsg_off; // so it doesn't beep if bad expr
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200485 if (!p_hls)
486 search_flags += SEARCH_KEEP;
Bram Moolenaar976b8472018-08-12 15:49:47 +0200487 if (search_first_line != 0)
488 search_flags += SEARCH_START;
Bram Moolenaarb0acacd2018-08-11 16:40:43 +0200489 ccline.cmdbuff[skiplen + patlen] = NUL;
Bram Moolenaar92ea26b2019-10-18 20:53:34 +0200490#ifdef FEAT_RELTIME
Bram Moolenaara80faa82020-04-12 19:37:17 +0200491 CLEAR_FIELD(sia);
Paul Ollis65745772022-06-05 16:55:54 +0100492 // Set the time limit to half a second.
493 sia.sa_tm = 500;
Bram Moolenaar92ea26b2019-10-18 20:53:34 +0200494#endif
Bram Moolenaarc036e872020-02-21 21:30:52 +0100495 found = do_search(NULL, firstc == ':' ? '/' : firstc, search_delim,
Bram Moolenaarb0acacd2018-08-11 16:40:43 +0200496 ccline.cmdbuff + skiplen, count, search_flags,
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200497#ifdef FEAT_RELTIME
Bram Moolenaar92ea26b2019-10-18 20:53:34 +0200498 &sia
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200499#else
Bram Moolenaar92ea26b2019-10-18 20:53:34 +0200500 NULL
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200501#endif
502 );
Bram Moolenaarc7f08b72018-08-12 17:39:14 +0200503 ccline.cmdbuff[skiplen + patlen] = next_char;
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200504 --emsg_off;
505
Bram Moolenaarb0acacd2018-08-11 16:40:43 +0200506 if (curwin->w_cursor.lnum < search_first_line
507 || curwin->w_cursor.lnum > search_last_line)
Bram Moolenaar2f6a3462018-08-14 18:16:52 +0200508 {
Bram Moolenaarb0acacd2018-08-11 16:40:43 +0200509 // match outside of address range
Bram Moolenaar99f043a2018-09-09 15:54:14 +0200510 found = 0;
Bram Moolenaar2f6a3462018-08-14 18:16:52 +0200511 curwin->w_cursor = is_state->search_start;
512 }
Bram Moolenaarb0acacd2018-08-11 16:40:43 +0200513
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200514 // if interrupted while searching, behave like it failed
515 if (got_int)
516 {
517 (void)vpeekc(); // remove <C-C> from input stream
518 got_int = FALSE; // don't abandon the command line
Bram Moolenaar99f043a2018-09-09 15:54:14 +0200519 found = 0;
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200520 }
521 else if (char_avail())
522 // cancelled searching because a char was typed
523 is_state->incsearch_postponed = TRUE;
524 }
Bram Moolenaar99f043a2018-09-09 15:54:14 +0200525 if (found != 0)
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200526 highlight_match = TRUE; // highlight position
527 else
528 highlight_match = FALSE; // remove highlight
529
530 // First restore the old curwin values, so the screen is positioned in the
531 // same way as the actual search command.
532 restore_viewstate(&is_state->old_viewstate);
533 changed_cline_bef_curs();
534 update_topline();
535
Bram Moolenaar99f043a2018-09-09 15:54:14 +0200536 if (found != 0)
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200537 {
538 pos_T save_pos = curwin->w_cursor;
539
540 is_state->match_start = curwin->w_cursor;
541 set_search_match(&curwin->w_cursor);
542 validate_cursor();
543 end_pos = curwin->w_cursor;
544 is_state->match_end = end_pos;
545 curwin->w_cursor = save_pos;
546 }
547 else
548 end_pos = curwin->w_cursor; // shutup gcc 4
549
Bram Moolenaar4edfe2d2018-08-23 20:55:45 +0200550 // Disable 'hlsearch' highlighting if the pattern matches everything.
551 // Avoids a flash when typing "foo\|".
552 if (!use_last_pat)
553 {
554 next_char = ccline.cmdbuff[skiplen + patlen];
555 ccline.cmdbuff[skiplen + patlen] = NUL;
Bram Moolenaard93a7fc2021-01-04 12:42:13 +0100556 if (empty_pattern(ccline.cmdbuff + skiplen, search_delim)
557 && !no_hlsearch)
Bram Moolenaar65985ac2018-09-16 17:08:04 +0200558 {
Bram Moolenaara4d158b2022-08-14 14:17:45 +0100559 redraw_all_later(UPD_SOME_VALID);
Bram Moolenaar4edfe2d2018-08-23 20:55:45 +0200560 set_no_hlsearch(TRUE);
Bram Moolenaar65985ac2018-09-16 17:08:04 +0200561 }
Bram Moolenaar4edfe2d2018-08-23 20:55:45 +0200562 ccline.cmdbuff[skiplen + patlen] = next_char;
563 }
564
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200565 validate_cursor();
566 // May redraw the status line to show the cursor position.
567 if (p_ru && curwin->w_status_height > 0)
568 curwin->w_redr_status = TRUE;
569
Bram Moolenaara4d158b2022-08-14 14:17:45 +0100570 update_screen(UPD_SOME_VALID);
Bram Moolenaar7ab5d772019-10-26 20:45:24 +0200571 highlight_match = FALSE;
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200572 restore_last_search_pattern();
573
Bram Moolenaar99f043a2018-09-09 15:54:14 +0200574 // Leave it at the end to make CTRL-R CTRL-W work. But not when beyond the
575 // end of the pattern, e.g. for ":s/pat/".
576 if (ccline.cmdbuff[skiplen + patlen] != NUL)
577 curwin->w_cursor = is_state->search_start;
578 else if (found != 0)
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200579 curwin->w_cursor = end_pos;
580
581 msg_starthere();
582 redrawcmdline();
583 is_state->did_incsearch = TRUE;
584}
585
586/*
587 * May adjust 'incsearch' highlighting for typing CTRL-G and CTRL-T, go to next
588 * or previous match.
589 * Returns FAIL when jumping to cmdline_not_changed;
590 */
591 static int
592may_adjust_incsearch_highlighting(
Bram Moolenaarb0acacd2018-08-11 16:40:43 +0200593 int firstc,
594 long count,
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200595 incsearch_state_T *is_state,
Bram Moolenaarb0acacd2018-08-11 16:40:43 +0200596 int c)
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200597{
Bram Moolenaarb0acacd2018-08-11 16:40:43 +0200598 int skiplen, patlen;
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200599 pos_T t;
600 char_u *pat;
601 int search_flags = SEARCH_NOOF;
602 int i;
Bram Moolenaarb0acacd2018-08-11 16:40:43 +0200603 int save;
Bram Moolenaarc036e872020-02-21 21:30:52 +0100604 int search_delim;
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200605
Bram Moolenaar198cb662018-09-06 21:44:17 +0200606 // Parsing range may already set the last search pattern.
Bram Moolenaar01a060d2018-11-30 21:57:55 +0100607 // NOTE: must call restore_last_search_pattern() before returning!
Bram Moolenaar198cb662018-09-06 21:44:17 +0200608 save_last_search_pattern();
609
Bram Moolenaard8d957d2021-10-04 19:47:35 +0100610 if (!do_incsearch_highlighting(firstc, &search_delim, is_state,
611 &skiplen, &patlen))
Bram Moolenaar198cb662018-09-06 21:44:17 +0200612 {
613 restore_last_search_pattern();
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200614 return OK;
Bram Moolenaar198cb662018-09-06 21:44:17 +0200615 }
Bram Moolenaarb0acacd2018-08-11 16:40:43 +0200616 if (patlen == 0 && ccline.cmdbuff[skiplen] == NUL)
Bram Moolenaar198cb662018-09-06 21:44:17 +0200617 {
618 restore_last_search_pattern();
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200619 return FAIL;
Bram Moolenaar198cb662018-09-06 21:44:17 +0200620 }
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200621
Bram Moolenaarc036e872020-02-21 21:30:52 +0100622 if (search_delim == ccline.cmdbuff[skiplen])
Bram Moolenaaref73a282018-08-11 19:02:22 +0200623 {
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200624 pat = last_search_pattern();
Bram Moolenaard8d957d2021-10-04 19:47:35 +0100625 if (pat == NULL)
626 {
627 restore_last_search_pattern();
628 return FAIL;
629 }
Bram Moolenaaref73a282018-08-11 19:02:22 +0200630 skiplen = 0;
Bram Moolenaard7cc1632018-08-14 20:18:26 +0200631 patlen = (int)STRLEN(pat);
Bram Moolenaaref73a282018-08-11 19:02:22 +0200632 }
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200633 else
Bram Moolenaarb0acacd2018-08-11 16:40:43 +0200634 pat = ccline.cmdbuff + skiplen;
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200635
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200636 cursor_off();
637 out_flush();
638 if (c == Ctrl_G)
639 {
640 t = is_state->match_end;
641 if (LT_POS(is_state->match_start, is_state->match_end))
642 // Start searching at the end of the match not at the beginning of
643 // the next column.
644 (void)decl(&t);
645 search_flags += SEARCH_COL;
646 }
647 else
648 t = is_state->match_start;
649 if (!p_hls)
650 search_flags += SEARCH_KEEP;
651 ++emsg_off;
Bram Moolenaarb0acacd2018-08-11 16:40:43 +0200652 save = pat[patlen];
653 pat[patlen] = NUL;
Bram Moolenaar5d24a222018-12-23 19:10:09 +0100654 i = searchit(curwin, curbuf, &t, NULL,
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200655 c == Ctrl_G ? FORWARD : BACKWARD,
Bram Moolenaar92ea26b2019-10-18 20:53:34 +0200656 pat, count, search_flags, RE_SEARCH, NULL);
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200657 --emsg_off;
Bram Moolenaarb0acacd2018-08-11 16:40:43 +0200658 pat[patlen] = save;
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200659 if (i)
660 {
661 is_state->search_start = is_state->match_start;
662 is_state->match_end = t;
663 is_state->match_start = t;
Bram Moolenaarb0acacd2018-08-11 16:40:43 +0200664 if (c == Ctrl_T && firstc != '?')
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200665 {
666 // Move just before the current match, so that when nv_search
667 // finishes the cursor will be put back on the match.
668 is_state->search_start = t;
669 (void)decl(&is_state->search_start);
670 }
671 else if (c == Ctrl_G && firstc == '?')
672 {
673 // Move just after the current match, so that when nv_search
674 // finishes the cursor will be put back on the match.
675 is_state->search_start = t;
676 (void)incl(&is_state->search_start);
677 }
678 if (LT_POS(t, is_state->search_start) && c == Ctrl_G)
679 {
680 // wrap around
681 is_state->search_start = t;
682 if (firstc == '?')
683 (void)incl(&is_state->search_start);
684 else
685 (void)decl(&is_state->search_start);
686 }
687
688 set_search_match(&is_state->match_end);
689 curwin->w_cursor = is_state->match_start;
690 changed_cline_bef_curs();
691 update_topline();
692 validate_cursor();
693 highlight_match = TRUE;
694 save_viewstate(&is_state->old_viewstate);
Bram Moolenaara4d158b2022-08-14 14:17:45 +0100695 update_screen(UPD_NOT_VALID);
Bram Moolenaar7ab5d772019-10-26 20:45:24 +0200696 highlight_match = FALSE;
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200697 redrawcmdline();
Bram Moolenaar69a5b862019-07-16 21:38:51 +0200698 curwin->w_cursor = is_state->match_end;
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200699 }
700 else
701 vim_beep(BO_ERROR);
702 restore_last_search_pattern();
703 return FAIL;
704}
705
706/*
707 * When CTRL-L typed: add character from the match to the pattern.
708 * May set "*c" to the added character.
709 * Return OK when jumping to cmdline_not_changed.
710 */
711 static int
712may_add_char_to_search(int firstc, int *c, incsearch_state_T *is_state)
713{
Bram Moolenaarc036e872020-02-21 21:30:52 +0100714 int skiplen, patlen, search_delim;
Bram Moolenaarb0acacd2018-08-11 16:40:43 +0200715
Bram Moolenaar198cb662018-09-06 21:44:17 +0200716 // Parsing range may already set the last search pattern.
Bram Moolenaar01a060d2018-11-30 21:57:55 +0100717 // NOTE: must call restore_last_search_pattern() before returning!
Bram Moolenaar198cb662018-09-06 21:44:17 +0200718 save_last_search_pattern();
719
Bram Moolenaar9b7cce22020-06-06 15:14:08 +0200720 if (!do_incsearch_highlighting(firstc, &search_delim, is_state,
721 &skiplen, &patlen))
Bram Moolenaar198cb662018-09-06 21:44:17 +0200722 {
723 restore_last_search_pattern();
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200724 return FAIL;
Bram Moolenaar198cb662018-09-06 21:44:17 +0200725 }
Bram Moolenaar01a060d2018-11-30 21:57:55 +0100726 restore_last_search_pattern();
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200727
728 // Add a character from under the cursor for 'incsearch'.
729 if (is_state->did_incsearch)
730 {
731 curwin->w_cursor = is_state->match_end;
Bram Moolenaar730f48f2019-04-11 13:45:57 +0200732 *c = gchar_cursor();
733 if (*c != NUL)
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200734 {
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200735 // If 'ignorecase' and 'smartcase' are set and the
736 // command line has no uppercase characters, convert
737 // the character to lowercase.
Bram Moolenaarb0acacd2018-08-11 16:40:43 +0200738 if (p_ic && p_scs && !pat_has_uppercase(ccline.cmdbuff + skiplen))
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200739 *c = MB_TOLOWER(*c);
Bram Moolenaarc036e872020-02-21 21:30:52 +0100740 if (*c == search_delim || vim_strchr((char_u *)(
Bram Moolenaarf4e20992020-12-21 19:59:08 +0100741 magic_isset() ? "\\~^$.*[" : "\\^$"), *c) != NULL)
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200742 {
Bram Moolenaar730f48f2019-04-11 13:45:57 +0200743 // put a backslash before special characters
744 stuffcharReadbuff(*c);
745 *c = '\\';
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200746 }
Bram Moolenaar730f48f2019-04-11 13:45:57 +0200747 // add any composing characters
748 if (mb_char2len(*c) != mb_ptr2len(ml_get_cursor()))
749 {
750 int save_c = *c;
751
752 while (mb_char2len(*c) != mb_ptr2len(ml_get_cursor()))
753 {
754 curwin->w_cursor.col += mb_char2len(*c);
755 *c = gchar_cursor();
756 stuffcharReadbuff(*c);
757 }
758 *c = save_c;
759 }
760 return FAIL;
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +0200761 }
762 }
763 return OK;
764}
Bram Moolenaar9b25af32018-04-28 13:56:09 +0200765#endif
766
Bram Moolenaar693f7dc2019-06-21 02:30:38 +0200767#ifdef FEAT_ARABIC
768/*
769 * Return TRUE if the command line has an Arabic character at or after "start"
770 * for "len" bytes.
771 */
772 static int
773cmdline_has_arabic(int start, int len)
774{
775 int j;
776 int mb_l;
777 int u8c;
778 char_u *p;
779 int u8cc[MAX_MCO];
780
781 if (!enc_utf8)
782 return FALSE;
783
784 for (j = start; j < start + len; j += mb_l)
785 {
786 p = ccline.cmdbuff + j;
787 u8c = utfc_ptr2char_len(p, u8cc, start + len - j);
788 mb_l = utfc_ptr2len_len(p, start + len - j);
789 if (ARABIC_CHAR(u8c))
790 return TRUE;
791 }
792 return FALSE;
793}
794#endif
795
Bram Moolenaard3dc0622018-09-30 17:45:30 +0200796 void
797cmdline_init(void)
798{
Bram Moolenaara80faa82020-04-12 19:37:17 +0200799 CLEAR_FIELD(ccline);
Bram Moolenaard3dc0622018-09-30 17:45:30 +0200800}
801
Bram Moolenaar66216052017-12-16 16:33:44 +0100802/*
Bram Moolenaar9c929712020-09-07 22:05:28 +0200803 * Handle the backslash key pressed in the command-line mode. CTRL-\ CTRL-N
804 * goes to Normal mode, CTRL-\ CTRL-G goes to Insert mode when 'insertmode' is
805 * set, CTRL-\ e prompts for an expression.
806 */
807 static int
808cmdline_handle_backslash_key(int c, int *gotesc)
809{
810 ++no_mapping;
811 ++allow_keys;
812 c = plain_vgetc();
813 --no_mapping;
814 --allow_keys;
815
816 // CTRL-\ e doesn't work when obtaining an expression, unless it
817 // is in a mapping.
818 if (c != Ctrl_N && c != Ctrl_G && (c != 'e'
819 || (ccline.cmdfirstc == '=' && KeyTyped)
820#ifdef FEAT_EVAL
821 || cmdline_star > 0
822#endif
823 ))
824 {
825 vungetc(c);
826 return PROCESS_NEXT_KEY;
827 }
828
829#ifdef FEAT_EVAL
830 if (c == 'e')
831 {
832 char_u *p = NULL;
833 int len;
834
835 /*
836 * Replace the command line with the result of an expression.
837 * Need to save and restore the current command line, to be
838 * able to enter a new one...
839 */
840 if (ccline.cmdpos == ccline.cmdlen)
841 new_cmdpos = 99999; // keep it at the end
842 else
843 new_cmdpos = ccline.cmdpos;
844
845 c = get_expr_register();
846 if (c == '=')
847 {
zeertzjqcfe45652022-05-27 17:26:55 +0100848 // Need to save and restore ccline. And set "textlock"
Bram Moolenaar9c929712020-09-07 22:05:28 +0200849 // to avoid nasty things like going to another buffer when
850 // evaluating an expression.
zeertzjqcfe45652022-05-27 17:26:55 +0100851 ++textlock;
Bram Moolenaar9c929712020-09-07 22:05:28 +0200852 p = get_expr_line();
zeertzjqcfe45652022-05-27 17:26:55 +0100853 --textlock;
Bram Moolenaar9c929712020-09-07 22:05:28 +0200854
855 if (p != NULL)
856 {
857 len = (int)STRLEN(p);
858 if (realloc_cmdbuff(len + 1) == OK)
859 {
860 ccline.cmdlen = len;
861 STRCPY(ccline.cmdbuff, p);
862 vim_free(p);
863
864 // Restore the cursor or use the position set with
865 // set_cmdline_pos().
866 if (new_cmdpos > ccline.cmdlen)
867 ccline.cmdpos = ccline.cmdlen;
868 else
869 ccline.cmdpos = new_cmdpos;
870
871 KeyTyped = FALSE; // Don't do p_wc completion.
872 redrawcmd();
873 return CMDLINE_CHANGED;
874 }
875 vim_free(p);
876 }
877 }
878 beep_flush();
879 got_int = FALSE; // don't abandon the command line
880 did_emsg = FALSE;
881 emsg_on_display = FALSE;
882 redrawcmd();
883 return CMDLINE_NOT_CHANGED;
884 }
885#endif
886
887 if (c == Ctrl_G && p_im && restart_edit == 0)
888 restart_edit = 'a';
889 *gotesc = TRUE; // will free ccline.cmdbuff after putting it
890 // in history
891 return GOTO_NORMAL_MODE;
892}
893
894/*
895 * Completion for 'wildchar' or 'wildcharm' key.
896 * - hitting <ESC> twice means: abandon command line.
897 * - wildcard expansion is only done when the 'wildchar' key is really
898 * typed, not when it comes from a macro
899 * Returns CMDLINE_CHANGED if command line is changed or CMDLINE_NOT_CHANGED.
900 */
901 static int
902cmdline_wildchar_complete(
903 int c,
904 int escape,
905 int *did_wild_list,
906 int *wim_index_p,
907 expand_T *xp,
908 int *gotesc)
909{
910 int wim_index = *wim_index_p;
911 int res;
912 int j;
913 int options = WILD_NO_BEEP;
914
915 if (wim_flags[wim_index] & WIM_BUFLASTUSED)
916 options |= WILD_BUFLASTUSED;
917 if (xp->xp_numfiles > 0) // typed p_wc at least twice
918 {
919 // if 'wildmode' contains "list" may still need to list
920 if (xp->xp_numfiles > 1
921 && !*did_wild_list
Yegappan Lakshmanan3908ef52022-02-08 12:08:07 +0000922 && ((wim_flags[wim_index] & WIM_LIST)
Bram Moolenaar54162322022-08-26 16:58:51 +0100923 || (p_wmnu && (wim_flags[wim_index] & WIM_FULL) != 0)))
Bram Moolenaar9c929712020-09-07 22:05:28 +0200924 {
Yegappan Lakshmanan3908ef52022-02-08 12:08:07 +0000925 (void)showmatches(xp,
926 p_wmnu && ((wim_flags[wim_index] & WIM_LIST) == 0));
Bram Moolenaar9c929712020-09-07 22:05:28 +0200927 redrawcmd();
928 *did_wild_list = TRUE;
929 }
930 if (wim_flags[wim_index] & WIM_LONGEST)
931 res = nextwild(xp, WILD_LONGEST, options, escape);
932 else if (wim_flags[wim_index] & WIM_FULL)
933 res = nextwild(xp, WILD_NEXT, options, escape);
934 else
935 res = OK; // don't insert 'wildchar' now
936 }
937 else // typed p_wc first time
938 {
939 wim_index = 0;
940 j = ccline.cmdpos;
941 // if 'wildmode' first contains "longest", get longest
942 // common part
943 if (wim_flags[0] & WIM_LONGEST)
944 res = nextwild(xp, WILD_LONGEST, options, escape);
945 else
946 res = nextwild(xp, WILD_EXPAND_KEEP, options, escape);
947
948 // if interrupted while completing, behave like it failed
949 if (got_int)
950 {
951 (void)vpeekc(); // remove <C-C> from input stream
952 got_int = FALSE; // don't abandon the command line
953 (void)ExpandOne(xp, NULL, NULL, 0, WILD_FREE);
Bram Moolenaar9c929712020-09-07 22:05:28 +0200954 xp->xp_context = EXPAND_NOTHING;
Bram Moolenaar9c929712020-09-07 22:05:28 +0200955 *wim_index_p = wim_index;
956 return CMDLINE_CHANGED;
957 }
958
959 // when more than one match, and 'wildmode' first contains
960 // "list", or no change and 'wildmode' contains "longest,list",
961 // list all matches
962 if (res == OK && xp->xp_numfiles > 1)
963 {
964 // a "longest" that didn't do anything is skipped (but not
965 // "list:longest")
966 if (wim_flags[0] == WIM_LONGEST && ccline.cmdpos == j)
967 wim_index = 1;
968 if ((wim_flags[wim_index] & WIM_LIST)
Bram Moolenaar54162322022-08-26 16:58:51 +0100969 || (p_wmnu && (wim_flags[wim_index] & WIM_FULL) != 0))
Bram Moolenaar9c929712020-09-07 22:05:28 +0200970 {
971 if (!(wim_flags[0] & WIM_LONGEST))
972 {
Bram Moolenaar9c929712020-09-07 22:05:28 +0200973 int p_wmnu_save = p_wmnu;
Bram Moolenaar54162322022-08-26 16:58:51 +0100974
Bram Moolenaar9c929712020-09-07 22:05:28 +0200975 p_wmnu = 0;
Bram Moolenaar54162322022-08-26 16:58:51 +0100976
Bram Moolenaar9c929712020-09-07 22:05:28 +0200977 // remove match
978 nextwild(xp, WILD_PREV, 0, escape);
Bram Moolenaar9c929712020-09-07 22:05:28 +0200979 p_wmnu = p_wmnu_save;
Bram Moolenaar9c929712020-09-07 22:05:28 +0200980 }
Bram Moolenaar9c929712020-09-07 22:05:28 +0200981 (void)showmatches(xp, p_wmnu
982 && ((wim_flags[wim_index] & WIM_LIST) == 0));
Bram Moolenaar9c929712020-09-07 22:05:28 +0200983 redrawcmd();
984 *did_wild_list = TRUE;
985 if (wim_flags[wim_index] & WIM_LONGEST)
986 nextwild(xp, WILD_LONGEST, options, escape);
987 else if (wim_flags[wim_index] & WIM_FULL)
988 nextwild(xp, WILD_NEXT, options, escape);
989 }
990 else
991 vim_beep(BO_WILD);
992 }
Bram Moolenaar9c929712020-09-07 22:05:28 +0200993 else if (xp->xp_numfiles == -1)
994 xp->xp_context = EXPAND_NOTHING;
Bram Moolenaar9c929712020-09-07 22:05:28 +0200995 }
996 if (wim_index < 3)
997 ++wim_index;
998 if (c == ESC)
999 *gotesc = TRUE;
1000
1001 *wim_index_p = wim_index;
1002 return (res == OK) ? CMDLINE_CHANGED : CMDLINE_NOT_CHANGED;
1003}
1004
1005/*
Bram Moolenaar2f3cd2e2020-09-06 15:54:00 +02001006 * Handle backspace, delete and CTRL-W keys in the command-line mode.
1007 * Returns:
1008 * CMDLINE_NOT_CHANGED - if the command line is not changed
1009 * CMDLINE_CHANGED - if the command line is changed
1010 * GOTO_NORMAL_MODE - go back to normal mode
1011 */
1012 static int
1013cmdline_erase_chars(
1014 int c,
1015 int indent
1016#ifdef FEAT_SEARCH_EXTRA
1017 , incsearch_state_T *isp
1018#endif
1019 )
1020{
1021 int i;
1022 int j;
1023
1024 if (c == K_KDEL)
1025 c = K_DEL;
1026
1027 /*
1028 * Delete current character is the same as backspace on next
1029 * character, except at end of line.
1030 */
1031 if (c == K_DEL && ccline.cmdpos != ccline.cmdlen)
1032 ++ccline.cmdpos;
1033 if (has_mbyte && c == K_DEL)
1034 ccline.cmdpos += mb_off_next(ccline.cmdbuff,
1035 ccline.cmdbuff + ccline.cmdpos);
1036 if (ccline.cmdpos > 0)
1037 {
1038 char_u *p;
1039
1040 j = ccline.cmdpos;
1041 p = ccline.cmdbuff + j;
1042 if (has_mbyte)
1043 {
1044 p = mb_prevptr(ccline.cmdbuff, p);
1045 if (c == Ctrl_W)
1046 {
1047 while (p > ccline.cmdbuff && vim_isspace(*p))
1048 p = mb_prevptr(ccline.cmdbuff, p);
1049 i = mb_get_class(p);
1050 while (p > ccline.cmdbuff && mb_get_class(p) == i)
1051 p = mb_prevptr(ccline.cmdbuff, p);
1052 if (mb_get_class(p) != i)
1053 p += (*mb_ptr2len)(p);
1054 }
1055 }
1056 else if (c == Ctrl_W)
1057 {
1058 while (p > ccline.cmdbuff && vim_isspace(p[-1]))
1059 --p;
Bram Moolenaaref02f162022-05-07 10:49:10 +01001060 if (p > ccline.cmdbuff)
1061 {
1062 i = vim_iswordc(p[-1]);
1063 while (p > ccline.cmdbuff && !vim_isspace(p[-1])
1064 && vim_iswordc(p[-1]) == i)
1065 --p;
1066 }
Bram Moolenaar2f3cd2e2020-09-06 15:54:00 +02001067 }
1068 else
1069 --p;
1070 ccline.cmdpos = (int)(p - ccline.cmdbuff);
1071 ccline.cmdlen -= j - ccline.cmdpos;
1072 i = ccline.cmdpos;
1073 while (i < ccline.cmdlen)
1074 ccline.cmdbuff[i++] = ccline.cmdbuff[j++];
1075
1076 // Truncate at the end, required for multi-byte chars.
1077 ccline.cmdbuff[ccline.cmdlen] = NUL;
1078#ifdef FEAT_SEARCH_EXTRA
1079 if (ccline.cmdlen == 0)
1080 {
1081 isp->search_start = isp->save_cursor;
1082 // save view settings, so that the screen
1083 // won't be restored at the wrong position
1084 isp->old_viewstate = isp->init_viewstate;
1085 }
1086#endif
1087 redrawcmd();
1088 }
1089 else if (ccline.cmdlen == 0 && c != Ctrl_W
1090 && ccline.cmdprompt == NULL && indent == 0)
1091 {
1092 // In ex and debug mode it doesn't make sense to return.
1093 if (exmode_active
1094#ifdef FEAT_EVAL
1095 || ccline.cmdfirstc == '>'
1096#endif
1097 )
1098 return CMDLINE_NOT_CHANGED;
1099
1100 VIM_CLEAR(ccline.cmdbuff); // no commandline to return
1101 if (!cmd_silent)
1102 {
1103#ifdef FEAT_RIGHTLEFT
1104 if (cmdmsg_rl)
1105 msg_col = Columns;
1106 else
1107#endif
1108 msg_col = 0;
1109 msg_putchar(' '); // delete ':'
1110 }
1111#ifdef FEAT_SEARCH_EXTRA
1112 if (ccline.cmdlen == 0)
1113 isp->search_start = isp->save_cursor;
1114#endif
1115 redraw_cmdline = TRUE;
1116 return GOTO_NORMAL_MODE;
1117 }
1118 return CMDLINE_CHANGED;
1119}
1120
1121/*
1122 * Handle the CTRL-^ key in the command-line mode and toggle the use of the
1123 * language :lmap mappings and/or Input Method.
1124 */
1125 static void
1126cmdline_toggle_langmap(long *b_im_ptr)
1127{
Bram Moolenaar24959102022-05-07 20:01:16 +01001128 if (map_to_exists_mode((char_u *)"", MODE_LANGMAP, FALSE))
Bram Moolenaar2f3cd2e2020-09-06 15:54:00 +02001129 {
1130 // ":lmap" mappings exists, toggle use of mappings.
Bram Moolenaar24959102022-05-07 20:01:16 +01001131 State ^= MODE_LANGMAP;
Bram Moolenaar2f3cd2e2020-09-06 15:54:00 +02001132#ifdef HAVE_INPUT_METHOD
1133 im_set_active(FALSE); // Disable input method
1134#endif
1135 if (b_im_ptr != NULL)
1136 {
Bram Moolenaar24959102022-05-07 20:01:16 +01001137 if (State & MODE_LANGMAP)
Bram Moolenaar2f3cd2e2020-09-06 15:54:00 +02001138 *b_im_ptr = B_IMODE_LMAP;
1139 else
1140 *b_im_ptr = B_IMODE_NONE;
1141 }
1142 }
1143#ifdef HAVE_INPUT_METHOD
1144 else
1145 {
1146 // There are no ":lmap" mappings, toggle IM. When
1147 // 'imdisable' is set don't try getting the status, it's
1148 // always off.
1149 if ((p_imdisable && b_im_ptr != NULL)
1150 ? *b_im_ptr == B_IMODE_IM : im_get_status())
1151 {
1152 im_set_active(FALSE); // Disable input method
1153 if (b_im_ptr != NULL)
1154 *b_im_ptr = B_IMODE_NONE;
1155 }
1156 else
1157 {
1158 im_set_active(TRUE); // Enable input method
1159 if (b_im_ptr != NULL)
1160 *b_im_ptr = B_IMODE_IM;
1161 }
1162 }
1163#endif
1164 if (b_im_ptr != NULL)
1165 {
1166 if (b_im_ptr == &curbuf->b_p_iminsert)
1167 set_iminsert_global();
1168 else
1169 set_imsearch_global();
1170 }
1171#ifdef CURSOR_SHAPE
1172 ui_cursor_shape(); // may show different cursor shape
1173#endif
1174#if defined(FEAT_KEYMAP)
1175 // Show/unshow value of 'keymap' in status lines later.
1176 status_redraw_curbuf();
1177#endif
1178}
1179
1180/*
1181 * Handle the CTRL-R key in the command-line mode and insert the contents of a
1182 * numbered or named register.
1183 */
1184 static int
1185cmdline_insert_reg(int *gotesc UNUSED)
1186{
1187 int i;
1188 int c;
Bram Moolenaar6689df02022-06-22 18:14:29 +01001189#ifdef FEAT_EVAL
Bram Moolenaar6046ade2022-06-22 13:51:54 +01001190 int save_new_cmdpos = new_cmdpos;
Bram Moolenaar6689df02022-06-22 18:14:29 +01001191#endif
Bram Moolenaar2f3cd2e2020-09-06 15:54:00 +02001192
1193#ifdef USE_ON_FLY_SCROLL
1194 dont_scroll = TRUE; // disallow scrolling here
1195#endif
1196 putcmdline('"', TRUE);
1197 ++no_mapping;
1198 ++allow_keys;
1199 i = c = plain_vgetc(); // CTRL-R <char>
1200 if (i == Ctrl_O)
1201 i = Ctrl_R; // CTRL-R CTRL-O == CTRL-R CTRL-R
1202 if (i == Ctrl_R)
1203 c = plain_vgetc(); // CTRL-R CTRL-R <char>
1204 extra_char = NUL;
1205 --no_mapping;
1206 --allow_keys;
1207#ifdef FEAT_EVAL
1208 /*
1209 * Insert the result of an expression.
Bram Moolenaar2f3cd2e2020-09-06 15:54:00 +02001210 */
1211 new_cmdpos = -1;
1212 if (c == '=')
1213 {
1214 if (ccline.cmdfirstc == '=' // can't do this recursively
1215 || cmdline_star > 0) // or when typing a password
1216 {
1217 beep_flush();
1218 c = ESC;
1219 }
1220 else
1221 c = get_expr_register();
1222 }
1223#endif
1224 if (c != ESC) // use ESC to cancel inserting register
1225 {
1226 cmdline_paste(c, i == Ctrl_R, FALSE);
1227
1228#ifdef FEAT_EVAL
1229 // When there was a serious error abort getting the
1230 // command line.
1231 if (aborting())
1232 {
1233 *gotesc = TRUE; // will free ccline.cmdbuff after
1234 // putting it in history
1235 return GOTO_NORMAL_MODE;
1236 }
1237#endif
1238 KeyTyped = FALSE; // Don't do p_wc completion.
1239#ifdef FEAT_EVAL
1240 if (new_cmdpos >= 0)
1241 {
1242 // set_cmdline_pos() was used
1243 if (new_cmdpos > ccline.cmdlen)
1244 ccline.cmdpos = ccline.cmdlen;
1245 else
1246 ccline.cmdpos = new_cmdpos;
1247 }
1248#endif
1249 }
Bram Moolenaar6689df02022-06-22 18:14:29 +01001250#ifdef FEAT_EVAL
Bram Moolenaar6046ade2022-06-22 13:51:54 +01001251 new_cmdpos = save_new_cmdpos;
Bram Moolenaar6689df02022-06-22 18:14:29 +01001252#endif
Bram Moolenaar6046ade2022-06-22 13:51:54 +01001253
Bram Moolenaar796139a2021-05-18 21:38:45 +02001254 // remove the double quote
Bram Moolenaar2f3cd2e2020-09-06 15:54:00 +02001255 redrawcmd();
Bram Moolenaar796139a2021-05-18 21:38:45 +02001256
1257 // The text has been stuffed, the command line didn't change yet.
1258 return CMDLINE_NOT_CHANGED;
Bram Moolenaar2f3cd2e2020-09-06 15:54:00 +02001259}
1260
1261/*
1262 * Handle the Left and Right mouse clicks in the command-line mode.
1263 */
1264 static void
1265cmdline_left_right_mouse(int c, int *ignore_drag_release)
1266{
1267 if (c == K_LEFTRELEASE || c == K_RIGHTRELEASE)
1268 *ignore_drag_release = TRUE;
1269 else
1270 *ignore_drag_release = FALSE;
1271# ifdef FEAT_GUI
1272 // When GUI is active, also move when 'mouse' is empty
1273 if (!gui.in_use)
1274# endif
1275 if (!mouse_has(MOUSE_COMMAND))
1276 return;
1277# ifdef FEAT_CLIPBOARD
1278 if (mouse_row < cmdline_row && clip_star.available)
1279 {
1280 int button, is_click, is_drag;
1281
1282 /*
1283 * Handle modeless selection.
1284 */
1285 button = get_mouse_button(KEY2TERMCAP1(c),
1286 &is_click, &is_drag);
1287 if (mouse_model_popup() && button == MOUSE_LEFT
1288 && (mod_mask & MOD_MASK_SHIFT))
1289 {
1290 // Translate shift-left to right button.
1291 button = MOUSE_RIGHT;
1292 mod_mask &= ~MOD_MASK_SHIFT;
1293 }
1294 clip_modeless(button, is_click, is_drag);
1295 return;
1296 }
1297# endif
1298
1299 set_cmdspos();
1300 for (ccline.cmdpos = 0; ccline.cmdpos < ccline.cmdlen;
1301 ++ccline.cmdpos)
1302 {
1303 int i;
1304
1305 i = cmdline_charsize(ccline.cmdpos);
1306 if (mouse_row <= cmdline_row + ccline.cmdspos / Columns
1307 && mouse_col < ccline.cmdspos % Columns + i)
1308 break;
1309 if (has_mbyte)
1310 {
1311 // Count ">" for double-wide char that doesn't fit.
1312 correct_cmdspos(ccline.cmdpos, i);
1313 ccline.cmdpos += (*mb_ptr2len)(ccline.cmdbuff
1314 + ccline.cmdpos) - 1;
1315 }
1316 ccline.cmdspos += i;
1317 }
1318}
1319
1320/*
1321 * Handle the Up, Down, Page Up, Page down, CTRL-N and CTRL-P key in the
1322 * command-line mode. The pressed key is in 'c'.
1323 * Returns:
1324 * CMDLINE_NOT_CHANGED - if the command line is not changed
1325 * CMDLINE_CHANGED - if the command line is changed
1326 * GOTO_NORMAL_MODE - go back to normal mode
1327 */
1328 static int
1329cmdline_browse_history(
1330 int c,
1331 int firstc,
1332 char_u **curcmdstr,
1333 int histype,
1334 int *hiscnt_p,
1335 expand_T *xp)
1336{
1337 int i;
1338 int j;
1339 char_u *lookfor = *curcmdstr;
1340 int hiscnt = *hiscnt_p;
1341 int res;
1342
1343 if (get_hislen() == 0 || firstc == NUL) // no history
1344 return CMDLINE_NOT_CHANGED;
1345
1346 i = hiscnt;
1347
1348 // save current command string so it can be restored later
1349 if (lookfor == NULL)
1350 {
1351 if ((lookfor = vim_strsave(ccline.cmdbuff)) == NULL)
1352 return CMDLINE_NOT_CHANGED;
1353 lookfor[ccline.cmdpos] = NUL;
1354 }
1355
1356 j = (int)STRLEN(lookfor);
1357 for (;;)
1358 {
1359 // one step backwards
1360 if (c == K_UP|| c == K_S_UP || c == Ctrl_P
1361 || c == K_PAGEUP || c == K_KPAGEUP)
1362 {
1363 if (hiscnt == get_hislen()) // first time
1364 hiscnt = *get_hisidx(histype);
1365 else if (hiscnt == 0 && *get_hisidx(histype)
1366 != get_hislen() - 1)
1367 hiscnt = get_hislen() - 1;
1368 else if (hiscnt != *get_hisidx(histype) + 1)
1369 --hiscnt;
1370 else // at top of list
1371 {
1372 hiscnt = i;
1373 break;
1374 }
1375 }
1376 else // one step forwards
1377 {
1378 // on last entry, clear the line
1379 if (hiscnt == *get_hisidx(histype))
1380 {
1381 hiscnt = get_hislen();
1382 break;
1383 }
1384
1385 // not on a history line, nothing to do
1386 if (hiscnt == get_hislen())
1387 break;
1388 if (hiscnt == get_hislen() - 1) // wrap around
1389 hiscnt = 0;
1390 else
1391 ++hiscnt;
1392 }
1393 if (hiscnt < 0 || get_histentry(histype)[hiscnt].hisstr
1394 == NULL)
1395 {
1396 hiscnt = i;
1397 break;
1398 }
1399 if ((c != K_UP && c != K_DOWN)
1400 || hiscnt == i
1401 || STRNCMP(get_histentry(histype)[hiscnt].hisstr,
1402 lookfor, (size_t)j) == 0)
1403 break;
1404 }
1405
1406 if (hiscnt != i) // jumped to other entry
1407 {
1408 char_u *p;
1409 int len;
1410 int old_firstc;
1411
1412 VIM_CLEAR(ccline.cmdbuff);
1413 xp->xp_context = EXPAND_NOTHING;
1414 if (hiscnt == get_hislen())
1415 p = lookfor; // back to the old one
1416 else
1417 p = get_histentry(histype)[hiscnt].hisstr;
1418
1419 if (histype == HIST_SEARCH
1420 && p != lookfor
1421 && (old_firstc = p[STRLEN(p) + 1]) != firstc)
1422 {
1423 // Correct for the separator character used when
1424 // adding the history entry vs the one used now.
1425 // First loop: count length.
1426 // Second loop: copy the characters.
1427 for (i = 0; i <= 1; ++i)
1428 {
1429 len = 0;
1430 for (j = 0; p[j] != NUL; ++j)
1431 {
1432 // Replace old sep with new sep, unless it is
1433 // escaped.
1434 if (p[j] == old_firstc
1435 && (j == 0 || p[j - 1] != '\\'))
1436 {
1437 if (i > 0)
1438 ccline.cmdbuff[len] = firstc;
1439 }
1440 else
1441 {
1442 // Escape new sep, unless it is already
1443 // escaped.
1444 if (p[j] == firstc
1445 && (j == 0 || p[j - 1] != '\\'))
1446 {
1447 if (i > 0)
1448 ccline.cmdbuff[len] = '\\';
1449 ++len;
1450 }
1451 if (i > 0)
1452 ccline.cmdbuff[len] = p[j];
1453 }
1454 ++len;
1455 }
1456 if (i == 0)
1457 {
1458 alloc_cmdbuff(len);
1459 if (ccline.cmdbuff == NULL)
1460 {
1461 res = GOTO_NORMAL_MODE;
1462 goto done;
1463 }
1464 }
1465 }
1466 ccline.cmdbuff[len] = NUL;
1467 }
1468 else
1469 {
1470 alloc_cmdbuff((int)STRLEN(p));
1471 if (ccline.cmdbuff == NULL)
1472 {
1473 res = GOTO_NORMAL_MODE;
1474 goto done;
1475 }
1476 STRCPY(ccline.cmdbuff, p);
1477 }
1478
1479 ccline.cmdpos = ccline.cmdlen = (int)STRLEN(ccline.cmdbuff);
1480 redrawcmd();
1481 res = CMDLINE_CHANGED;
1482 goto done;
1483 }
1484 beep_flush();
1485 res = CMDLINE_NOT_CHANGED;
1486
1487done:
1488 *curcmdstr = lookfor;
1489 *hiscnt_p = hiscnt;
1490 return res;
1491}
1492
1493/*
Bram Moolenaar9c929712020-09-07 22:05:28 +02001494 * Initialize the current command-line info.
1495 */
1496 static int
1497init_ccline(int firstc, int indent)
1498{
1499 ccline.overstrike = FALSE; // always start in insert mode
1500
1501 /*
1502 * set some variables for redrawcmd()
1503 */
1504 ccline.cmdfirstc = (firstc == '@' ? 0 : firstc);
1505 ccline.cmdindent = (firstc > 0 ? indent : 0);
1506
1507 // alloc initial ccline.cmdbuff
Bram Moolenaar85b67472022-01-25 11:55:02 +00001508 alloc_cmdbuff(indent + 50);
Bram Moolenaar9c929712020-09-07 22:05:28 +02001509 if (ccline.cmdbuff == NULL)
1510 return FAIL;
1511 ccline.cmdlen = ccline.cmdpos = 0;
1512 ccline.cmdbuff[0] = NUL;
1513 sb_text_start_cmdline();
1514
1515 // autoindent for :insert and :append
1516 if (firstc <= 0)
1517 {
1518 vim_memset(ccline.cmdbuff, ' ', indent);
1519 ccline.cmdbuff[indent] = NUL;
1520 ccline.cmdpos = indent;
1521 ccline.cmdspos = indent;
1522 ccline.cmdlen = indent;
1523 }
1524
1525 return OK;
1526}
1527
1528/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00001529 * getcmdline() - accept a command line starting with firstc.
1530 *
1531 * firstc == ':' get ":" command line.
1532 * firstc == '/' or '?' get search pattern
1533 * firstc == '=' get expression
1534 * firstc == '@' get text for input() function
1535 * firstc == '>' get text for debug mode
1536 * firstc == NUL get text for :insert command
1537 * firstc == -1 like NUL, and break on CTRL-C
1538 *
1539 * The line is collected in ccline.cmdbuff, which is reallocated to fit the
1540 * command line.
1541 *
1542 * Careful: getcmdline() can be called recursively!
1543 *
1544 * Return pointer to allocated string if there is a commandline, NULL
1545 * otherwise.
1546 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001547 char_u *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01001548getcmdline(
Bram Moolenaarc97f9a52021-12-28 20:59:56 +00001549 int firstc,
1550 long count, // only used for incremental search
1551 int indent, // indent for inside conditionals
1552 getline_opt_T do_concat UNUSED)
Bram Moolenaar438d1762018-09-30 17:11:48 +02001553{
1554 return getcmdline_int(firstc, count, indent, TRUE);
1555}
1556
1557 static char_u *
1558getcmdline_int(
1559 int firstc,
1560 long count UNUSED, // only used for incremental search
1561 int indent, // indent for inside conditionals
Bram Moolenaar9c929712020-09-07 22:05:28 +02001562 int clear_ccline) // clear ccline first
Bram Moolenaar071d4272004-06-13 20:20:40 +00001563{
Bram Moolenaar51f0bfb2022-05-17 20:11:02 +01001564 static int depth = 0; // call depth
Bram Moolenaar071d4272004-06-13 20:20:40 +00001565 int c;
1566 int i;
1567 int j;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001568 int gotesc = FALSE; // TRUE when <ESC> just typed
1569 int do_abbr; // when TRUE check for abbr.
1570 char_u *lookfor = NULL; // string to match
1571 int hiscnt; // current history line in use
1572 int histype; // history type to be used
Bram Moolenaar071d4272004-06-13 20:20:40 +00001573#ifdef FEAT_SEARCH_EXTRA
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +02001574 incsearch_state_T is_state;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001575#endif
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001576 int did_wild_list = FALSE; // did wild_list() recently
1577 int wim_index = 0; // index in wim_flags[]
Bram Moolenaar071d4272004-06-13 20:20:40 +00001578 int res;
1579 int save_msg_scroll = msg_scroll;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001580 int save_State = State; // remember State when called
1581 int some_key_typed = FALSE; // one of the keys was typed
1582 // mouse drag and release events are ignored, unless they are
1583 // preceded with a mouse down event
Bram Moolenaar071d4272004-06-13 20:20:40 +00001584 int ignore_drag_release = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001585#ifdef FEAT_EVAL
1586 int break_ctrl_c = FALSE;
1587#endif
1588 expand_T xpc;
1589 long *b_im_ptr = NULL;
Bram Moolenaar66b51422019-08-18 21:44:12 +02001590 cmdline_info_T save_ccline;
Bram Moolenaar438d1762018-09-30 17:11:48 +02001591 int did_save_ccline = FALSE;
Bram Moolenaarfafcf0d2017-10-19 18:35:51 +02001592 int cmdline_type;
Yegappan Lakshmanan155b0882022-03-17 13:03:09 +00001593 int wild_type;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001594
Bram Moolenaar51f0bfb2022-05-17 20:11:02 +01001595 // one recursion level deeper
1596 ++depth;
1597
Bram Moolenaar438d1762018-09-30 17:11:48 +02001598 if (ccline.cmdbuff != NULL)
1599 {
1600 // Being called recursively. Since ccline is global, we need to save
1601 // the current buffer and restore it when returning.
1602 save_cmdline(&save_ccline);
1603 did_save_ccline = TRUE;
1604 }
Bram Moolenaar9c929712020-09-07 22:05:28 +02001605 if (clear_ccline)
Bram Moolenaara80faa82020-04-12 19:37:17 +02001606 CLEAR_FIELD(ccline);
Bram Moolenaar438d1762018-09-30 17:11:48 +02001607
Bram Moolenaar071d4272004-06-13 20:20:40 +00001608#ifdef FEAT_EVAL
1609 if (firstc == -1)
1610 {
1611 firstc = NUL;
1612 break_ctrl_c = TRUE;
1613 }
1614#endif
1615#ifdef FEAT_RIGHTLEFT
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001616 // start without Hebrew mapping for a command line
Bram Moolenaar071d4272004-06-13 20:20:40 +00001617 if (firstc == ':' || firstc == '=' || firstc == '>')
1618 cmd_hkmap = 0;
1619#endif
1620
Bram Moolenaar071d4272004-06-13 20:20:40 +00001621#ifdef FEAT_SEARCH_EXTRA
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +02001622 init_incsearch_state(&is_state);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001623#endif
1624
Bram Moolenaar9c929712020-09-07 22:05:28 +02001625 if (init_ccline(firstc, indent) != OK)
Bram Moolenaar438d1762018-09-30 17:11:48 +02001626 goto theend; // out of memory
Bram Moolenaar4399ef42005-02-12 14:29:27 +00001627
Bram Moolenaar51f0bfb2022-05-17 20:11:02 +01001628 if (depth == 50)
1629 {
1630 // Somehow got into a loop recursively calling getcmdline(), bail out.
1631 emsg(_(e_command_too_recursive));
1632 goto theend;
1633 }
1634
Bram Moolenaar071d4272004-06-13 20:20:40 +00001635 ExpandInit(&xpc);
Bram Moolenaard6e7cc62008-09-14 12:42:29 +00001636 ccline.xpc = &xpc;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001637
1638#ifdef FEAT_RIGHTLEFT
1639 if (curwin->w_p_rl && *curwin->w_p_rlc == 's'
1640 && (firstc == '/' || firstc == '?'))
1641 cmdmsg_rl = TRUE;
1642 else
1643 cmdmsg_rl = FALSE;
1644#endif
1645
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001646 redir_off = TRUE; // don't redirect the typed command
Bram Moolenaar071d4272004-06-13 20:20:40 +00001647 if (!cmd_silent)
1648 {
1649 i = msg_scrolled;
Bram Moolenaar13608d82022-08-29 15:06:50 +01001650 msg_scrolled = 0; // avoid wait_return() message
Bram Moolenaar071d4272004-06-13 20:20:40 +00001651 gotocmdline(TRUE);
1652 msg_scrolled += i;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001653 redrawcmdprompt(); // draw prompt or indent
Bram Moolenaar071d4272004-06-13 20:20:40 +00001654 set_cmdspos();
1655 }
1656 xpc.xp_context = EXPAND_NOTHING;
1657 xpc.xp_backslash = XP_BS_NONE;
Bram Moolenaar8ada17c2006-01-19 22:16:24 +00001658#ifndef BACKSLASH_IN_FILENAME
1659 xpc.xp_shell = FALSE;
1660#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001661
Bram Moolenaarbfd8fc02005-09-20 23:22:24 +00001662#if defined(FEAT_EVAL)
1663 if (ccline.input_fn)
1664 {
1665 xpc.xp_context = ccline.xp_context;
1666 xpc.xp_pattern = ccline.cmdbuff;
1667 xpc.xp_arg = ccline.xp_arg;
1668 }
1669#endif
1670
Bram Moolenaar071d4272004-06-13 20:20:40 +00001671 /*
1672 * Avoid scrolling when called by a recursive do_cmdline(), e.g. when
1673 * doing ":@0" when register 0 doesn't contain a CR.
1674 */
1675 msg_scroll = FALSE;
1676
Bram Moolenaar24959102022-05-07 20:01:16 +01001677 State = MODE_CMDLINE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001678
1679 if (firstc == '/' || firstc == '?' || firstc == '@')
1680 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001681 // Use ":lmap" mappings for search pattern and input().
Bram Moolenaar071d4272004-06-13 20:20:40 +00001682 if (curbuf->b_p_imsearch == B_IMODE_USE_INSERT)
1683 b_im_ptr = &curbuf->b_p_iminsert;
1684 else
1685 b_im_ptr = &curbuf->b_p_imsearch;
1686 if (*b_im_ptr == B_IMODE_LMAP)
Bram Moolenaar24959102022-05-07 20:01:16 +01001687 State |= MODE_LANGMAP;
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01001688#ifdef HAVE_INPUT_METHOD
Bram Moolenaar071d4272004-06-13 20:20:40 +00001689 im_set_active(*b_im_ptr == B_IMODE_IM);
1690#endif
1691 }
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01001692#ifdef HAVE_INPUT_METHOD
Bram Moolenaar071d4272004-06-13 20:20:40 +00001693 else if (p_imcmdline)
1694 im_set_active(TRUE);
1695#endif
1696
Bram Moolenaar071d4272004-06-13 20:20:40 +00001697 setmouse();
Bram Moolenaar071d4272004-06-13 20:20:40 +00001698#ifdef CURSOR_SHAPE
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001699 ui_cursor_shape(); // may show different cursor shape
Bram Moolenaar071d4272004-06-13 20:20:40 +00001700#endif
1701
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001702 // When inside an autocommand for writing "exiting" may be set and
1703 // terminal mode set to cooked. Need to set raw mode here then.
Bram Moolenaarf4d11452005-12-02 00:46:37 +00001704 settmode(TMODE_RAW);
1705
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001706 // Trigger CmdlineEnter autocommands.
Bram Moolenaarfafcf0d2017-10-19 18:35:51 +02001707 cmdline_type = firstc == NUL ? '-' : firstc;
1708 trigger_cmd_autocmd(cmdline_type, EVENT_CMDLINEENTER);
=?UTF-8?q?Magnus=20Gro=C3=9F?=f1e88762021-09-12 13:39:55 +02001709#ifdef FEAT_EVAL
1710 if (!debug_mode)
LemonBoy2bf52dd2022-04-09 18:17:34 +01001711 may_trigger_modechanged();
=?UTF-8?q?Magnus=20Gro=C3=9F?=f1e88762021-09-12 13:39:55 +02001712#endif
Bram Moolenaarfafcf0d2017-10-19 18:35:51 +02001713
Bram Moolenaar071d4272004-06-13 20:20:40 +00001714 init_history();
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001715 hiscnt = get_hislen(); // set hiscnt to impossible history value
Bram Moolenaar071d4272004-06-13 20:20:40 +00001716 histype = hist_char2type(firstc);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001717
1718#ifdef FEAT_DIGRAPHS
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001719 do_digraph(-1); // init digraph typeahead
Bram Moolenaar071d4272004-06-13 20:20:40 +00001720#endif
1721
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001722 // If something above caused an error, reset the flags, we do want to type
1723 // and execute commands. Display may be messed up a bit.
Bram Moolenaar15a35c42014-06-25 12:26:46 +02001724 if (did_emsg)
1725 redrawcmd();
Bram Moolenaarce0b7572021-04-01 18:47:14 +02001726
Bram Moolenaar160a2b42021-04-01 21:57:46 +02001727#ifdef FEAT_STL_OPT
Bram Moolenaarce0b7572021-04-01 18:47:14 +02001728 // Redraw the statusline in case it uses the current mode using the mode()
1729 // function.
Bram Moolenaard8db8382021-04-08 18:27:53 +02001730 if (!cmd_silent && msg_scrolled == 0)
Bram Moolenaarce0b7572021-04-01 18:47:14 +02001731 {
Bram Moolenaard8db8382021-04-08 18:27:53 +02001732 int found_one = FALSE;
1733 win_T *wp;
1734
1735 FOR_ALL_WINDOWS(wp)
1736 if (*p_stl != NUL || *wp->w_p_stl != NUL)
1737 {
1738 wp->w_redr_status = TRUE;
1739 found_one = TRUE;
1740 }
zeertzjq6791adc2022-07-26 20:42:25 +01001741
1742 if (*p_tal != NUL)
1743 {
1744 redraw_tabline = TRUE;
1745 found_one = TRUE;
1746 }
1747
Bram Moolenaard8db8382021-04-08 18:27:53 +02001748 if (found_one)
1749 redraw_statuslines();
Bram Moolenaarce0b7572021-04-01 18:47:14 +02001750 }
Bram Moolenaar160a2b42021-04-01 21:57:46 +02001751#endif
Bram Moolenaarce0b7572021-04-01 18:47:14 +02001752
Bram Moolenaar15a35c42014-06-25 12:26:46 +02001753 did_emsg = FALSE;
1754 got_int = FALSE;
1755
Bram Moolenaar071d4272004-06-13 20:20:40 +00001756 /*
1757 * Collect the command string, handling editing keys.
1758 */
1759 for (;;)
1760 {
Bram Moolenaard832c3c2021-05-15 15:09:06 +02001761 int trigger_cmdlinechanged = TRUE;
Yegappan Lakshmanan5cffa8d2022-03-16 13:33:53 +00001762 int end_wildmenu;
Bram Moolenaard832c3c2021-05-15 15:09:06 +02001763
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001764 redir_off = TRUE; // Don't redirect the typed command.
1765 // Repeated, because a ":redir" inside
1766 // completion may switch it on.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001767#ifdef USE_ON_FLY_SCROLL
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001768 dont_scroll = FALSE; // allow scrolling here
Bram Moolenaar071d4272004-06-13 20:20:40 +00001769#endif
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001770 quit_more = FALSE; // reset after CTRL-D which had a more-prompt
Bram Moolenaar071d4272004-06-13 20:20:40 +00001771
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001772 did_emsg = FALSE; // There can't really be a reason why an error
1773 // that occurs while typing a command should
1774 // cause the command not to be executed.
Bram Moolenaar72532d32018-04-07 19:09:09 +02001775
Bram Moolenaar8aeec402019-09-15 23:02:04 +02001776 // Trigger SafeState if nothing is pending.
1777 may_trigger_safestate(xpc.xp_numfiles <= 0);
1778
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001779 // Get a character. Ignore K_IGNORE and K_NOP, they should not do
1780 // anything, such as stop completion.
Bram Moolenaar30405d32008-01-02 20:55:27 +00001781 do
Bram Moolenaarf4d61bc2020-11-14 14:22:28 +01001782 {
1783 cursorcmd(); // set the cursor on the right spot
Bram Moolenaar30405d32008-01-02 20:55:27 +00001784 c = safe_vgetc();
Bram Moolenaarf4d61bc2020-11-14 14:22:28 +01001785 } while (c == K_IGNORE || c == K_NOP);
Bram Moolenaar30405d32008-01-02 20:55:27 +00001786
Bram Moolenaare32c3c42022-01-15 18:26:04 +00001787 if (c == K_COMMAND || c == K_SCRIPT_COMMAND)
Bram Moolenaar847fe7d2021-05-15 13:19:16 +02001788 {
1789 int clen = ccline.cmdlen;
1790
Bram Moolenaare32c3c42022-01-15 18:26:04 +00001791 if (do_cmdkey_command(c, DOCMD_NOWAIT) == OK)
Bram Moolenaar847fe7d2021-05-15 13:19:16 +02001792 {
1793 if (clen == ccline.cmdlen)
Bram Moolenaard832c3c2021-05-15 15:09:06 +02001794 trigger_cmdlinechanged = FALSE;
Bram Moolenaar847fe7d2021-05-15 13:19:16 +02001795 goto cmdline_changed;
1796 }
1797 }
Bram Moolenaar957cf672020-11-12 14:21:06 +01001798
Bram Moolenaar071d4272004-06-13 20:20:40 +00001799 if (KeyTyped)
1800 {
1801 some_key_typed = TRUE;
1802#ifdef FEAT_RIGHTLEFT
1803 if (cmd_hkmap)
1804 c = hkmap(c);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001805 if (cmdmsg_rl && !KeyStuffed)
1806 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001807 // Invert horizontal movements and operations. Only when
1808 // typed by the user directly, not when the result of a
1809 // mapping.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001810 switch (c)
1811 {
1812 case K_RIGHT: c = K_LEFT; break;
1813 case K_S_RIGHT: c = K_S_LEFT; break;
1814 case K_C_RIGHT: c = K_C_LEFT; break;
1815 case K_LEFT: c = K_RIGHT; break;
1816 case K_S_LEFT: c = K_S_RIGHT; break;
1817 case K_C_LEFT: c = K_C_RIGHT; break;
1818 }
1819 }
1820#endif
1821 }
1822
1823 /*
1824 * Ignore got_int when CTRL-C was typed here.
1825 * Don't ignore it in :global, we really need to break then, e.g., for
1826 * ":g/pat/normal /pat" (without the <CR>).
1827 * Don't ignore it for the input() function.
1828 */
1829 if ((c == Ctrl_C
1830#ifdef UNIX
1831 || c == intr_char
1832#endif
1833 )
1834#if defined(FEAT_EVAL) || defined(FEAT_CRYPT)
1835 && firstc != '@'
1836#endif
1837#ifdef FEAT_EVAL
zeertzjq3cfae392022-07-26 17:48:13 +01001838 // do clear got_int in Ex mode to avoid infinite Ctrl-C loop
1839 && (!break_ctrl_c || exmode_active)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001840#endif
1841 && !global_busy)
1842 got_int = FALSE;
1843
Bram Moolenaard7663c22019-08-06 21:59:57 +02001844 // free old command line when finished moving around in the history
1845 // list
Bram Moolenaar071d4272004-06-13 20:20:40 +00001846 if (lookfor != NULL
Bram Moolenaarbc7aa852005-03-06 23:38:09 +00001847 && c != K_S_DOWN && c != K_S_UP
Bram Moolenaar68b76a62005-03-25 21:53:48 +00001848 && c != K_DOWN && c != K_UP
Bram Moolenaar071d4272004-06-13 20:20:40 +00001849 && c != K_PAGEDOWN && c != K_PAGEUP
1850 && c != K_KPAGEDOWN && c != K_KPAGEUP
Bram Moolenaar68b76a62005-03-25 21:53:48 +00001851 && c != K_LEFT && c != K_RIGHT
Bram Moolenaar071d4272004-06-13 20:20:40 +00001852 && (xpc.xp_numfiles > 0 || (c != Ctrl_P && c != Ctrl_N)))
Bram Moolenaard23a8232018-02-10 18:45:26 +01001853 VIM_CLEAR(lookfor);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001854
1855 /*
Bram Moolenaard6e7cc62008-09-14 12:42:29 +00001856 * When there are matching completions to select <S-Tab> works like
1857 * CTRL-P (unless 'wc' is <S-Tab>).
Bram Moolenaar071d4272004-06-13 20:20:40 +00001858 */
Bram Moolenaard6e7cc62008-09-14 12:42:29 +00001859 if (c != p_wc && c == K_S_TAB && xpc.xp_numfiles > 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001860 c = Ctrl_P;
1861
Yegappan Lakshmananb31aec32022-02-16 12:44:29 +00001862 if (p_wmnu)
1863 c = wildmenu_translate_key(&ccline, c, &xpc, did_wild_list);
Yegappan Lakshmanan3908ef52022-02-08 12:08:07 +00001864
1865 if (cmdline_pum_active())
1866 {
Yegappan Lakshmanan560dff42022-02-10 19:52:10 +00001867 // Ctrl-Y: Accept the current selection and close the popup menu.
1868 // Ctrl-E: cancel the cmdline popup menu and return the original
1869 // text.
Yegappan Lakshmanan3908ef52022-02-08 12:08:07 +00001870 if (c == Ctrl_E || c == Ctrl_Y)
1871 {
Yegappan Lakshmanan3908ef52022-02-08 12:08:07 +00001872 wild_type = (c == Ctrl_E) ? WILD_CANCEL : WILD_APPLY;
Yegappan Lakshmanan3908ef52022-02-08 12:08:07 +00001873 if (nextwild(&xpc, wild_type, WILD_NO_BEEP,
1874 firstc != '@') == FAIL)
1875 break;
Yegappan Lakshmanan560dff42022-02-10 19:52:10 +00001876 c = Ctrl_E;
Yegappan Lakshmanan3908ef52022-02-08 12:08:07 +00001877 }
1878 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001879
Yegappan Lakshmanan5cffa8d2022-03-16 13:33:53 +00001880 // The wildmenu is cleared if the pressed key is not used for
1881 // navigating the wild menu (i.e. the key is not 'wildchar' or
1882 // 'wildcharm' or Ctrl-N or Ctrl-P or Ctrl-A or Ctrl-L).
1883 // If the popup menu is displayed, then PageDown and PageUp keys are
1884 // also used to navigate the menu.
1885 end_wildmenu = (!(c == p_wc && KeyTyped) && c != p_wcm
1886 && c != Ctrl_N && c != Ctrl_P && c != Ctrl_A && c != Ctrl_L);
Yegappan Lakshmanan5cffa8d2022-03-16 13:33:53 +00001887 end_wildmenu = end_wildmenu && (!cmdline_pum_active() ||
1888 (c != K_PAGEDOWN && c != K_PAGEUP
1889 && c != K_KPAGEDOWN && c != K_KPAGEUP));
Yegappan Lakshmanan5cffa8d2022-03-16 13:33:53 +00001890
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001891 // free expanded names when finished walking through matches
Yegappan Lakshmanan5cffa8d2022-03-16 13:33:53 +00001892 if (end_wildmenu)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001893 {
Bram Moolenaar73a16c22022-02-08 17:40:36 +00001894 if (cmdline_pum_active())
1895 cmdline_pum_remove();
Yegappan Lakshmanan560dff42022-02-10 19:52:10 +00001896 if (xpc.xp_numfiles != -1)
1897 (void)ExpandOne(&xpc, NULL, NULL, 0, WILD_FREE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001898 did_wild_list = FALSE;
Bram Moolenaar68b76a62005-03-25 21:53:48 +00001899 if (!p_wmnu || (c != K_UP && c != K_DOWN))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001900 xpc.xp_context = EXPAND_NOTHING;
1901 wim_index = 0;
Bram Moolenaareadee482020-09-04 15:37:31 +02001902 wildmenu_cleanup(&ccline);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001903 }
1904
Yegappan Lakshmananb31aec32022-02-16 12:44:29 +00001905 if (p_wmnu)
1906 c = wildmenu_process_key(&ccline, c, &xpc);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001907
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001908 // CTRL-\ CTRL-N goes to Normal mode, CTRL-\ CTRL-G goes to Insert
1909 // mode when 'insertmode' is set, CTRL-\ e prompts for an expression.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001910 if (c == Ctrl_BSL)
1911 {
Bram Moolenaar9c929712020-09-07 22:05:28 +02001912 res = cmdline_handle_backslash_key(c, &gotesc);
1913 if (res == CMDLINE_CHANGED)
1914 goto cmdline_changed;
1915 else if (res == CMDLINE_NOT_CHANGED)
Bram Moolenaar66b4bf82010-11-16 14:06:08 +01001916 goto cmdline_not_changed;
Bram Moolenaar9c929712020-09-07 22:05:28 +02001917 else if (res == GOTO_NORMAL_MODE)
1918 goto returncmd; // back to cmd mode
1919 c = Ctrl_BSL; // backslash key not processed by
1920 // cmdline_handle_backslash_key()
Bram Moolenaar071d4272004-06-13 20:20:40 +00001921 }
1922
1923#ifdef FEAT_CMDWIN
1924 if (c == cedit_key || c == K_CMDWIN)
1925 {
Bram Moolenaar85db5472019-12-04 15:11:08 +01001926 // TODO: why is ex_normal_busy checked here?
1927 if ((c == K_CMDWIN || ex_normal_busy == 0) && got_int == FALSE)
Bram Moolenaar58da7072014-09-09 18:45:49 +02001928 {
1929 /*
1930 * Open a window to edit the command line (and history).
1931 */
Bram Moolenaar3bab9392017-04-07 15:42:25 +02001932 c = open_cmdwin();
Bram Moolenaar58da7072014-09-09 18:45:49 +02001933 some_key_typed = TRUE;
1934 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001935 }
1936# ifdef FEAT_DIGRAPHS
1937 else
1938# endif
1939#endif
1940#ifdef FEAT_DIGRAPHS
1941 c = do_digraph(c);
1942#endif
1943
1944 if (c == '\n' || c == '\r' || c == K_KENTER || (c == ESC
1945 && (!KeyTyped || vim_strchr(p_cpo, CPO_ESC) != NULL)))
1946 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001947 // In Ex mode a backslash escapes a newline.
Bram Moolenaar26a60b42005-02-22 08:49:11 +00001948 if (exmode_active
1949 && c != ESC
Bram Moolenaar26a60b42005-02-22 08:49:11 +00001950 && ccline.cmdpos == ccline.cmdlen
Bram Moolenaar5f2c5db2007-07-17 16:15:36 +00001951 && ccline.cmdpos > 0
Bram Moolenaar26a60b42005-02-22 08:49:11 +00001952 && ccline.cmdbuff[ccline.cmdpos - 1] == '\\')
Bram Moolenaar071d4272004-06-13 20:20:40 +00001953 {
Bram Moolenaar26a60b42005-02-22 08:49:11 +00001954 if (c == K_KENTER)
1955 c = '\n';
Bram Moolenaar071d4272004-06-13 20:20:40 +00001956 }
Bram Moolenaar26a60b42005-02-22 08:49:11 +00001957 else
1958 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001959 gotesc = FALSE; // Might have typed ESC previously, don't
1960 // truncate the cmdline now.
Bram Moolenaar26a60b42005-02-22 08:49:11 +00001961 if (ccheck_abbr(c + ABBR_OFF))
1962 goto cmdline_changed;
1963 if (!cmd_silent)
1964 {
1965 windgoto(msg_row, 0);
1966 out_flush();
1967 }
1968 break;
1969 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001970 }
1971
Bram Moolenaar9c929712020-09-07 22:05:28 +02001972 // Completion for 'wildchar' or 'wildcharm' key.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001973 if ((c == p_wc && !gotesc && KeyTyped) || c == p_wcm)
1974 {
Bram Moolenaar9c929712020-09-07 22:05:28 +02001975 res = cmdline_wildchar_complete(c, firstc != '@', &did_wild_list,
1976 &wim_index, &xpc, &gotesc);
1977 if (res == CMDLINE_CHANGED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001978 goto cmdline_changed;
1979 }
1980
1981 gotesc = FALSE;
1982
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001983 // <S-Tab> goes to last match, in a clumsy way
Bram Moolenaar071d4272004-06-13 20:20:40 +00001984 if (c == K_S_TAB && KeyTyped)
1985 {
Yegappan Lakshmanan3908ef52022-02-08 12:08:07 +00001986 if (nextwild(&xpc, WILD_EXPAND_KEEP, 0, firstc != '@') == OK)
1987 {
Bram Moolenaar300175f2022-08-21 18:38:21 +01001988 if (xpc.xp_numfiles > 1
1989 && ((!did_wild_list && (wim_flags[wim_index] & WIM_LIST))
Bram Moolenaar54162322022-08-26 16:58:51 +01001990 || p_wmnu))
Yegappan Lakshmanan560dff42022-02-10 19:52:10 +00001991 {
Yegappan Lakshmanan560dff42022-02-10 19:52:10 +00001992 // Trigger the popup menu when wildoptions=pum
1993 showmatches(&xpc, p_wmnu
1994 && ((wim_flags[wim_index] & WIM_LIST) == 0));
Yegappan Lakshmanan560dff42022-02-10 19:52:10 +00001995 }
Yegappan Lakshmanan3908ef52022-02-08 12:08:07 +00001996 if (nextwild(&xpc, WILD_PREV, 0, firstc != '@') == OK
1997 && nextwild(&xpc, WILD_PREV, 0, firstc != '@') == OK)
1998 goto cmdline_changed;
1999 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002000 }
2001
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002002 if (c == NUL || c == K_ZERO) // NUL is stored as NL
Bram Moolenaar071d4272004-06-13 20:20:40 +00002003 c = NL;
2004
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002005 do_abbr = TRUE; // default: check for abbreviation
Bram Moolenaar071d4272004-06-13 20:20:40 +00002006
2007 /*
2008 * Big switch for a typed command line character.
2009 */
2010 switch (c)
2011 {
2012 case K_BS:
2013 case Ctrl_H:
2014 case K_DEL:
2015 case K_KDEL:
2016 case Ctrl_W:
Bram Moolenaar2f3cd2e2020-09-06 15:54:00 +02002017 res = cmdline_erase_chars(c, indent
Bram Moolenaar4d6f32c2016-08-26 19:13:46 +02002018#ifdef FEAT_SEARCH_EXTRA
Bram Moolenaar2f3cd2e2020-09-06 15:54:00 +02002019 , &is_state
Bram Moolenaar4d6f32c2016-08-26 19:13:46 +02002020#endif
Bram Moolenaar2f3cd2e2020-09-06 15:54:00 +02002021 );
2022 if (res == CMDLINE_NOT_CHANGED)
2023 goto cmdline_not_changed;
2024 else if (res == GOTO_NORMAL_MODE)
2025 goto returncmd; // back to cmd mode
2026 goto cmdline_changed;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002027
2028 case K_INS:
2029 case K_KINS:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002030 ccline.overstrike = !ccline.overstrike;
2031#ifdef CURSOR_SHAPE
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002032 ui_cursor_shape(); // may show different cursor shape
Bram Moolenaar071d4272004-06-13 20:20:40 +00002033#endif
2034 goto cmdline_not_changed;
2035
2036 case Ctrl_HAT:
Bram Moolenaar2f3cd2e2020-09-06 15:54:00 +02002037 cmdline_toggle_langmap(b_im_ptr);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002038 goto cmdline_not_changed;
2039
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002040// case '@': only in very old vi
Bram Moolenaar071d4272004-06-13 20:20:40 +00002041 case Ctrl_U:
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002042 // delete all characters left of the cursor
Bram Moolenaar071d4272004-06-13 20:20:40 +00002043 j = ccline.cmdpos;
2044 ccline.cmdlen -= j;
2045 i = ccline.cmdpos = 0;
2046 while (i < ccline.cmdlen)
2047 ccline.cmdbuff[i++] = ccline.cmdbuff[j++];
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002048 // Truncate at the end, required for multi-byte chars.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002049 ccline.cmdbuff[ccline.cmdlen] = NUL;
Bram Moolenaar4d6f32c2016-08-26 19:13:46 +02002050#ifdef FEAT_SEARCH_EXTRA
2051 if (ccline.cmdlen == 0)
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +02002052 is_state.search_start = is_state.save_cursor;
Bram Moolenaar4d6f32c2016-08-26 19:13:46 +02002053#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002054 redrawcmd();
2055 goto cmdline_changed;
2056
2057#ifdef FEAT_CLIPBOARD
2058 case Ctrl_Y:
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002059 // Copy the modeless selection, if there is one.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002060 if (clip_star.state != SELECT_CLEARED)
2061 {
2062 if (clip_star.state == SELECT_DONE)
2063 clip_copy_modeless_selection(TRUE);
2064 goto cmdline_not_changed;
2065 }
2066 break;
2067#endif
2068
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002069 case ESC: // get here if p_wc != ESC or when ESC typed twice
Bram Moolenaar071d4272004-06-13 20:20:40 +00002070 case Ctrl_C:
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002071 // In exmode it doesn't make sense to return. Except when
2072 // ":normal" runs out of characters.
Bram Moolenaar7c626922005-02-07 22:01:03 +00002073 if (exmode_active
Bram Moolenaare2c38102016-01-31 14:55:40 +01002074 && (ex_normal_busy == 0 || typebuf.tb_len > 0))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002075 goto cmdline_not_changed;
2076
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002077 gotesc = TRUE; // will free ccline.cmdbuff after
2078 // putting it in history
2079 goto returncmd; // back to cmd mode
Bram Moolenaar071d4272004-06-13 20:20:40 +00002080
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002081 case Ctrl_R: // insert register
Bram Moolenaar2f3cd2e2020-09-06 15:54:00 +02002082 res = cmdline_insert_reg(&gotesc);
2083 if (res == CMDLINE_NOT_CHANGED)
2084 goto cmdline_not_changed;
2085 else if (res == GOTO_NORMAL_MODE)
2086 goto returncmd;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002087 goto cmdline_changed;
2088
2089 case Ctrl_D:
2090 if (showmatches(&xpc, FALSE) == EXPAND_NOTHING)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002091 break; // Use ^D as normal char instead
Bram Moolenaar071d4272004-06-13 20:20:40 +00002092
2093 redrawcmd();
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002094 continue; // don't do incremental search now
Bram Moolenaar071d4272004-06-13 20:20:40 +00002095
2096 case K_RIGHT:
2097 case K_S_RIGHT:
2098 case K_C_RIGHT:
2099 do
2100 {
2101 if (ccline.cmdpos >= ccline.cmdlen)
2102 break;
2103 i = cmdline_charsize(ccline.cmdpos);
2104 if (KeyTyped && ccline.cmdspos + i >= Columns * Rows)
2105 break;
2106 ccline.cmdspos += i;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002107 if (has_mbyte)
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00002108 ccline.cmdpos += (*mb_ptr2len)(ccline.cmdbuff
Bram Moolenaar071d4272004-06-13 20:20:40 +00002109 + ccline.cmdpos);
2110 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00002111 ++ccline.cmdpos;
2112 }
Bram Moolenaarbc7aa852005-03-06 23:38:09 +00002113 while ((c == K_S_RIGHT || c == K_C_RIGHT
2114 || (mod_mask & (MOD_MASK_SHIFT|MOD_MASK_CTRL)))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002115 && ccline.cmdbuff[ccline.cmdpos] != ' ');
Bram Moolenaar071d4272004-06-13 20:20:40 +00002116 if (has_mbyte)
2117 set_cmdspos_cursor();
Bram Moolenaar071d4272004-06-13 20:20:40 +00002118 goto cmdline_not_changed;
2119
2120 case K_LEFT:
2121 case K_S_LEFT:
2122 case K_C_LEFT:
Bram Moolenaar49feabd2007-12-07 19:28:58 +00002123 if (ccline.cmdpos == 0)
2124 goto cmdline_not_changed;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002125 do
2126 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00002127 --ccline.cmdpos;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002128 if (has_mbyte) // move to first byte of char
Bram Moolenaar071d4272004-06-13 20:20:40 +00002129 ccline.cmdpos -= (*mb_head_off)(ccline.cmdbuff,
2130 ccline.cmdbuff + ccline.cmdpos);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002131 ccline.cmdspos -= cmdline_charsize(ccline.cmdpos);
2132 }
Bram Moolenaar49feabd2007-12-07 19:28:58 +00002133 while (ccline.cmdpos > 0
2134 && (c == K_S_LEFT || c == K_C_LEFT
Bram Moolenaarbc7aa852005-03-06 23:38:09 +00002135 || (mod_mask & (MOD_MASK_SHIFT|MOD_MASK_CTRL)))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002136 && ccline.cmdbuff[ccline.cmdpos - 1] != ' ');
Bram Moolenaar071d4272004-06-13 20:20:40 +00002137 if (has_mbyte)
2138 set_cmdspos_cursor();
Bram Moolenaar071d4272004-06-13 20:20:40 +00002139 goto cmdline_not_changed;
2140
2141 case K_IGNORE:
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002142 // Ignore mouse event or open_cmdwin() result.
Bram Moolenaar30405d32008-01-02 20:55:27 +00002143 goto cmdline_not_changed;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002144
Bram Moolenaar4f974752019-02-17 17:44:42 +01002145#ifdef FEAT_GUI_MSWIN
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002146 // On MS-Windows ignore <M-F4>, we get it when closing the window
2147 // was cancelled.
Bram Moolenaar4770d092006-01-12 23:22:24 +00002148 case K_F4:
2149 if (mod_mask == MOD_MASK_ALT)
2150 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002151 redrawcmd(); // somehow the cmdline is cleared
Bram Moolenaar4770d092006-01-12 23:22:24 +00002152 goto cmdline_not_changed;
2153 }
2154 break;
2155#endif
2156
Bram Moolenaar071d4272004-06-13 20:20:40 +00002157 case K_MIDDLEDRAG:
2158 case K_MIDDLERELEASE:
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002159 goto cmdline_not_changed; // Ignore mouse
Bram Moolenaar071d4272004-06-13 20:20:40 +00002160
2161 case K_MIDDLEMOUSE:
2162# ifdef FEAT_GUI
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002163 // When GUI is active, also paste when 'mouse' is empty
Bram Moolenaar071d4272004-06-13 20:20:40 +00002164 if (!gui.in_use)
2165# endif
2166 if (!mouse_has(MOUSE_COMMAND))
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002167 goto cmdline_not_changed; // Ignore mouse
Bram Moolenaara23ccb82006-02-27 00:08:02 +00002168# ifdef FEAT_CLIPBOARD
Bram Moolenaar071d4272004-06-13 20:20:40 +00002169 if (clip_star.available)
Bram Moolenaar1769d5a2006-10-17 14:25:24 +00002170 cmdline_paste('*', TRUE, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002171 else
Bram Moolenaara23ccb82006-02-27 00:08:02 +00002172# endif
Bram Moolenaar1769d5a2006-10-17 14:25:24 +00002173 cmdline_paste(0, TRUE, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002174 redrawcmd();
2175 goto cmdline_changed;
2176
Bram Moolenaara23ccb82006-02-27 00:08:02 +00002177# ifdef FEAT_DND
Bram Moolenaar071d4272004-06-13 20:20:40 +00002178 case K_DROP:
Bram Moolenaar1769d5a2006-10-17 14:25:24 +00002179 cmdline_paste('~', TRUE, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002180 redrawcmd();
2181 goto cmdline_changed;
Bram Moolenaara23ccb82006-02-27 00:08:02 +00002182# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002183
2184 case K_LEFTDRAG:
2185 case K_LEFTRELEASE:
2186 case K_RIGHTDRAG:
2187 case K_RIGHTRELEASE:
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002188 // Ignore drag and release events when the button-down wasn't
2189 // seen before.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002190 if (ignore_drag_release)
2191 goto cmdline_not_changed;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002192 // FALLTHROUGH
Bram Moolenaar071d4272004-06-13 20:20:40 +00002193 case K_LEFTMOUSE:
2194 case K_RIGHTMOUSE:
Bram Moolenaar2f3cd2e2020-09-06 15:54:00 +02002195 cmdline_left_right_mouse(c, &ignore_drag_release);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002196 goto cmdline_not_changed;
2197
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002198 // Mouse scroll wheel: ignored here
Bram Moolenaar071d4272004-06-13 20:20:40 +00002199 case K_MOUSEDOWN:
2200 case K_MOUSEUP:
Bram Moolenaar8d9b40e2010-07-25 15:49:07 +02002201 case K_MOUSELEFT:
2202 case K_MOUSERIGHT:
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002203 // Alternate buttons ignored here
Bram Moolenaar071d4272004-06-13 20:20:40 +00002204 case K_X1MOUSE:
2205 case K_X1DRAG:
2206 case K_X1RELEASE:
2207 case K_X2MOUSE:
2208 case K_X2DRAG:
2209 case K_X2RELEASE:
Bram Moolenaar51b0f372017-11-18 18:52:04 +01002210 case K_MOUSEMOVE:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002211 goto cmdline_not_changed;
2212
Bram Moolenaar071d4272004-06-13 20:20:40 +00002213#ifdef FEAT_GUI
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002214 case K_LEFTMOUSE_NM: // mousefocus click, ignored
Bram Moolenaar071d4272004-06-13 20:20:40 +00002215 case K_LEFTRELEASE_NM:
2216 goto cmdline_not_changed;
2217
2218 case K_VER_SCROLLBAR:
Bram Moolenaar1c7715d2005-10-03 22:02:18 +00002219 if (msg_scrolled == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002220 {
2221 gui_do_scroll();
2222 redrawcmd();
2223 }
2224 goto cmdline_not_changed;
2225
2226 case K_HOR_SCROLLBAR:
Bram Moolenaar1c7715d2005-10-03 22:02:18 +00002227 if (msg_scrolled == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002228 {
Bram Moolenaar8d9b40e2010-07-25 15:49:07 +02002229 gui_do_horiz_scroll(scrollbar_value, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002230 redrawcmd();
2231 }
2232 goto cmdline_not_changed;
2233#endif
Bram Moolenaara23ccb82006-02-27 00:08:02 +00002234#ifdef FEAT_GUI_TABLINE
2235 case K_TABLINE:
2236 case K_TABMENU:
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002237 // Don't want to change any tabs here. Make sure the same tab
2238 // is still selected.
Bram Moolenaara23ccb82006-02-27 00:08:02 +00002239 if (gui_use_tabline())
2240 gui_mch_set_curtab(tabpage_index(curtab));
2241 goto cmdline_not_changed;
2242#endif
2243
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002244 case K_SELECT: // end of Select mode mapping - ignore
Bram Moolenaar071d4272004-06-13 20:20:40 +00002245 goto cmdline_not_changed;
2246
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002247 case Ctrl_B: // begin of command line
Bram Moolenaar071d4272004-06-13 20:20:40 +00002248 case K_HOME:
2249 case K_KHOME:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002250 case K_S_HOME:
2251 case K_C_HOME:
2252 ccline.cmdpos = 0;
2253 set_cmdspos();
2254 goto cmdline_not_changed;
2255
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002256 case Ctrl_E: // end of command line
Bram Moolenaar071d4272004-06-13 20:20:40 +00002257 case K_END:
2258 case K_KEND:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002259 case K_S_END:
2260 case K_C_END:
2261 ccline.cmdpos = ccline.cmdlen;
2262 set_cmdspos_cursor();
2263 goto cmdline_not_changed;
2264
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002265 case Ctrl_A: // all matches
Yegappan Lakshmanan3908ef52022-02-08 12:08:07 +00002266 if (cmdline_pum_active())
Yegappan Lakshmanan560dff42022-02-10 19:52:10 +00002267 // As Ctrl-A completes all the matches, close the popup
2268 // menu (if present)
Yegappan Lakshmanan3908ef52022-02-08 12:08:07 +00002269 cmdline_pum_cleanup(&ccline);
Bram Moolenaar54162322022-08-26 16:58:51 +01002270
Yegappan Lakshmanan560dff42022-02-10 19:52:10 +00002271 if (nextwild(&xpc, WILD_ALL, 0, firstc != '@') == FAIL)
2272 break;
2273 xpc.xp_context = EXPAND_NOTHING;
2274 did_wild_list = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002275 goto cmdline_changed;
2276
Bram Moolenaarefd2bf12006-03-16 21:41:35 +00002277 case Ctrl_L:
2278#ifdef FEAT_SEARCH_EXTRA
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +02002279 if (may_add_char_to_search(firstc, &c, &is_state) == OK)
Bram Moolenaarefd2bf12006-03-16 21:41:35 +00002280 goto cmdline_not_changed;
Bram Moolenaarefd2bf12006-03-16 21:41:35 +00002281#endif
2282
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002283 // completion: longest common part
Bram Moolenaarb3479632012-11-28 16:49:58 +01002284 if (nextwild(&xpc, WILD_LONGEST, 0, firstc != '@') == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002285 break;
2286 goto cmdline_changed;
2287
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002288 case Ctrl_N: // next match
2289 case Ctrl_P: // previous match
Bram Moolenaar7df0f632016-08-26 19:56:00 +02002290 if (xpc.xp_numfiles > 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002291 {
Yegappan Lakshmanan155b0882022-03-17 13:03:09 +00002292 wild_type = (c == Ctrl_P) ? WILD_PREV : WILD_NEXT;
2293 if (nextwild(&xpc, wild_type, 0, firstc != '@') == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002294 break;
Bram Moolenaar11956692016-08-27 16:26:56 +02002295 goto cmdline_not_changed;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002296 }
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002297 // FALLTHROUGH
Bram Moolenaar071d4272004-06-13 20:20:40 +00002298 case K_UP:
2299 case K_DOWN:
2300 case K_S_UP:
2301 case K_S_DOWN:
2302 case K_PAGEUP:
2303 case K_KPAGEUP:
2304 case K_PAGEDOWN:
2305 case K_KPAGEDOWN:
Yegappan Lakshmanan5cffa8d2022-03-16 13:33:53 +00002306 if (cmdline_pum_active()
2307 && (c == K_PAGEUP || c == K_PAGEDOWN ||
2308 c == K_KPAGEUP || c == K_KPAGEDOWN))
2309 {
2310 // If the popup menu is displayed, then PageUp and PageDown
2311 // are used to scroll the menu.
Yegappan Lakshmanan155b0882022-03-17 13:03:09 +00002312 wild_type = WILD_PAGEUP;
2313 if (c == K_PAGEDOWN || c == K_KPAGEDOWN)
2314 wild_type = WILD_PAGEDOWN;
2315 if (nextwild(&xpc, wild_type, 0, firstc != '@') == FAIL)
Yegappan Lakshmanan5cffa8d2022-03-16 13:33:53 +00002316 break;
2317 goto cmdline_not_changed;
2318 }
2319 else
Yegappan Lakshmanan5cffa8d2022-03-16 13:33:53 +00002320 {
2321 res = cmdline_browse_history(c, firstc, &lookfor, histype,
2322 &hiscnt, &xpc);
2323 if (res == CMDLINE_CHANGED)
2324 goto cmdline_changed;
2325 else if (res == GOTO_NORMAL_MODE)
2326 goto returncmd;
2327 }
Bram Moolenaar11956692016-08-27 16:26:56 +02002328 goto cmdline_not_changed;
2329
Bram Moolenaar349e7d92016-09-03 20:04:34 +02002330#ifdef FEAT_SEARCH_EXTRA
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002331 case Ctrl_G: // next match
2332 case Ctrl_T: // previous match
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +02002333 if (may_adjust_incsearch_highlighting(
2334 firstc, count, &is_state, c) == FAIL)
Bram Moolenaar349e7d92016-09-03 20:04:34 +02002335 goto cmdline_not_changed;
Bram Moolenaar349e7d92016-09-03 20:04:34 +02002336 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002337#endif
2338
2339 case Ctrl_V:
2340 case Ctrl_Q:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002341 {
Bram Moolenaarfc4ea2a2019-11-26 19:33:22 +01002342 ignore_drag_release = TRUE;
2343 putcmdline('^', TRUE);
Bram Moolenaar0684e362020-12-03 19:54:42 +01002344
2345 // Get next (two) character(s). Do not change any
2346 // modifyOtherKeys ESC sequence to a normal key for
2347 // CTRL-SHIFT-V.
2348 c = get_literal(mod_mask & MOD_MASK_SHIFT);
2349
Bram Moolenaarfc4ea2a2019-11-26 19:33:22 +01002350 do_abbr = FALSE; // don't do abbreviation now
2351 extra_char = NUL;
2352 // may need to remove ^ when composing char was typed
2353 if (enc_utf8 && utf_iscomposing(c) && !cmd_silent)
2354 {
2355 draw_cmdline(ccline.cmdpos,
2356 ccline.cmdlen - ccline.cmdpos);
2357 msg_putchar(' ');
2358 cursorcmd();
2359 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002360 }
Bram Moolenaarfc4ea2a2019-11-26 19:33:22 +01002361
Bram Moolenaar071d4272004-06-13 20:20:40 +00002362 break;
2363
2364#ifdef FEAT_DIGRAPHS
2365 case Ctrl_K:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002366 ignore_drag_release = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002367 putcmdline('?', TRUE);
Bram Moolenaara1cb1d12019-10-17 23:00:07 +02002368# ifdef USE_ON_FLY_SCROLL
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002369 dont_scroll = TRUE; // disallow scrolling here
Bram Moolenaara1cb1d12019-10-17 23:00:07 +02002370# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002371 c = get_digraph(TRUE);
Bram Moolenaara92522f2017-07-15 15:21:38 +02002372 extra_char = NUL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002373 if (c != NUL)
2374 break;
2375
2376 redrawcmd();
2377 goto cmdline_not_changed;
Bram Moolenaara1cb1d12019-10-17 23:00:07 +02002378#endif // FEAT_DIGRAPHS
Bram Moolenaar071d4272004-06-13 20:20:40 +00002379
2380#ifdef FEAT_RIGHTLEFT
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002381 case Ctrl__: // CTRL-_: switch language mode
Bram Moolenaar071d4272004-06-13 20:20:40 +00002382 if (!p_ari)
2383 break;
Bram Moolenaar14184a32019-02-16 15:10:30 +01002384 cmd_hkmap = !cmd_hkmap;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002385 goto cmdline_not_changed;
2386#endif
2387
Bram Moolenaarabbc4482017-01-24 15:57:55 +01002388 case K_PS:
2389 bracketed_paste(PASTE_CMDLINE, FALSE, NULL);
2390 goto cmdline_changed;
2391
Bram Moolenaar071d4272004-06-13 20:20:40 +00002392 default:
2393#ifdef UNIX
2394 if (c == intr_char)
2395 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002396 gotesc = TRUE; // will free ccline.cmdbuff after
2397 // putting it in history
2398 goto returncmd; // back to Normal mode
Bram Moolenaar071d4272004-06-13 20:20:40 +00002399 }
2400#endif
2401 /*
2402 * Normal character with no special meaning. Just set mod_mask
2403 * to 0x0 so that typing Shift-Space in the GUI doesn't enter
2404 * the string <S-Space>. This should only happen after ^V.
2405 */
2406 if (!IS_SPECIAL(c))
2407 mod_mask = 0x0;
2408 break;
2409 }
2410 /*
2411 * End of switch on command line character.
2412 * We come here if we have a normal character.
2413 */
2414
Bram Moolenaar13505972019-01-24 15:04:48 +01002415 if (do_abbr && (IS_SPECIAL(c) || !vim_iswordc(c))
2416 && (ccheck_abbr(
2417 // Add ABBR_OFF for characters above 0x100, this is
2418 // what check_abbr() expects.
2419 (has_mbyte && c >= 0x100) ? (c + ABBR_OFF) : c)
2420 || c == Ctrl_RSB))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002421 goto cmdline_changed;
2422
2423 /*
2424 * put the character in the command line
2425 */
2426 if (IS_SPECIAL(c) || mod_mask != 0)
2427 put_on_cmdline(get_special_key_name(c, mod_mask), -1, TRUE);
2428 else
2429 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00002430 if (has_mbyte)
2431 {
2432 j = (*mb_char2bytes)(c, IObuff);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002433 IObuff[j] = NUL; // exclude composing chars
Bram Moolenaar071d4272004-06-13 20:20:40 +00002434 put_on_cmdline(IObuff, j, TRUE);
2435 }
2436 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00002437 {
2438 IObuff[0] = c;
2439 put_on_cmdline(IObuff, 1, TRUE);
2440 }
2441 }
2442 goto cmdline_changed;
2443
2444/*
2445 * This part implements incremental searches for "/" and "?"
2446 * Jump to cmdline_not_changed when a character has been read but the command
2447 * line did not change. Then we only search and redraw if something changed in
2448 * the past.
2449 * Jump to cmdline_changed when the command line did change.
2450 * (Sorry for the goto's, I know it is ugly).
2451 */
2452cmdline_not_changed:
2453#ifdef FEAT_SEARCH_EXTRA
Bram Moolenaar0ee81cb2018-08-10 22:07:32 +02002454 if (!is_state.incsearch_postponed)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002455 continue;
2456#endif
2457
2458cmdline_changed:
Bram Moolenaarf4d61bc2020-11-14 14:22:28 +01002459#ifdef FEAT_SEARCH_EXTRA
2460 // If the window changed incremental search state is not valid.
2461 if (is_state.winid != curwin->w_id)
2462 init_incsearch_state(&is_state);
2463#endif
Bram Moolenaard832c3c2021-05-15 15:09:06 +02002464 if (trigger_cmdlinechanged)
2465 // Trigger CmdlineChanged autocommands.
2466 trigger_cmd_autocmd(cmdline_type, EVENT_CMDLINECHANGED);
Bram Moolenaar153b7042018-01-31 15:48:32 +01002467
Bram Moolenaar071d4272004-06-13 20:20:40 +00002468#ifdef FEAT_SEARCH_EXTRA
Bram Moolenaarccb148a2021-07-26 21:11:32 +02002469 if (xpc.xp_context == EXPAND_NOTHING && (KeyTyped || vpeekc() == NUL))
Bram Moolenaara60053b2020-09-03 16:50:13 +02002470 may_do_incsearch_highlighting(firstc, count, &is_state);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002471#endif
2472
2473#ifdef FEAT_RIGHTLEFT
2474 if (cmdmsg_rl
2475# ifdef FEAT_ARABIC
Bram Moolenaar693f7dc2019-06-21 02:30:38 +02002476 || (p_arshape && !p_tbidi
2477 && cmdline_has_arabic(0, ccline.cmdlen))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002478# endif
2479 )
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002480 // Always redraw the whole command line to fix shaping and
2481 // right-left typing. Not efficient, but it works.
2482 // Do it only when there are no characters left to read
2483 // to avoid useless intermediate redraws.
Bram Moolenaar58437e02012-02-22 17:58:04 +01002484 if (vpeekc() == NUL)
2485 redrawcmd();
Bram Moolenaar071d4272004-06-13 20:20:40 +00002486#endif
2487 }
2488
2489returncmd:
2490
2491#ifdef FEAT_RIGHTLEFT
2492 cmdmsg_rl = FALSE;
2493#endif
2494
Bram Moolenaar071d4272004-06-13 20:20:40 +00002495 ExpandCleanup(&xpc);
Bram Moolenaard6e7cc62008-09-14 12:42:29 +00002496 ccline.xpc = NULL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002497
2498#ifdef FEAT_SEARCH_EXTRA
Bram Moolenaarc7f08b72018-08-12 17:39:14 +02002499 finish_incsearch_highlighting(gotesc, &is_state, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002500#endif
2501
2502 if (ccline.cmdbuff != NULL)
2503 {
2504 /*
2505 * Put line in history buffer (":" and "=" only when it was typed).
2506 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002507 if (ccline.cmdlen && firstc != NUL
2508 && (some_key_typed || histype == HIST_SEARCH))
2509 {
2510 add_to_history(histype, ccline.cmdbuff, TRUE,
2511 histype == HIST_SEARCH ? firstc : NUL);
2512 if (firstc == ':')
2513 {
2514 vim_free(new_last_cmdline);
2515 new_last_cmdline = vim_strsave(ccline.cmdbuff);
2516 }
2517 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002518
Bram Moolenaarf8e8c062017-10-22 14:44:17 +02002519 if (gotesc)
2520 abandon_cmdline();
Bram Moolenaar071d4272004-06-13 20:20:40 +00002521 }
2522
2523 /*
2524 * If the screen was shifted up, redraw the whole screen (later).
2525 * If the line is too long, clear it, so ruler and shown command do
2526 * not get printed in the middle of it.
2527 */
2528 msg_check();
2529 msg_scroll = save_msg_scroll;
2530 redir_off = FALSE;
2531
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002532 // When the command line was typed, no need for a wait-return prompt.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002533 if (some_key_typed)
2534 need_wait_return = FALSE;
2535
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002536 // Trigger CmdlineLeave autocommands.
Bram Moolenaarfafcf0d2017-10-19 18:35:51 +02002537 trigger_cmd_autocmd(cmdline_type, EVENT_CMDLINELEAVE);
Bram Moolenaarfafcf0d2017-10-19 18:35:51 +02002538
Bram Moolenaar071d4272004-06-13 20:20:40 +00002539 State = save_State;
=?UTF-8?q?Magnus=20Gro=C3=9F?=f1e88762021-09-12 13:39:55 +02002540
2541#ifdef FEAT_EVAL
2542 if (!debug_mode)
LemonBoy2bf52dd2022-04-09 18:17:34 +01002543 may_trigger_modechanged();
=?UTF-8?q?Magnus=20Gro=C3=9F?=f1e88762021-09-12 13:39:55 +02002544#endif
2545
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01002546#ifdef HAVE_INPUT_METHOD
Bram Moolenaar071d4272004-06-13 20:20:40 +00002547 if (b_im_ptr != NULL && *b_im_ptr != B_IMODE_LMAP)
2548 im_save_status(b_im_ptr);
2549 im_set_active(FALSE);
2550#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002551 setmouse();
Bram Moolenaar071d4272004-06-13 20:20:40 +00002552#ifdef CURSOR_SHAPE
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002553 ui_cursor_shape(); // may show different cursor shape
Bram Moolenaar071d4272004-06-13 20:20:40 +00002554#endif
Bram Moolenaarf2405ed2017-03-16 19:58:25 +01002555 sb_text_end_cmdline();
Bram Moolenaar071d4272004-06-13 20:20:40 +00002556
Bram Moolenaar438d1762018-09-30 17:11:48 +02002557theend:
Bram Moolenaar5f2bb9f2005-01-11 21:29:04 +00002558 {
2559 char_u *p = ccline.cmdbuff;
2560
Bram Moolenaar51f0bfb2022-05-17 20:11:02 +01002561 --depth;
Bram Moolenaar438d1762018-09-30 17:11:48 +02002562 if (did_save_ccline)
2563 restore_cmdline(&save_ccline);
2564 else
2565 ccline.cmdbuff = NULL;
Bram Moolenaar5f2bb9f2005-01-11 21:29:04 +00002566 return p;
2567 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002568}
2569
2570#if (defined(FEAT_CRYPT) || defined(FEAT_EVAL)) || defined(PROTO)
2571/*
2572 * Get a command line with a prompt.
2573 * This is prepared to be called recursively from getcmdline() (e.g. by
2574 * f_input() when evaluating an expression from CTRL-R =).
2575 * Returns the command line in allocated memory, or NULL.
2576 */
2577 char_u *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01002578getcmdline_prompt(
2579 int firstc,
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002580 char_u *prompt, // command line prompt
2581 int attr, // attributes for prompt
2582 int xp_context, // type of expansion
2583 char_u *xp_arg) // user-defined expansion argument
Bram Moolenaar071d4272004-06-13 20:20:40 +00002584{
2585 char_u *s;
Bram Moolenaar66b51422019-08-18 21:44:12 +02002586 cmdline_info_T save_ccline;
Bram Moolenaar438d1762018-09-30 17:11:48 +02002587 int did_save_ccline = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002588 int msg_col_save = msg_col;
Bram Moolenaar6135d0d2016-03-22 20:31:13 +01002589 int msg_silent_save = msg_silent;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002590
Bram Moolenaar438d1762018-09-30 17:11:48 +02002591 if (ccline.cmdbuff != NULL)
2592 {
2593 // Save the values of the current cmdline and restore them below.
2594 save_cmdline(&save_ccline);
2595 did_save_ccline = TRUE;
2596 }
2597
Bram Moolenaara80faa82020-04-12 19:37:17 +02002598 CLEAR_FIELD(ccline);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002599 ccline.cmdprompt = prompt;
2600 ccline.cmdattr = attr;
Bram Moolenaarbfd8fc02005-09-20 23:22:24 +00002601# ifdef FEAT_EVAL
2602 ccline.xp_context = xp_context;
2603 ccline.xp_arg = xp_arg;
2604 ccline.input_fn = (firstc == '@');
2605# endif
Bram Moolenaar6135d0d2016-03-22 20:31:13 +01002606 msg_silent = 0;
Bram Moolenaar438d1762018-09-30 17:11:48 +02002607 s = getcmdline_int(firstc, 1L, 0, FALSE);
2608
2609 if (did_save_ccline)
2610 restore_cmdline(&save_ccline);
2611
Bram Moolenaar6135d0d2016-03-22 20:31:13 +01002612 msg_silent = msg_silent_save;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002613 // Restore msg_col, the prompt from input() may have changed it.
2614 // But only if called recursively and the commandline is therefore being
2615 // restored to an old one; if not, the input() prompt stays on the screen,
2616 // so we need its modified msg_col left intact.
Bram Moolenaar1db1f772011-08-17 16:25:48 +02002617 if (ccline.cmdbuff != NULL)
2618 msg_col = msg_col_save;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002619
2620 return s;
2621}
2622#endif
2623
Bram Moolenaar8ada17c2006-01-19 22:16:24 +00002624/*
Bram Moolenaar7bae0b12019-11-21 22:14:18 +01002625 * Read the 'wildmode' option, fill wim_flags[].
2626 */
2627 int
2628check_opt_wim(void)
2629{
2630 char_u new_wim_flags[4];
2631 char_u *p;
2632 int i;
2633 int idx = 0;
2634
2635 for (i = 0; i < 4; ++i)
2636 new_wim_flags[i] = 0;
2637
2638 for (p = p_wim; *p; ++p)
2639 {
2640 for (i = 0; ASCII_ISALPHA(p[i]); ++i)
2641 ;
2642 if (p[i] != NUL && p[i] != ',' && p[i] != ':')
2643 return FAIL;
2644 if (i == 7 && STRNCMP(p, "longest", 7) == 0)
2645 new_wim_flags[idx] |= WIM_LONGEST;
2646 else if (i == 4 && STRNCMP(p, "full", 4) == 0)
2647 new_wim_flags[idx] |= WIM_FULL;
2648 else if (i == 4 && STRNCMP(p, "list", 4) == 0)
2649 new_wim_flags[idx] |= WIM_LIST;
2650 else if (i == 8 && STRNCMP(p, "lastused", 8) == 0)
2651 new_wim_flags[idx] |= WIM_BUFLASTUSED;
2652 else
2653 return FAIL;
2654 p += i;
2655 if (*p == NUL)
2656 break;
2657 if (*p == ',')
2658 {
2659 if (idx == 3)
2660 return FAIL;
2661 ++idx;
2662 }
2663 }
2664
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002665 // fill remaining entries with last flag
Bram Moolenaar7bae0b12019-11-21 22:14:18 +01002666 while (idx < 3)
2667 {
2668 new_wim_flags[idx + 1] = new_wim_flags[idx];
2669 ++idx;
2670 }
2671
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002672 // only when there are no errors, wim_flags[] is changed
Bram Moolenaar7bae0b12019-11-21 22:14:18 +01002673 for (i = 0; i < 4; ++i)
2674 wim_flags[i] = new_wim_flags[i];
2675 return OK;
2676}
2677
2678/*
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00002679 * Return TRUE when the text must not be changed and we can't switch to
Bram Moolenaar6adb9ea2020-04-30 22:31:18 +02002680 * another window or buffer. TRUE when editing the command line, evaluating
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00002681 * 'balloonexpr', etc.
Bram Moolenaar8ada17c2006-01-19 22:16:24 +00002682 */
2683 int
zeertzjqcfe45652022-05-27 17:26:55 +01002684text_locked(void)
Bram Moolenaar8ada17c2006-01-19 22:16:24 +00002685{
2686#ifdef FEAT_CMDWIN
2687 if (cmdwin_type != 0)
2688 return TRUE;
2689#endif
zeertzjqcfe45652022-05-27 17:26:55 +01002690 return textlock != 0;
Bram Moolenaar8ada17c2006-01-19 22:16:24 +00002691}
2692
2693/*
2694 * Give an error message for a command that isn't allowed while the cmdline
2695 * window is open or editing the cmdline in another way.
2696 */
2697 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01002698text_locked_msg(void)
Bram Moolenaar8ada17c2006-01-19 22:16:24 +00002699{
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002700 emsg(_(get_text_locked_msg()));
Bram Moolenaar5a497892016-09-03 16:29:04 +02002701}
2702
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002703 char *
Bram Moolenaar5a497892016-09-03 16:29:04 +02002704get_text_locked_msg(void)
2705{
Bram Moolenaar8ada17c2006-01-19 22:16:24 +00002706#ifdef FEAT_CMDWIN
2707 if (cmdwin_type != 0)
Bram Moolenaar108010a2021-06-27 22:03:33 +02002708 return e_invalid_in_cmdline_window;
Bram Moolenaar8ada17c2006-01-19 22:16:24 +00002709#endif
zeertzjqcfe45652022-05-27 17:26:55 +01002710 return e_not_allowed_to_change_text_or_change_window;
Bram Moolenaar6adb9ea2020-04-30 22:31:18 +02002711}
2712
2713/*
Bram Moolenaar71223e22022-05-30 15:23:09 +01002714 * Check for text, window or buffer locked.
2715 * Give an error message and return TRUE if something is locked.
2716 */
2717 int
2718text_or_buf_locked(void)
2719{
2720 if (text_locked())
2721 {
2722 text_locked_msg();
2723 return TRUE;
2724 }
2725 return curbuf_locked();
2726}
2727
2728/*
Bram Moolenaarbf1b7a72009-03-05 02:15:53 +00002729 * Check if "curbuf_lock" or "allbuf_lock" is set and return TRUE when it is
2730 * and give an error message.
Bram Moolenaar910f66f2006-04-05 20:41:53 +00002731 */
2732 int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01002733curbuf_locked(void)
Bram Moolenaar910f66f2006-04-05 20:41:53 +00002734{
2735 if (curbuf_lock > 0)
2736 {
Bram Moolenaar677658a2022-01-05 16:09:06 +00002737 emsg(_(e_not_allowed_to_edit_another_buffer_now));
Bram Moolenaar910f66f2006-04-05 20:41:53 +00002738 return TRUE;
2739 }
Bram Moolenaarbf1b7a72009-03-05 02:15:53 +00002740 return allbuf_locked();
2741}
2742
2743/*
2744 * Check if "allbuf_lock" is set and return TRUE when it is and give an error
2745 * message.
2746 */
2747 int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01002748allbuf_locked(void)
Bram Moolenaarbf1b7a72009-03-05 02:15:53 +00002749{
2750 if (allbuf_lock > 0)
2751 {
Bram Moolenaar9d00e4a2022-01-05 17:49:15 +00002752 emsg(_(e_not_allowed_to_change_buffer_information_now));
Bram Moolenaarbf1b7a72009-03-05 02:15:53 +00002753 return TRUE;
2754 }
Bram Moolenaar910f66f2006-04-05 20:41:53 +00002755 return FALSE;
2756}
Bram Moolenaar910f66f2006-04-05 20:41:53 +00002757
Bram Moolenaar071d4272004-06-13 20:20:40 +00002758 static int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01002759cmdline_charsize(int idx)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002760{
2761#if defined(FEAT_CRYPT) || defined(FEAT_EVAL)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002762 if (cmdline_star > 0) // showing '*', always 1 position
Bram Moolenaar071d4272004-06-13 20:20:40 +00002763 return 1;
2764#endif
2765 return ptr2cells(ccline.cmdbuff + idx);
2766}
2767
2768/*
2769 * Compute the offset of the cursor on the command line for the prompt and
2770 * indent.
2771 */
2772 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01002773set_cmdspos(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002774{
Bram Moolenaarbfd8fc02005-09-20 23:22:24 +00002775 if (ccline.cmdfirstc != NUL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002776 ccline.cmdspos = 1 + ccline.cmdindent;
2777 else
2778 ccline.cmdspos = 0 + ccline.cmdindent;
2779}
2780
2781/*
2782 * Compute the screen position for the cursor on the command line.
2783 */
2784 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01002785set_cmdspos_cursor(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002786{
2787 int i, m, c;
2788
2789 set_cmdspos();
2790 if (KeyTyped)
Bram Moolenaar482aaeb2005-09-29 18:26:07 +00002791 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00002792 m = Columns * Rows;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002793 if (m < 0) // overflow, Columns or Rows at weird value
Bram Moolenaar482aaeb2005-09-29 18:26:07 +00002794 m = MAXCOL;
2795 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002796 else
2797 m = MAXCOL;
2798 for (i = 0; i < ccline.cmdlen && i < ccline.cmdpos; ++i)
2799 {
2800 c = cmdline_charsize(i);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002801 // Count ">" for double-wide multi-byte char that doesn't fit.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002802 if (has_mbyte)
2803 correct_cmdspos(i, c);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002804 // If the cmdline doesn't fit, show cursor on last visible char.
2805 // Don't move the cursor itself, so we can still append.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002806 if ((ccline.cmdspos += c) >= m)
2807 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00002808 ccline.cmdspos -= c;
2809 break;
2810 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002811 if (has_mbyte)
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00002812 i += (*mb_ptr2len)(ccline.cmdbuff + i) - 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002813 }
2814}
2815
Bram Moolenaar071d4272004-06-13 20:20:40 +00002816/*
2817 * Check if the character at "idx", which is "cells" wide, is a multi-byte
2818 * character that doesn't fit, so that a ">" must be displayed.
2819 */
2820 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01002821correct_cmdspos(int idx, int cells)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002822{
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00002823 if ((*mb_ptr2len)(ccline.cmdbuff + idx) > 1
Bram Moolenaar071d4272004-06-13 20:20:40 +00002824 && (*mb_ptr2cells)(ccline.cmdbuff + idx) > 1
2825 && ccline.cmdspos % Columns + cells > Columns)
2826 ccline.cmdspos++;
2827}
Bram Moolenaar071d4272004-06-13 20:20:40 +00002828
2829/*
2830 * Get an Ex command line for the ":" command.
2831 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002832 char_u *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01002833getexline(
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002834 int c, // normally ':', NUL for ":append"
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01002835 void *cookie UNUSED,
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002836 int indent, // indent for inside conditionals
Bram Moolenaar66250c92020-08-20 15:02:42 +02002837 getline_opt_T options)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002838{
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002839 // When executing a register, remove ':' that's in front of each line.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002840 if (exec_from_reg && vpeekc() == ':')
2841 (void)vgetc();
Bram Moolenaar66250c92020-08-20 15:02:42 +02002842 return getcmdline(c, 1L, indent, options);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002843}
2844
2845/*
2846 * Get an Ex command line for Ex mode.
2847 * In Ex mode we only use the OS supplied line editing features and no
2848 * mappings or abbreviations.
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002849 * Returns a string in allocated memory or NULL.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002850 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002851 char_u *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01002852getexmodeline(
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002853 int promptc, // normally ':', NUL for ":append" and '?' for
2854 // :s prompt
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01002855 void *cookie UNUSED,
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002856 int indent, // indent for inside conditionals
Bram Moolenaar66250c92020-08-20 15:02:42 +02002857 getline_opt_T options UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002858{
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002859 garray_T line_ga;
2860 char_u *pend;
2861 int startcol = 0;
Bram Moolenaar76624232007-07-28 12:21:47 +00002862 int c1 = 0;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002863 int escaped = FALSE; // CTRL-V typed
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002864 int vcol = 0;
2865 char_u *p;
Bram Moolenaar76624232007-07-28 12:21:47 +00002866 int prev_char;
Bram Moolenaar2d54ec92014-06-12 19:44:48 +02002867 int len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002868
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002869 // Switch cursor on now. This avoids that it happens after the "\n", which
2870 // confuses the system function that computes tabstops.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002871 cursor_on();
2872
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002873 // always start in column 0; write a newline if necessary
Bram Moolenaar071d4272004-06-13 20:20:40 +00002874 compute_cmdrow();
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002875 if ((msg_col || msg_didout) && promptc != '?')
Bram Moolenaar071d4272004-06-13 20:20:40 +00002876 msg_putchar('\n');
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002877 if (promptc == ':')
Bram Moolenaar071d4272004-06-13 20:20:40 +00002878 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002879 // indent that is only displayed, not in the line itself
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002880 if (p_prompt)
2881 msg_putchar(':');
Bram Moolenaar071d4272004-06-13 20:20:40 +00002882 while (indent-- > 0)
2883 msg_putchar(' ');
Bram Moolenaar071d4272004-06-13 20:20:40 +00002884 startcol = msg_col;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002885 }
2886
2887 ga_init2(&line_ga, 1, 30);
2888
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002889 // autoindent for :insert and :append is in the line itself
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002890 if (promptc <= 0)
Bram Moolenaar4399ef42005-02-12 14:29:27 +00002891 {
Bram Moolenaar4399ef42005-02-12 14:29:27 +00002892 vcol = indent;
Bram Moolenaar4399ef42005-02-12 14:29:27 +00002893 while (indent >= 8)
2894 {
2895 ga_append(&line_ga, TAB);
Bram Moolenaar32526b32019-01-19 17:43:09 +01002896 msg_puts(" ");
Bram Moolenaar4399ef42005-02-12 14:29:27 +00002897 indent -= 8;
2898 }
2899 while (indent-- > 0)
2900 {
2901 ga_append(&line_ga, ' ');
2902 msg_putchar(' ');
2903 }
2904 }
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002905 ++no_mapping;
2906 ++allow_keys;
Bram Moolenaar4399ef42005-02-12 14:29:27 +00002907
Bram Moolenaar071d4272004-06-13 20:20:40 +00002908 /*
2909 * Get the line, one character at a time.
2910 */
2911 got_int = FALSE;
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002912 while (!got_int)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002913 {
Bram Moolenaarda636572015-04-03 17:11:45 +02002914 long sw;
2915 char_u *s;
2916
Bram Moolenaar071d4272004-06-13 20:20:40 +00002917 if (ga_grow(&line_ga, 40) == FAIL)
2918 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002919
Bram Moolenaarba748c82017-02-26 14:00:07 +01002920 /*
2921 * Get one character at a time.
2922 */
Bram Moolenaar76624232007-07-28 12:21:47 +00002923 prev_char = c1;
Bram Moolenaarba748c82017-02-26 14:00:07 +01002924
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002925 // Check for a ":normal" command and no more characters left.
Bram Moolenaarba748c82017-02-26 14:00:07 +01002926 if (ex_normal_busy > 0 && typebuf.tb_len == 0)
2927 c1 = '\n';
2928 else
2929 c1 = vgetc();
Bram Moolenaar071d4272004-06-13 20:20:40 +00002930
2931 /*
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002932 * Handle line editing.
2933 * Previously this was left to the system, putting the terminal in
2934 * cooked mode, but then CTRL-D and CTRL-T can't be used properly.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002935 */
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002936 if (got_int)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002937 {
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002938 msg_putchar('\n');
2939 break;
2940 }
2941
Bram Moolenaarabbc4482017-01-24 15:57:55 +01002942 if (c1 == K_PS)
2943 {
2944 bracketed_paste(PASTE_EX, FALSE, &line_ga);
2945 goto redraw;
2946 }
2947
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002948 if (!escaped)
2949 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002950 // CR typed means "enter", which is NL
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002951 if (c1 == '\r')
2952 c1 = '\n';
2953
2954 if (c1 == BS || c1 == K_BS
2955 || c1 == DEL || c1 == K_DEL || c1 == K_KDEL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002956 {
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002957 if (line_ga.ga_len > 0)
2958 {
Bram Moolenaar2d54ec92014-06-12 19:44:48 +02002959 if (has_mbyte)
2960 {
2961 p = (char_u *)line_ga.ga_data;
2962 p[line_ga.ga_len] = NUL;
2963 len = (*mb_head_off)(p, p + line_ga.ga_len - 1) + 1;
2964 line_ga.ga_len -= len;
2965 }
2966 else
Bram Moolenaar2d54ec92014-06-12 19:44:48 +02002967 --line_ga.ga_len;
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002968 goto redraw;
2969 }
2970 continue;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002971 }
2972
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002973 if (c1 == Ctrl_U)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002974 {
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002975 msg_col = startcol;
2976 msg_clr_eos();
2977 line_ga.ga_len = 0;
Bram Moolenaarda636572015-04-03 17:11:45 +02002978 goto redraw;
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002979 }
2980
2981 if (c1 == Ctrl_T)
2982 {
Bram Moolenaarda636572015-04-03 17:11:45 +02002983 sw = get_sw_value(curbuf);
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002984 p = (char_u *)line_ga.ga_data;
2985 p[line_ga.ga_len] = NUL;
Bram Moolenaar597a4222014-06-25 14:39:50 +02002986 indent = get_indent_str(p, 8, FALSE);
Bram Moolenaar14f24742012-08-08 18:01:05 +02002987 indent += sw - indent % sw;
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002988add_indent:
Bram Moolenaar597a4222014-06-25 14:39:50 +02002989 while (get_indent_str(p, 8, FALSE) < indent)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002990 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002991 (void)ga_grow(&line_ga, 2); // one more for the NUL
Bram Moolenaarda636572015-04-03 17:11:45 +02002992 p = (char_u *)line_ga.ga_data;
2993 s = skipwhite(p);
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002994 mch_memmove(s + 1, s, line_ga.ga_len - (s - p) + 1);
2995 *s = ' ';
2996 ++line_ga.ga_len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002997 }
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002998redraw:
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002999 // redraw the line
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003000 msg_col = startcol;
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003001 vcol = 0;
Bram Moolenaar2d54ec92014-06-12 19:44:48 +02003002 p = (char_u *)line_ga.ga_data;
3003 p[line_ga.ga_len] = NUL;
3004 while (p < (char_u *)line_ga.ga_data + line_ga.ga_len)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003005 {
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003006 if (*p == TAB)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003007 {
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003008 do
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003009 msg_putchar(' ');
Bram Moolenaarabab0b02019-03-30 18:47:01 +01003010 while (++vcol % 8);
Bram Moolenaar2d54ec92014-06-12 19:44:48 +02003011 ++p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003012 }
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003013 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00003014 {
Bram Moolenaar1614a142019-10-06 22:00:13 +02003015 len = mb_ptr2len(p);
Bram Moolenaar2d54ec92014-06-12 19:44:48 +02003016 msg_outtrans_len(p, len);
3017 vcol += ptr2cells(p);
3018 p += len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003019 }
3020 }
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003021 msg_clr_eos();
Bram Moolenaar76624232007-07-28 12:21:47 +00003022 windgoto(msg_row, msg_col);
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003023 continue;
3024 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003025
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003026 if (c1 == Ctrl_D)
3027 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003028 // Delete one shiftwidth.
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003029 p = (char_u *)line_ga.ga_data;
3030 if (prev_char == '0' || prev_char == '^')
Bram Moolenaar071d4272004-06-13 20:20:40 +00003031 {
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003032 if (prev_char == '^')
3033 ex_keep_indent = TRUE;
3034 indent = 0;
3035 p[--line_ga.ga_len] = NUL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003036 }
3037 else
3038 {
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003039 p[line_ga.ga_len] = NUL;
Bram Moolenaar597a4222014-06-25 14:39:50 +02003040 indent = get_indent_str(p, 8, FALSE);
Bram Moolenaarda636572015-04-03 17:11:45 +02003041 if (indent > 0)
3042 {
3043 --indent;
3044 indent -= indent % get_sw_value(curbuf);
3045 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003046 }
Bram Moolenaar597a4222014-06-25 14:39:50 +02003047 while (get_indent_str(p, 8, FALSE) > indent)
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003048 {
Bram Moolenaarda636572015-04-03 17:11:45 +02003049 s = skipwhite(p);
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003050 mch_memmove(s - 1, s, line_ga.ga_len - (s - p) + 1);
3051 --line_ga.ga_len;
3052 }
3053 goto add_indent;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003054 }
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003055
3056 if (c1 == Ctrl_V || c1 == Ctrl_Q)
3057 {
3058 escaped = TRUE;
3059 continue;
3060 }
3061
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003062 // Ignore special key codes: mouse movement, K_IGNORE, etc.
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003063 if (IS_SPECIAL(c1))
3064 continue;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003065 }
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003066
3067 if (IS_SPECIAL(c1))
3068 c1 = '?';
Bram Moolenaar2d54ec92014-06-12 19:44:48 +02003069 if (has_mbyte)
3070 len = (*mb_char2bytes)(c1,
3071 (char_u *)line_ga.ga_data + line_ga.ga_len);
3072 else
Bram Moolenaar2d54ec92014-06-12 19:44:48 +02003073 {
3074 len = 1;
3075 ((char_u *)line_ga.ga_data)[line_ga.ga_len] = c1;
3076 }
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003077 if (c1 == '\n')
3078 msg_putchar('\n');
3079 else if (c1 == TAB)
3080 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003081 // Don't use chartabsize(), 'ts' can be different
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003082 do
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003083 msg_putchar(' ');
Bram Moolenaarabab0b02019-03-30 18:47:01 +01003084 while (++vcol % 8);
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003085 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003086 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00003087 {
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003088 msg_outtrans_len(
Bram Moolenaar2d54ec92014-06-12 19:44:48 +02003089 ((char_u *)line_ga.ga_data) + line_ga.ga_len, len);
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003090 vcol += char2cells(c1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003091 }
Bram Moolenaar2d54ec92014-06-12 19:44:48 +02003092 line_ga.ga_len += len;
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003093 escaped = FALSE;
3094
3095 windgoto(msg_row, msg_col);
Bram Moolenaar4399ef42005-02-12 14:29:27 +00003096 pend = (char_u *)(line_ga.ga_data) + line_ga.ga_len;
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003097
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003098 // We are done when a NL is entered, but not when it comes after an
3099 // odd number of backslashes, that results in a NUL.
Bram Moolenaar417f5e72010-09-29 15:50:30 +02003100 if (line_ga.ga_len > 0 && pend[-1] == '\n')
Bram Moolenaar071d4272004-06-13 20:20:40 +00003101 {
Bram Moolenaar417f5e72010-09-29 15:50:30 +02003102 int bcount = 0;
3103
3104 while (line_ga.ga_len - 2 >= bcount && pend[-2 - bcount] == '\\')
3105 ++bcount;
3106
3107 if (bcount > 0)
3108 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003109 // Halve the number of backslashes: "\NL" -> "NUL", "\\NL" ->
3110 // "\NL", etc.
Bram Moolenaar417f5e72010-09-29 15:50:30 +02003111 line_ga.ga_len -= (bcount + 1) / 2;
3112 pend -= (bcount + 1) / 2;
3113 pend[-1] = '\n';
3114 }
3115
3116 if ((bcount & 1) == 0)
3117 {
3118 --line_ga.ga_len;
3119 --pend;
3120 *pend = NUL;
3121 break;
3122 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003123 }
3124 }
3125
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003126 --no_mapping;
3127 --allow_keys;
3128
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003129 // make following messages go to the next line
Bram Moolenaar071d4272004-06-13 20:20:40 +00003130 msg_didout = FALSE;
3131 msg_col = 0;
3132 if (msg_row < Rows - 1)
3133 ++msg_row;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003134 emsg_on_display = FALSE; // don't want ui_delay()
Bram Moolenaar071d4272004-06-13 20:20:40 +00003135
3136 if (got_int)
3137 ga_clear(&line_ga);
3138
3139 return (char_u *)line_ga.ga_data;
3140}
3141
Bram Moolenaare344bea2005-09-01 20:46:49 +00003142# if defined(MCH_CURSOR_SHAPE) || defined(FEAT_GUI) \
3143 || defined(FEAT_MOUSESHAPE) || defined(PROTO)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003144/*
3145 * Return TRUE if ccline.overstrike is on.
3146 */
3147 int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01003148cmdline_overstrike(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003149{
3150 return ccline.overstrike;
3151}
3152
3153/*
3154 * Return TRUE if the cursor is at the end of the cmdline.
3155 */
3156 int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01003157cmdline_at_end(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003158{
3159 return (ccline.cmdpos >= ccline.cmdlen);
3160}
3161#endif
3162
Bram Moolenaar9372a112005-12-06 19:59:18 +00003163#if (defined(FEAT_XIM) && (defined(FEAT_GUI_GTK))) || defined(PROTO)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003164/*
3165 * Return the virtual column number at the current cursor position.
3166 * This is used by the IM code to obtain the start of the preedit string.
3167 */
3168 colnr_T
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01003169cmdline_getvcol_cursor(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003170{
3171 if (ccline.cmdbuff == NULL || ccline.cmdpos > ccline.cmdlen)
3172 return MAXCOL;
3173
Bram Moolenaar071d4272004-06-13 20:20:40 +00003174 if (has_mbyte)
3175 {
3176 colnr_T col;
3177 int i = 0;
3178
3179 for (col = 0; i < ccline.cmdpos; ++col)
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00003180 i += (*mb_ptr2len)(ccline.cmdbuff + i);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003181
3182 return col;
3183 }
3184 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00003185 return ccline.cmdpos;
3186}
3187#endif
3188
3189#if defined(FEAT_XIM) && defined(FEAT_GUI_GTK)
3190/*
3191 * If part of the command line is an IM preedit string, redraw it with
3192 * IM feedback attributes. The cursor position is restored after drawing.
3193 */
3194 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01003195redrawcmd_preedit(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003196{
Bram Moolenaar24959102022-05-07 20:01:16 +01003197 if ((State & MODE_CMDLINE)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003198 && xic != NULL
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003199 // && im_get_status() doesn't work when using SCIM
Bram Moolenaar071d4272004-06-13 20:20:40 +00003200 && !p_imdisable
3201 && im_is_preediting())
3202 {
3203 int cmdpos = 0;
3204 int cmdspos;
3205 int old_row;
3206 int old_col;
3207 colnr_T col;
3208
3209 old_row = msg_row;
3210 old_col = msg_col;
Bram Moolenaarbfd8fc02005-09-20 23:22:24 +00003211 cmdspos = ((ccline.cmdfirstc != NUL) ? 1 : 0) + ccline.cmdindent;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003212
Bram Moolenaar071d4272004-06-13 20:20:40 +00003213 if (has_mbyte)
3214 {
3215 for (col = 0; col < preedit_start_col
3216 && cmdpos < ccline.cmdlen; ++col)
3217 {
3218 cmdspos += (*mb_ptr2cells)(ccline.cmdbuff + cmdpos);
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00003219 cmdpos += (*mb_ptr2len)(ccline.cmdbuff + cmdpos);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003220 }
3221 }
3222 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00003223 {
3224 cmdspos += preedit_start_col;
3225 cmdpos += preedit_start_col;
3226 }
3227
3228 msg_row = cmdline_row + (cmdspos / (int)Columns);
3229 msg_col = cmdspos % (int)Columns;
3230 if (msg_row >= Rows)
3231 msg_row = Rows - 1;
3232
3233 for (col = 0; cmdpos < ccline.cmdlen; ++col)
3234 {
3235 int char_len;
3236 int char_attr;
3237
3238 char_attr = im_get_feedback_attr(col);
3239 if (char_attr < 0)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003240 break; // end of preedit string
Bram Moolenaar071d4272004-06-13 20:20:40 +00003241
Bram Moolenaar071d4272004-06-13 20:20:40 +00003242 if (has_mbyte)
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00003243 char_len = (*mb_ptr2len)(ccline.cmdbuff + cmdpos);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003244 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00003245 char_len = 1;
3246
3247 msg_outtrans_len_attr(ccline.cmdbuff + cmdpos, char_len, char_attr);
3248 cmdpos += char_len;
3249 }
3250
3251 msg_row = old_row;
3252 msg_col = old_col;
3253 }
3254}
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003255#endif // FEAT_XIM && FEAT_GUI_GTK
Bram Moolenaar071d4272004-06-13 20:20:40 +00003256
3257/*
3258 * Allocate a new command line buffer.
3259 * Assigns the new buffer to ccline.cmdbuff and ccline.cmdbufflen.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003260 */
3261 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01003262alloc_cmdbuff(int len)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003263{
3264 /*
3265 * give some extra space to avoid having to allocate all the time
3266 */
3267 if (len < 80)
3268 len = 100;
3269 else
3270 len += 20;
3271
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003272 ccline.cmdbuff = alloc(len); // caller should check for out-of-memory
Bram Moolenaar071d4272004-06-13 20:20:40 +00003273 ccline.cmdbufflen = len;
3274}
3275
3276/*
3277 * Re-allocate the command line to length len + something extra.
3278 * return FAIL for failure, OK otherwise
3279 */
Bram Moolenaar66b51422019-08-18 21:44:12 +02003280 int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01003281realloc_cmdbuff(int len)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003282{
3283 char_u *p;
3284
Bram Moolenaar673b87b2010-08-13 19:12:07 +02003285 if (len < ccline.cmdbufflen)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003286 return OK; // no need to resize
Bram Moolenaar673b87b2010-08-13 19:12:07 +02003287
Bram Moolenaar071d4272004-06-13 20:20:40 +00003288 p = ccline.cmdbuff;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003289 alloc_cmdbuff(len); // will get some more
3290 if (ccline.cmdbuff == NULL) // out of memory
Bram Moolenaar071d4272004-06-13 20:20:40 +00003291 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003292 ccline.cmdbuff = p; // keep the old one
Bram Moolenaar071d4272004-06-13 20:20:40 +00003293 return FAIL;
3294 }
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003295 // There isn't always a NUL after the command, but it may need to be
3296 // there, thus copy up to the NUL and add a NUL.
Bram Moolenaar35a34232010-08-13 16:51:26 +02003297 mch_memmove(ccline.cmdbuff, p, (size_t)ccline.cmdlen);
3298 ccline.cmdbuff[ccline.cmdlen] = NUL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003299 vim_free(p);
Bram Moolenaard6e7cc62008-09-14 12:42:29 +00003300
3301 if (ccline.xpc != NULL
3302 && ccline.xpc->xp_pattern != NULL
3303 && ccline.xpc->xp_context != EXPAND_NOTHING
3304 && ccline.xpc->xp_context != EXPAND_UNSUCCESSFUL)
3305 {
Bram Moolenaarbb5ddda2008-11-28 10:01:10 +00003306 int i = (int)(ccline.xpc->xp_pattern - p);
Bram Moolenaard6e7cc62008-09-14 12:42:29 +00003307
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003308 // If xp_pattern points inside the old cmdbuff it needs to be adjusted
3309 // to point into the newly allocated memory.
Bram Moolenaard6e7cc62008-09-14 12:42:29 +00003310 if (i >= 0 && i <= ccline.cmdlen)
3311 ccline.xpc->xp_pattern = ccline.cmdbuff + i;
3312 }
3313
Bram Moolenaar071d4272004-06-13 20:20:40 +00003314 return OK;
3315}
3316
Bram Moolenaarf461c8e2005-06-25 23:04:51 +00003317#if defined(FEAT_ARABIC) || defined(PROTO)
3318static char_u *arshape_buf = NULL;
3319
3320# if defined(EXITFREE) || defined(PROTO)
3321 void
Bram Moolenaar48ac6712019-07-04 20:26:21 +02003322free_arshape_buf(void)
Bram Moolenaarf461c8e2005-06-25 23:04:51 +00003323{
3324 vim_free(arshape_buf);
3325}
3326# endif
3327#endif
3328
Bram Moolenaar071d4272004-06-13 20:20:40 +00003329/*
3330 * Draw part of the cmdline at the current cursor position. But draw stars
3331 * when cmdline_star is TRUE.
3332 */
3333 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01003334draw_cmdline(int start, int len)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003335{
3336#if defined(FEAT_CRYPT) || defined(FEAT_EVAL)
3337 int i;
3338
3339 if (cmdline_star > 0)
3340 for (i = 0; i < len; ++i)
3341 {
3342 msg_putchar('*');
Bram Moolenaar071d4272004-06-13 20:20:40 +00003343 if (has_mbyte)
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00003344 i += (*mb_ptr2len)(ccline.cmdbuff + start + i) - 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003345 }
3346 else
3347#endif
3348#ifdef FEAT_ARABIC
Bram Moolenaar693f7dc2019-06-21 02:30:38 +02003349 if (p_arshape && !p_tbidi && cmdline_has_arabic(start, len))
Bram Moolenaar071d4272004-06-13 20:20:40 +00003350 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00003351 static int buflen = 0;
3352 char_u *p;
3353 int j;
3354 int newlen = 0;
3355 int mb_l;
Bram Moolenaar4ea8fe12006-03-09 22:32:39 +00003356 int pc, pc1 = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003357 int prev_c = 0;
3358 int prev_c1 = 0;
Bram Moolenaar362e1a32006-03-06 23:29:24 +00003359 int u8c;
3360 int u8cc[MAX_MCO];
Bram Moolenaar071d4272004-06-13 20:20:40 +00003361 int nc = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003362
3363 /*
3364 * Do arabic shaping into a temporary buffer. This is very
3365 * inefficient!
3366 */
Bram Moolenaarcafda4f2005-09-06 19:25:11 +00003367 if (len * 2 + 2 > buflen)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003368 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003369 // Re-allocate the buffer. We keep it around to avoid a lot of
3370 // alloc()/free() calls.
Bram Moolenaarf461c8e2005-06-25 23:04:51 +00003371 vim_free(arshape_buf);
Bram Moolenaarcafda4f2005-09-06 19:25:11 +00003372 buflen = len * 2 + 2;
Bram Moolenaarf461c8e2005-06-25 23:04:51 +00003373 arshape_buf = alloc(buflen);
3374 if (arshape_buf == NULL)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003375 return; // out of memory
Bram Moolenaar071d4272004-06-13 20:20:40 +00003376 }
3377
Bram Moolenaarcafda4f2005-09-06 19:25:11 +00003378 if (utf_iscomposing(utf_ptr2char(ccline.cmdbuff + start)))
3379 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003380 // Prepend a space to draw the leading composing char on.
Bram Moolenaarcafda4f2005-09-06 19:25:11 +00003381 arshape_buf[0] = ' ';
3382 newlen = 1;
3383 }
3384
Bram Moolenaar071d4272004-06-13 20:20:40 +00003385 for (j = start; j < start + len; j += mb_l)
3386 {
3387 p = ccline.cmdbuff + j;
Bram Moolenaar362e1a32006-03-06 23:29:24 +00003388 u8c = utfc_ptr2char_len(p, u8cc, start + len - j);
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00003389 mb_l = utfc_ptr2len_len(p, start + len - j);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003390 if (ARABIC_CHAR(u8c))
3391 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003392 // Do Arabic shaping.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003393 if (cmdmsg_rl)
3394 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003395 // displaying from right to left
Bram Moolenaar071d4272004-06-13 20:20:40 +00003396 pc = prev_c;
3397 pc1 = prev_c1;
Bram Moolenaar362e1a32006-03-06 23:29:24 +00003398 prev_c1 = u8cc[0];
Bram Moolenaar071d4272004-06-13 20:20:40 +00003399 if (j + mb_l >= start + len)
3400 nc = NUL;
3401 else
3402 nc = utf_ptr2char(p + mb_l);
3403 }
3404 else
3405 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003406 // displaying from left to right
Bram Moolenaar071d4272004-06-13 20:20:40 +00003407 if (j + mb_l >= start + len)
3408 pc = NUL;
3409 else
Bram Moolenaar362e1a32006-03-06 23:29:24 +00003410 {
3411 int pcc[MAX_MCO];
3412
3413 pc = utfc_ptr2char_len(p + mb_l, pcc,
Bram Moolenaar071d4272004-06-13 20:20:40 +00003414 start + len - j - mb_l);
Bram Moolenaar362e1a32006-03-06 23:29:24 +00003415 pc1 = pcc[0];
3416 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003417 nc = prev_c;
3418 }
3419 prev_c = u8c;
3420
Bram Moolenaar362e1a32006-03-06 23:29:24 +00003421 u8c = arabic_shape(u8c, NULL, &u8cc[0], pc, pc1, nc);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003422
Bram Moolenaarf461c8e2005-06-25 23:04:51 +00003423 newlen += (*mb_char2bytes)(u8c, arshape_buf + newlen);
Bram Moolenaar362e1a32006-03-06 23:29:24 +00003424 if (u8cc[0] != 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003425 {
Bram Moolenaar362e1a32006-03-06 23:29:24 +00003426 newlen += (*mb_char2bytes)(u8cc[0], arshape_buf + newlen);
3427 if (u8cc[1] != 0)
3428 newlen += (*mb_char2bytes)(u8cc[1],
Bram Moolenaarf461c8e2005-06-25 23:04:51 +00003429 arshape_buf + newlen);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003430 }
3431 }
3432 else
3433 {
3434 prev_c = u8c;
Bram Moolenaarf461c8e2005-06-25 23:04:51 +00003435 mch_memmove(arshape_buf + newlen, p, mb_l);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003436 newlen += mb_l;
3437 }
3438 }
3439
Bram Moolenaarf461c8e2005-06-25 23:04:51 +00003440 msg_outtrans_len(arshape_buf, newlen);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003441 }
3442 else
3443#endif
3444 msg_outtrans_len(ccline.cmdbuff + start, len);
3445}
3446
3447/*
3448 * Put a character on the command line. Shifts the following text to the
3449 * right when "shift" is TRUE. Used for CTRL-V, CTRL-K, etc.
3450 * "c" must be printable (fit in one display cell)!
3451 */
3452 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01003453putcmdline(int c, int shift)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003454{
3455 if (cmd_silent)
3456 return;
3457 msg_no_more = TRUE;
3458 msg_putchar(c);
3459 if (shift)
3460 draw_cmdline(ccline.cmdpos, ccline.cmdlen - ccline.cmdpos);
3461 msg_no_more = FALSE;
3462 cursorcmd();
Bram Moolenaar6a77d262017-07-16 15:24:01 +02003463 extra_char = c;
3464 extra_char_shift = shift;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003465}
3466
3467/*
3468 * Undo a putcmdline(c, FALSE).
3469 */
3470 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01003471unputcmdline(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003472{
3473 if (cmd_silent)
3474 return;
3475 msg_no_more = TRUE;
3476 if (ccline.cmdlen == ccline.cmdpos)
3477 msg_putchar(' ');
Bram Moolenaar64fdf5c2012-06-06 12:03:06 +02003478 else if (has_mbyte)
3479 draw_cmdline(ccline.cmdpos,
3480 (*mb_ptr2len)(ccline.cmdbuff + ccline.cmdpos));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003481 else
3482 draw_cmdline(ccline.cmdpos, 1);
3483 msg_no_more = FALSE;
3484 cursorcmd();
Bram Moolenaar6a77d262017-07-16 15:24:01 +02003485 extra_char = NUL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003486}
3487
3488/*
3489 * Put the given string, of the given length, onto the command line.
3490 * If len is -1, then STRLEN() is used to calculate the length.
3491 * If 'redraw' is TRUE then the new part of the command line, and the remaining
3492 * part will be redrawn, otherwise it will not. If this function is called
3493 * twice in a row, then 'redraw' should be FALSE and redrawcmd() should be
3494 * called afterwards.
3495 */
3496 int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01003497put_on_cmdline(char_u *str, int len, int redraw)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003498{
3499 int retval;
3500 int i;
3501 int m;
3502 int c;
3503
3504 if (len < 0)
3505 len = (int)STRLEN(str);
3506
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003507 // Check if ccline.cmdbuff needs to be longer
Bram Moolenaar071d4272004-06-13 20:20:40 +00003508 if (ccline.cmdlen + len + 1 >= ccline.cmdbufflen)
Bram Moolenaar673b87b2010-08-13 19:12:07 +02003509 retval = realloc_cmdbuff(ccline.cmdlen + len + 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003510 else
3511 retval = OK;
3512 if (retval == OK)
3513 {
3514 if (!ccline.overstrike)
3515 {
3516 mch_memmove(ccline.cmdbuff + ccline.cmdpos + len,
3517 ccline.cmdbuff + ccline.cmdpos,
3518 (size_t)(ccline.cmdlen - ccline.cmdpos));
3519 ccline.cmdlen += len;
3520 }
3521 else
3522 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00003523 if (has_mbyte)
3524 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003525 // Count nr of characters in the new string.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003526 m = 0;
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00003527 for (i = 0; i < len; i += (*mb_ptr2len)(str + i))
Bram Moolenaar071d4272004-06-13 20:20:40 +00003528 ++m;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003529 // Count nr of bytes in cmdline that are overwritten by these
3530 // characters.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003531 for (i = ccline.cmdpos; i < ccline.cmdlen && m > 0;
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00003532 i += (*mb_ptr2len)(ccline.cmdbuff + i))
Bram Moolenaar071d4272004-06-13 20:20:40 +00003533 --m;
3534 if (i < ccline.cmdlen)
3535 {
3536 mch_memmove(ccline.cmdbuff + ccline.cmdpos + len,
3537 ccline.cmdbuff + i, (size_t)(ccline.cmdlen - i));
3538 ccline.cmdlen += ccline.cmdpos + len - i;
3539 }
3540 else
3541 ccline.cmdlen = ccline.cmdpos + len;
3542 }
Bram Moolenaar13505972019-01-24 15:04:48 +01003543 else if (ccline.cmdpos + len > ccline.cmdlen)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003544 ccline.cmdlen = ccline.cmdpos + len;
3545 }
3546 mch_memmove(ccline.cmdbuff + ccline.cmdpos, str, (size_t)len);
3547 ccline.cmdbuff[ccline.cmdlen] = NUL;
3548
Bram Moolenaar071d4272004-06-13 20:20:40 +00003549 if (enc_utf8)
3550 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003551 // When the inserted text starts with a composing character,
3552 // backup to the character before it. There could be two of them.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003553 i = 0;
3554 c = utf_ptr2char(ccline.cmdbuff + ccline.cmdpos);
3555 while (ccline.cmdpos > 0 && utf_iscomposing(c))
3556 {
3557 i = (*mb_head_off)(ccline.cmdbuff,
3558 ccline.cmdbuff + ccline.cmdpos - 1) + 1;
3559 ccline.cmdpos -= i;
3560 len += i;
3561 c = utf_ptr2char(ccline.cmdbuff + ccline.cmdpos);
3562 }
Bram Moolenaar13505972019-01-24 15:04:48 +01003563#ifdef FEAT_ARABIC
Bram Moolenaar071d4272004-06-13 20:20:40 +00003564 if (i == 0 && ccline.cmdpos > 0 && arabic_maycombine(c))
3565 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003566 // Check the previous character for Arabic combining pair.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003567 i = (*mb_head_off)(ccline.cmdbuff,
3568 ccline.cmdbuff + ccline.cmdpos - 1) + 1;
3569 if (arabic_combine(utf_ptr2char(ccline.cmdbuff
3570 + ccline.cmdpos - i), c))
3571 {
3572 ccline.cmdpos -= i;
3573 len += i;
3574 }
3575 else
3576 i = 0;
3577 }
Bram Moolenaar13505972019-01-24 15:04:48 +01003578#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003579 if (i != 0)
3580 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003581 // Also backup the cursor position.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003582 i = ptr2cells(ccline.cmdbuff + ccline.cmdpos);
3583 ccline.cmdspos -= i;
3584 msg_col -= i;
3585 if (msg_col < 0)
3586 {
3587 msg_col += Columns;
3588 --msg_row;
3589 }
3590 }
3591 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003592
3593 if (redraw && !cmd_silent)
3594 {
3595 msg_no_more = TRUE;
3596 i = cmdline_row;
Bram Moolenaar73dc59a2011-09-30 17:46:21 +02003597 cursorcmd();
Bram Moolenaar071d4272004-06-13 20:20:40 +00003598 draw_cmdline(ccline.cmdpos, ccline.cmdlen - ccline.cmdpos);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003599 // Avoid clearing the rest of the line too often.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003600 if (cmdline_row != i || ccline.overstrike)
3601 msg_clr_eos();
3602 msg_no_more = FALSE;
3603 }
Bram Moolenaar14184a32019-02-16 15:10:30 +01003604 if (KeyTyped)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003605 {
Bram Moolenaar14184a32019-02-16 15:10:30 +01003606 m = Columns * Rows;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003607 if (m < 0) // overflow, Columns or Rows at weird value
Bram Moolenaar071d4272004-06-13 20:20:40 +00003608 m = MAXCOL;
Bram Moolenaar14184a32019-02-16 15:10:30 +01003609 }
3610 else
3611 m = MAXCOL;
3612 for (i = 0; i < len; ++i)
3613 {
3614 c = cmdline_charsize(ccline.cmdpos);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003615 // count ">" for a double-wide char that doesn't fit.
Bram Moolenaar14184a32019-02-16 15:10:30 +01003616 if (has_mbyte)
3617 correct_cmdspos(ccline.cmdpos, c);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003618 // Stop cursor at the end of the screen, but do increment the
3619 // insert position, so that entering a very long command
3620 // works, even though you can't see it.
Bram Moolenaar14184a32019-02-16 15:10:30 +01003621 if (ccline.cmdspos + c < m)
3622 ccline.cmdspos += c;
Bram Moolenaar13505972019-01-24 15:04:48 +01003623
Bram Moolenaar14184a32019-02-16 15:10:30 +01003624 if (has_mbyte)
3625 {
3626 c = (*mb_ptr2len)(ccline.cmdbuff + ccline.cmdpos) - 1;
3627 if (c > len - i - 1)
3628 c = len - i - 1;
3629 ccline.cmdpos += c;
3630 i += c;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003631 }
Bram Moolenaar14184a32019-02-16 15:10:30 +01003632 ++ccline.cmdpos;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003633 }
3634 }
3635 if (redraw)
3636 msg_check();
3637 return retval;
3638}
3639
Bram Moolenaar66b51422019-08-18 21:44:12 +02003640static cmdline_info_T prev_ccline;
3641static int prev_ccline_used = FALSE;
Bram Moolenaar5f2bb9f2005-01-11 21:29:04 +00003642
3643/*
3644 * Save ccline, because obtaining the "=" register may execute "normal :cmd"
3645 * and overwrite it. But get_cmdline_str() may need it, thus make it
3646 * available globally in prev_ccline.
3647 */
3648 static void
Bram Moolenaar66b51422019-08-18 21:44:12 +02003649save_cmdline(cmdline_info_T *ccp)
Bram Moolenaar5f2bb9f2005-01-11 21:29:04 +00003650{
3651 if (!prev_ccline_used)
3652 {
Bram Moolenaara80faa82020-04-12 19:37:17 +02003653 CLEAR_FIELD(prev_ccline);
Bram Moolenaar5f2bb9f2005-01-11 21:29:04 +00003654 prev_ccline_used = TRUE;
3655 }
3656 *ccp = prev_ccline;
3657 prev_ccline = ccline;
Bram Moolenaar438d1762018-09-30 17:11:48 +02003658 ccline.cmdbuff = NULL; // signal that ccline is not in use
Bram Moolenaar5f2bb9f2005-01-11 21:29:04 +00003659}
3660
3661/*
Bram Moolenaarccc18222007-05-10 18:25:20 +00003662 * Restore ccline after it has been saved with save_cmdline().
Bram Moolenaar5f2bb9f2005-01-11 21:29:04 +00003663 */
3664 static void
Bram Moolenaar66b51422019-08-18 21:44:12 +02003665restore_cmdline(cmdline_info_T *ccp)
Bram Moolenaar5f2bb9f2005-01-11 21:29:04 +00003666{
3667 ccline = prev_ccline;
3668 prev_ccline = *ccp;
3669}
3670
Bram Moolenaar8299df92004-07-10 09:47:34 +00003671/*
Bram Moolenaar6f62fed2015-12-17 14:04:24 +01003672 * Paste a yank register into the command line.
3673 * Used by CTRL-R command in command-line mode.
Bram Moolenaar8299df92004-07-10 09:47:34 +00003674 * insert_reg() can't be used here, because special characters from the
3675 * register contents will be interpreted as commands.
3676 *
Bram Moolenaar6f62fed2015-12-17 14:04:24 +01003677 * Return FAIL for failure, OK otherwise.
Bram Moolenaar8299df92004-07-10 09:47:34 +00003678 */
3679 static int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01003680cmdline_paste(
3681 int regname,
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003682 int literally, // Insert text literally instead of "as typed"
3683 int remcr) // remove trailing CR
Bram Moolenaar8299df92004-07-10 09:47:34 +00003684{
3685 long i;
3686 char_u *arg;
Bram Moolenaarefd2bf12006-03-16 21:41:35 +00003687 char_u *p;
Bram Moolenaar8299df92004-07-10 09:47:34 +00003688 int allocated;
Bram Moolenaar8299df92004-07-10 09:47:34 +00003689
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003690 // check for valid regname; also accept special characters for CTRL-R in
3691 // the command line
Bram Moolenaar8299df92004-07-10 09:47:34 +00003692 if (regname != Ctrl_F && regname != Ctrl_P && regname != Ctrl_W
Bram Moolenaare2c8d832018-05-01 19:24:03 +02003693 && regname != Ctrl_A && regname != Ctrl_L
3694 && !valid_yank_reg(regname, FALSE))
Bram Moolenaar8299df92004-07-10 09:47:34 +00003695 return FAIL;
3696
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003697 // A register containing CTRL-R can cause an endless loop. Allow using
3698 // CTRL-C to break the loop.
Bram Moolenaar8299df92004-07-10 09:47:34 +00003699 line_breakcheck();
3700 if (got_int)
3701 return FAIL;
3702
3703#ifdef FEAT_CLIPBOARD
3704 regname = may_get_selection(regname);
3705#endif
3706
zeertzjqcfe45652022-05-27 17:26:55 +01003707 // Need to set "textlock" to avoid nasty things like going to another
Bram Moolenaar438d1762018-09-30 17:11:48 +02003708 // buffer when evaluating an expression.
zeertzjqcfe45652022-05-27 17:26:55 +01003709 ++textlock;
Bram Moolenaar8299df92004-07-10 09:47:34 +00003710 i = get_spec_reg(regname, &arg, &allocated, TRUE);
zeertzjqcfe45652022-05-27 17:26:55 +01003711 --textlock;
Bram Moolenaar8299df92004-07-10 09:47:34 +00003712
3713 if (i)
3714 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003715 // Got the value of a special register in "arg".
Bram Moolenaar8299df92004-07-10 09:47:34 +00003716 if (arg == NULL)
3717 return FAIL;
Bram Moolenaarefd2bf12006-03-16 21:41:35 +00003718
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003719 // When 'incsearch' is set and CTRL-R CTRL-W used: skip the duplicate
3720 // part of the word.
Bram Moolenaarefd2bf12006-03-16 21:41:35 +00003721 p = arg;
3722 if (p_is && regname == Ctrl_W)
3723 {
3724 char_u *w;
3725 int len;
3726
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003727 // Locate start of last word in the cmd buffer.
Bram Moolenaar80ae7b22011-07-07 16:44:37 +02003728 for (w = ccline.cmdbuff + ccline.cmdpos; w > ccline.cmdbuff; )
Bram Moolenaarefd2bf12006-03-16 21:41:35 +00003729 {
Bram Moolenaarefd2bf12006-03-16 21:41:35 +00003730 if (has_mbyte)
3731 {
3732 len = (*mb_head_off)(ccline.cmdbuff, w - 1) + 1;
3733 if (!vim_iswordc(mb_ptr2char(w - len)))
3734 break;
3735 w -= len;
3736 }
3737 else
Bram Moolenaarefd2bf12006-03-16 21:41:35 +00003738 {
3739 if (!vim_iswordc(w[-1]))
3740 break;
3741 --w;
3742 }
3743 }
Bram Moolenaar80ae7b22011-07-07 16:44:37 +02003744 len = (int)((ccline.cmdbuff + ccline.cmdpos) - w);
Bram Moolenaarefd2bf12006-03-16 21:41:35 +00003745 if (p_ic ? STRNICMP(w, arg, len) == 0 : STRNCMP(w, arg, len) == 0)
3746 p += len;
3747 }
3748
3749 cmdline_paste_str(p, literally);
Bram Moolenaar8299df92004-07-10 09:47:34 +00003750 if (allocated)
3751 vim_free(arg);
3752 return OK;
3753 }
3754
Bram Moolenaar1769d5a2006-10-17 14:25:24 +00003755 return cmdline_paste_reg(regname, literally, remcr);
Bram Moolenaar8299df92004-07-10 09:47:34 +00003756}
3757
3758/*
3759 * Put a string on the command line.
3760 * When "literally" is TRUE, insert literally.
3761 * When "literally" is FALSE, insert as typed, but don't leave the command
3762 * line.
3763 */
3764 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01003765cmdline_paste_str(char_u *s, int literally)
Bram Moolenaar8299df92004-07-10 09:47:34 +00003766{
3767 int c, cv;
3768
3769 if (literally)
3770 put_on_cmdline(s, -1, TRUE);
3771 else
3772 while (*s != NUL)
3773 {
3774 cv = *s;
3775 if (cv == Ctrl_V && s[1])
3776 ++s;
Bram Moolenaar8299df92004-07-10 09:47:34 +00003777 if (has_mbyte)
Bram Moolenaar48be32b2008-06-20 10:56:16 +00003778 c = mb_cptr2char_adv(&s);
Bram Moolenaar8299df92004-07-10 09:47:34 +00003779 else
Bram Moolenaar8299df92004-07-10 09:47:34 +00003780 c = *s++;
Bram Moolenaare79abdd2012-06-29 13:44:41 +02003781 if (cv == Ctrl_V || c == ESC || c == Ctrl_C
3782 || c == CAR || c == NL || c == Ctrl_L
Bram Moolenaar8299df92004-07-10 09:47:34 +00003783#ifdef UNIX
3784 || c == intr_char
3785#endif
3786 || (c == Ctrl_BSL && *s == Ctrl_N))
3787 stuffcharReadbuff(Ctrl_V);
3788 stuffcharReadbuff(c);
3789 }
3790}
3791
Bram Moolenaar071d4272004-06-13 20:20:40 +00003792/*
Bram Moolenaar89c79b92016-05-05 17:18:41 +02003793 * This function is called when the screen size changes and with incremental
3794 * search and in other situations where the command line may have been
3795 * overwritten.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003796 */
3797 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01003798redrawcmdline(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003799{
Bram Moolenaar29ae3772017-04-30 19:39:39 +02003800 redrawcmdline_ex(TRUE);
3801}
3802
Bram Moolenaare5050712021-12-09 10:51:05 +00003803/*
3804 * When "do_compute_cmdrow" is TRUE the command line is redrawn at the bottom.
3805 * If FALSE cmdline_row is used, which should redraw in the same place.
3806 */
Bram Moolenaar29ae3772017-04-30 19:39:39 +02003807 void
3808redrawcmdline_ex(int do_compute_cmdrow)
3809{
Bram Moolenaar071d4272004-06-13 20:20:40 +00003810 if (cmd_silent)
3811 return;
3812 need_wait_return = FALSE;
Bram Moolenaar29ae3772017-04-30 19:39:39 +02003813 if (do_compute_cmdrow)
3814 compute_cmdrow();
Bram Moolenaar071d4272004-06-13 20:20:40 +00003815 redrawcmd();
3816 cursorcmd();
3817}
3818
3819 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01003820redrawcmdprompt(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003821{
3822 int i;
3823
3824 if (cmd_silent)
3825 return;
Bram Moolenaarbfd8fc02005-09-20 23:22:24 +00003826 if (ccline.cmdfirstc != NUL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003827 msg_putchar(ccline.cmdfirstc);
3828 if (ccline.cmdprompt != NULL)
3829 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01003830 msg_puts_attr((char *)ccline.cmdprompt, ccline.cmdattr);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003831 ccline.cmdindent = msg_col + (msg_row - cmdline_row) * Columns;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003832 // do the reverse of set_cmdspos()
Bram Moolenaarbfd8fc02005-09-20 23:22:24 +00003833 if (ccline.cmdfirstc != NUL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003834 --ccline.cmdindent;
3835 }
3836 else
3837 for (i = ccline.cmdindent; i > 0; --i)
3838 msg_putchar(' ');
3839}
3840
3841/*
3842 * Redraw what is currently on the command line.
3843 */
3844 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01003845redrawcmd(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003846{
Bram Moolenaar37fef162022-08-29 18:16:32 +01003847 int save_in_echowindow = in_echowindow;
3848
Bram Moolenaar071d4272004-06-13 20:20:40 +00003849 if (cmd_silent)
3850 return;
3851
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003852 // when 'incsearch' is set there may be no command line while redrawing
Bram Moolenaardf1bdc92006-02-23 21:32:16 +00003853 if (ccline.cmdbuff == NULL)
3854 {
3855 windgoto(cmdline_row, 0);
3856 msg_clr_eos();
3857 return;
3858 }
3859
Bram Moolenaar37fef162022-08-29 18:16:32 +01003860 // Do not put this in the message window.
3861 in_echowindow = FALSE;
3862
zeertzjq46af7bc2022-07-28 12:34:09 +01003863 sb_text_restart_cmdline();
Bram Moolenaar071d4272004-06-13 20:20:40 +00003864 msg_start();
3865 redrawcmdprompt();
3866
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003867 // Don't use more prompt, truncate the cmdline if it doesn't fit.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003868 msg_no_more = TRUE;
3869 draw_cmdline(0, ccline.cmdlen);
3870 msg_clr_eos();
3871 msg_no_more = FALSE;
3872
3873 set_cmdspos_cursor();
Bram Moolenaara92522f2017-07-15 15:21:38 +02003874 if (extra_char != NUL)
Bram Moolenaar6a77d262017-07-16 15:24:01 +02003875 putcmdline(extra_char, extra_char_shift);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003876
3877 /*
3878 * An emsg() before may have set msg_scroll. This is used in normal mode,
3879 * in cmdline mode we can reset them now.
3880 */
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003881 msg_scroll = FALSE; // next message overwrites cmdline
Bram Moolenaar071d4272004-06-13 20:20:40 +00003882
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003883 // Typing ':' at the more prompt may set skip_redraw. We don't want this
3884 // in cmdline mode
Bram Moolenaar071d4272004-06-13 20:20:40 +00003885 skip_redraw = FALSE;
Bram Moolenaar37fef162022-08-29 18:16:32 +01003886
3887 in_echowindow = save_in_echowindow;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003888}
3889
3890 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01003891compute_cmdrow(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003892{
Bram Moolenaarcf0995d2022-09-11 21:36:17 +01003893 // ignore "msg_scrolled" in update_screen(), it will be reset soon.
3894 if (exmode_active || (msg_scrolled != 0 && !updating_screen))
Bram Moolenaar071d4272004-06-13 20:20:40 +00003895 cmdline_row = Rows - 1;
3896 else
3897 cmdline_row = W_WINROW(lastwin) + lastwin->w_height
Bram Moolenaare0de17d2017-09-24 16:24:34 +02003898 + lastwin->w_status_height;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003899}
3900
Bram Moolenaar66b51422019-08-18 21:44:12 +02003901 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01003902cursorcmd(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003903{
3904 if (cmd_silent)
3905 return;
3906
3907#ifdef FEAT_RIGHTLEFT
3908 if (cmdmsg_rl)
3909 {
3910 msg_row = cmdline_row + (ccline.cmdspos / (int)(Columns - 1));
3911 msg_col = (int)Columns - (ccline.cmdspos % (int)(Columns - 1)) - 1;
3912 if (msg_row <= 0)
3913 msg_row = Rows - 1;
3914 }
3915 else
3916#endif
3917 {
3918 msg_row = cmdline_row + (ccline.cmdspos / (int)Columns);
3919 msg_col = ccline.cmdspos % (int)Columns;
3920 if (msg_row >= Rows)
3921 msg_row = Rows - 1;
3922 }
3923
3924 windgoto(msg_row, msg_col);
3925#if defined(FEAT_XIM) && defined(FEAT_GUI_GTK)
Bram Moolenaar5c6dbcb2017-08-30 22:00:20 +02003926 if (p_imst == IM_ON_THE_SPOT)
3927 redrawcmd_preedit();
Bram Moolenaar071d4272004-06-13 20:20:40 +00003928#endif
3929#ifdef MCH_CURSOR_SHAPE
3930 mch_update_cursor();
3931#endif
3932}
3933
3934 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01003935gotocmdline(int clr)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003936{
3937 msg_start();
3938#ifdef FEAT_RIGHTLEFT
3939 if (cmdmsg_rl)
3940 msg_col = Columns - 1;
3941 else
3942#endif
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003943 msg_col = 0; // always start in column 0
3944 if (clr) // clear the bottom line(s)
3945 msg_clr_eos(); // will reset clear_cmdline
Bram Moolenaar071d4272004-06-13 20:20:40 +00003946 windgoto(cmdline_row, 0);
3947}
3948
3949/*
3950 * Check the word in front of the cursor for an abbreviation.
3951 * Called when the non-id character "c" has been entered.
3952 * When an abbreviation is recognized it is removed from the text with
3953 * backspaces and the replacement string is inserted, followed by "c".
3954 */
3955 static int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01003956ccheck_abbr(int c)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003957{
Bram Moolenaar5e3423d2018-05-13 18:36:27 +02003958 int spos = 0;
3959
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003960 if (p_paste || no_abbr) // no abbreviations or in paste mode
Bram Moolenaar071d4272004-06-13 20:20:40 +00003961 return FALSE;
3962
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003963 // Do not consider '<,'> be part of the mapping, skip leading whitespace.
3964 // Actually accepts any mark.
Bram Moolenaar5e3423d2018-05-13 18:36:27 +02003965 while (VIM_ISWHITE(ccline.cmdbuff[spos]) && spos < ccline.cmdlen)
3966 spos++;
3967 if (ccline.cmdlen - spos > 5
3968 && ccline.cmdbuff[spos] == '\''
3969 && ccline.cmdbuff[spos + 2] == ','
3970 && ccline.cmdbuff[spos + 3] == '\'')
3971 spos += 5;
3972 else
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003973 // check abbreviation from the beginning of the commandline
Bram Moolenaar5e3423d2018-05-13 18:36:27 +02003974 spos = 0;
3975
3976 return check_abbr(c, ccline.cmdbuff, ccline.cmdpos, spos);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003977}
3978
Bram Moolenaar071d4272004-06-13 20:20:40 +00003979/*
Bram Moolenaar21c1a0c2021-10-17 17:20:23 +01003980 * Escape special characters in "fname", depending on "what":
3981 * VSE_NONE: for when used as a file name argument after a Vim command.
3982 * VSE_SHELL: for a shell command.
3983 * VSE_BUFFER: for the ":buffer" command.
Bram Moolenaaraebaf892008-05-28 14:49:58 +00003984 * Returns the result in allocated memory.
3985 */
3986 char_u *
Bram Moolenaar21c1a0c2021-10-17 17:20:23 +01003987vim_strsave_fnameescape(char_u *fname, int what)
Bram Moolenaaraebaf892008-05-28 14:49:58 +00003988{
Bram Moolenaar7693ec62008-07-24 18:29:37 +00003989 char_u *p;
Bram Moolenaaraebaf892008-05-28 14:49:58 +00003990#ifdef BACKSLASH_IN_FILENAME
3991 char_u buf[20];
3992 int j = 0;
3993
Bram Moolenaar21c1a0c2021-10-17 17:20:23 +01003994 // Don't escape '[', '{' and '!' if they are in 'isfname' and for the
3995 // ":buffer" command.
3996 for (p = what == VSE_BUFFER ? BUFFER_ESC_CHARS : PATH_ESC_CHARS;
3997 *p != NUL; ++p)
Bram Moolenaar8f5610d2013-11-12 05:28:26 +01003998 if ((*p != '[' && *p != '{' && *p != '!') || !vim_isfilec(*p))
Bram Moolenaaraebaf892008-05-28 14:49:58 +00003999 buf[j++] = *p;
4000 buf[j] = NUL;
Bram Moolenaar1b24e4b2008-08-08 10:59:17 +00004001 p = vim_strsave_escaped(fname, buf);
Bram Moolenaaraebaf892008-05-28 14:49:58 +00004002#else
Bram Moolenaar21c1a0c2021-10-17 17:20:23 +01004003 p = vim_strsave_escaped(fname, what == VSE_SHELL ? SHELL_ESC_CHARS
4004 : what == VSE_BUFFER ? BUFFER_ESC_CHARS : PATH_ESC_CHARS);
4005 if (what == VSE_SHELL && csh_like_shell() && p != NULL)
Bram Moolenaar7693ec62008-07-24 18:29:37 +00004006 {
4007 char_u *s;
4008
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004009 // For csh and similar shells need to put two backslashes before '!'.
4010 // One is taken by Vim, one by the shell.
Bram Moolenaar7693ec62008-07-24 18:29:37 +00004011 s = vim_strsave_escaped(p, (char_u *)"!");
4012 vim_free(p);
4013 p = s;
4014 }
Bram Moolenaaraebaf892008-05-28 14:49:58 +00004015#endif
Bram Moolenaar1b24e4b2008-08-08 10:59:17 +00004016
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004017 // '>' and '+' are special at the start of some commands, e.g. ":edit" and
4018 // ":write". "cd -" has a special meaning.
Bram Moolenaara9d52e32010-07-31 16:44:19 +02004019 if (p != NULL && (*p == '>' || *p == '+' || (*p == '-' && p[1] == NUL)))
Bram Moolenaar1b24e4b2008-08-08 10:59:17 +00004020 escape_fname(&p);
4021
4022 return p;
Bram Moolenaaraebaf892008-05-28 14:49:58 +00004023}
4024
4025/*
Bram Moolenaar45360022005-07-21 21:08:21 +00004026 * Put a backslash before the file name in "pp", which is in allocated memory.
4027 */
Bram Moolenaar66b51422019-08-18 21:44:12 +02004028 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01004029escape_fname(char_u **pp)
Bram Moolenaar45360022005-07-21 21:08:21 +00004030{
4031 char_u *p;
4032
Bram Moolenaar964b3742019-05-24 18:54:09 +02004033 p = alloc(STRLEN(*pp) + 2);
Bram Moolenaar45360022005-07-21 21:08:21 +00004034 if (p != NULL)
4035 {
4036 p[0] = '\\';
4037 STRCPY(p + 1, *pp);
4038 vim_free(*pp);
4039 *pp = p;
4040 }
4041}
4042
4043/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00004044 * For each file name in files[num_files]:
4045 * If 'orig_pat' starts with "~/", replace the home directory with "~".
4046 */
4047 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01004048tilde_replace(
4049 char_u *orig_pat,
4050 int num_files,
4051 char_u **files)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004052{
4053 int i;
4054 char_u *p;
4055
4056 if (orig_pat[0] == '~' && vim_ispathsep(orig_pat[1]))
4057 {
4058 for (i = 0; i < num_files; ++i)
4059 {
4060 p = home_replace_save(NULL, files[i]);
4061 if (p != NULL)
4062 {
4063 vim_free(files[i]);
4064 files[i] = p;
4065 }
4066 }
4067 }
4068}
4069
4070/*
Bram Moolenaar66b51422019-08-18 21:44:12 +02004071 * Get a pointer to the current command line info.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004072 */
Bram Moolenaar66b51422019-08-18 21:44:12 +02004073 cmdline_info_T *
4074get_cmdline_info(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004075{
Bram Moolenaar66b51422019-08-18 21:44:12 +02004076 return &ccline;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004077}
4078
Bram Moolenaar064154c2016-03-19 22:50:43 +01004079#if defined(FEAT_EVAL) || defined(FEAT_CMDWIN) || defined(PROTO)
Bram Moolenaard293b2b2016-03-19 22:29:49 +01004080/*
zeertzjq46af7bc2022-07-28 12:34:09 +01004081 * Get pointer to the command line info to use. save_cmdline() may clear
Bram Moolenaard293b2b2016-03-19 22:29:49 +01004082 * ccline and put the previous value in prev_ccline.
4083 */
Bram Moolenaar66b51422019-08-18 21:44:12 +02004084 static cmdline_info_T *
Bram Moolenaard293b2b2016-03-19 22:29:49 +01004085get_ccline_ptr(void)
4086{
Bram Moolenaar24959102022-05-07 20:01:16 +01004087 if ((State & MODE_CMDLINE) == 0)
Bram Moolenaard293b2b2016-03-19 22:29:49 +01004088 return NULL;
4089 if (ccline.cmdbuff != NULL)
4090 return &ccline;
4091 if (prev_ccline_used && prev_ccline.cmdbuff != NULL)
4092 return &prev_ccline;
4093 return NULL;
4094}
Bram Moolenaar064154c2016-03-19 22:50:43 +01004095#endif
Bram Moolenaard293b2b2016-03-19 22:29:49 +01004096
zeertzjq54acb902022-08-29 16:21:25 +01004097#if defined(FEAT_EVAL) || defined(FEAT_CMDWIN)
4098/*
4099 * Get the current command-line type.
4100 * Returns ':' or '/' or '?' or '@' or '>' or '-'
4101 * Only works when the command line is being edited.
4102 * Returns NUL when something is wrong.
4103 */
4104 static int
4105get_cmdline_type(void)
4106{
4107 cmdline_info_T *p = get_ccline_ptr();
4108
4109 if (p == NULL)
4110 return NUL;
4111 if (p->cmdfirstc == NUL)
4112 return
4113# ifdef FEAT_EVAL
4114 (p->input_fn) ? '@' :
4115# endif
4116 '-';
4117 return p->cmdfirstc;
4118}
4119#endif
4120
Bram Moolenaar064154c2016-03-19 22:50:43 +01004121#if defined(FEAT_EVAL) || defined(PROTO)
Bram Moolenaard293b2b2016-03-19 22:29:49 +01004122/*
4123 * Get the current command line in allocated memory.
4124 * Only works when the command line is being edited.
4125 * Returns NULL when something is wrong.
4126 */
Bram Moolenaar08c308a2019-09-04 17:48:15 +02004127 static char_u *
Bram Moolenaard293b2b2016-03-19 22:29:49 +01004128get_cmdline_str(void)
4129{
Bram Moolenaar66b51422019-08-18 21:44:12 +02004130 cmdline_info_T *p;
Bram Moolenaard293b2b2016-03-19 22:29:49 +01004131
Bram Moolenaaree91c332018-09-25 22:27:35 +02004132 if (cmdline_star > 0)
4133 return NULL;
4134 p = get_ccline_ptr();
Bram Moolenaard293b2b2016-03-19 22:29:49 +01004135 if (p == NULL)
4136 return NULL;
4137 return vim_strnsave(p->cmdbuff, p->cmdlen);
4138}
4139
4140/*
Shougo Matsushita79d599b2022-05-07 12:48:29 +01004141 * Get the current command-line completion type.
4142 */
4143 static char_u *
4144get_cmdline_completion(void)
4145{
4146 cmdline_info_T *p;
4147
4148 if (cmdline_star > 0)
4149 return NULL;
4150
4151 p = get_ccline_ptr();
Bram Moolenaar9ff7d712022-05-07 17:45:16 +01004152 if (p != NULL && p->xpc != NULL)
Shougo Matsushita79d599b2022-05-07 12:48:29 +01004153 {
4154 char_u *cmd_compl;
4155
4156 set_expand_context(p->xpc);
4157
4158 cmd_compl = cmdcomplete_type_to_str(p->xpc->xp_context);
4159 if (cmd_compl != NULL)
Bram Moolenaar9ff7d712022-05-07 17:45:16 +01004160 return vim_strsave(cmd_compl);
Shougo Matsushita79d599b2022-05-07 12:48:29 +01004161 }
4162
4163 return NULL;
4164}
4165
4166/*
4167 * "getcmdcompltype()" function
4168 */
4169 void
4170f_getcmdcompltype(typval_T *argvars UNUSED, typval_T *rettv)
4171{
4172 rettv->v_type = VAR_STRING;
4173 rettv->vval.v_string = get_cmdline_completion();
4174}
4175
4176/*
Bram Moolenaar08c308a2019-09-04 17:48:15 +02004177 * "getcmdline()" function
Bram Moolenaard293b2b2016-03-19 22:29:49 +01004178 */
Bram Moolenaar08c308a2019-09-04 17:48:15 +02004179 void
4180f_getcmdline(typval_T *argvars UNUSED, typval_T *rettv)
4181{
4182 rettv->v_type = VAR_STRING;
4183 rettv->vval.v_string = get_cmdline_str();
4184}
4185
4186/*
4187 * "getcmdpos()" function
4188 */
4189 void
4190f_getcmdpos(typval_T *argvars UNUSED, typval_T *rettv)
Bram Moolenaard293b2b2016-03-19 22:29:49 +01004191{
Bram Moolenaar66b51422019-08-18 21:44:12 +02004192 cmdline_info_T *p = get_ccline_ptr();
Bram Moolenaard293b2b2016-03-19 22:29:49 +01004193
zeertzjq54acb902022-08-29 16:21:25 +01004194 rettv->vval.v_number = p != NULL ? p->cmdpos + 1 : 0;
Shougo Matsushita79d599b2022-05-07 12:48:29 +01004195}
4196
4197/*
4198 * "getcmdscreenpos()" function
4199 */
4200 void
4201f_getcmdscreenpos(typval_T *argvars UNUSED, typval_T *rettv)
4202{
zeertzjq54acb902022-08-29 16:21:25 +01004203 cmdline_info_T *p = get_ccline_ptr();
4204
4205 rettv->vval.v_number = p != NULL ? p->cmdspos + 1 : 0;
4206}
4207
4208/*
4209 * "getcmdtype()" function
4210 */
4211 void
4212f_getcmdtype(typval_T *argvars UNUSED, typval_T *rettv)
4213{
4214 rettv->v_type = VAR_STRING;
4215 rettv->vval.v_string = alloc(2);
4216 if (rettv->vval.v_string != NULL)
4217 {
4218 rettv->vval.v_string[0] = get_cmdline_type();
4219 rettv->vval.v_string[1] = NUL;
4220 }
Shougo Matsushita79d599b2022-05-07 12:48:29 +01004221}
4222
Shougo Matsushita07ea5f12022-08-27 12:22:25 +01004223// Set the command line str to "str".
4224// Returns 1 when failed, 0 when OK.
zeertzjq54acb902022-08-29 16:21:25 +01004225 static int
Shougo Matsushita07ea5f12022-08-27 12:22:25 +01004226set_cmdline_str(char_u *str, int pos)
4227{
4228 cmdline_info_T *p = get_ccline_ptr();
Shougo Matsushita07ea5f12022-08-27 12:22:25 +01004229 int len;
4230
4231 if (p == NULL)
4232 return 1;
4233
4234 len = (int)STRLEN(str);
4235 realloc_cmdbuff(len + 1);
4236 p->cmdlen = len;
4237 STRCPY(p->cmdbuff, str);
4238
4239 p->cmdpos = pos < 0 || pos > p->cmdlen ? p->cmdlen : pos;
4240 new_cmdpos = p->cmdpos;
4241
4242 redrawcmd();
4243
4244 // Trigger CmdlineChanged autocommands.
zeertzjq54acb902022-08-29 16:21:25 +01004245 trigger_cmd_autocmd(get_cmdline_type(), EVENT_CMDLINECHANGED);
Shougo Matsushita07ea5f12022-08-27 12:22:25 +01004246
4247 return 0;
4248}
4249
Shougo Matsushita79d599b2022-05-07 12:48:29 +01004250/*
Bram Moolenaard293b2b2016-03-19 22:29:49 +01004251 * Set the command line byte position to "pos". Zero is the first position.
4252 * Only works when the command line is being edited.
4253 * Returns 1 when failed, 0 when OK.
4254 */
Bram Moolenaar08c308a2019-09-04 17:48:15 +02004255 static int
Bram Moolenaard293b2b2016-03-19 22:29:49 +01004256set_cmdline_pos(
4257 int pos)
4258{
Bram Moolenaar66b51422019-08-18 21:44:12 +02004259 cmdline_info_T *p = get_ccline_ptr();
Bram Moolenaard293b2b2016-03-19 22:29:49 +01004260
4261 if (p == NULL)
4262 return 1;
4263
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004264 // The position is not set directly but after CTRL-\ e or CTRL-R = has
4265 // changed the command line.
Bram Moolenaard293b2b2016-03-19 22:29:49 +01004266 if (pos < 0)
4267 new_cmdpos = 0;
4268 else
4269 new_cmdpos = pos;
4270 return 0;
4271}
Bram Moolenaar08c308a2019-09-04 17:48:15 +02004272
Shougo Matsushita07ea5f12022-08-27 12:22:25 +01004273// "setcmdline()" function
4274 void
4275f_setcmdline(typval_T *argvars, typval_T *rettv)
4276{
4277 int pos = -1;
4278
Yegappan Lakshmanan25f1e552022-08-28 17:25:04 +01004279 if (check_for_string_arg(argvars, 0) == FAIL
4280 || check_for_opt_number_arg(argvars, 1) == FAIL)
Shougo Matsushita07ea5f12022-08-27 12:22:25 +01004281 return;
Shougo Matsushita07ea5f12022-08-27 12:22:25 +01004282
4283 if (argvars[1].v_type != VAR_UNKNOWN)
4284 {
4285 int error = FALSE;
4286
4287 pos = (int)tv_get_number_chk(&argvars[1], &error) - 1;
4288 if (error)
4289 return;
4290 if (pos < 0)
4291 {
4292 emsg(_(e_argument_must_be_positive));
4293 return;
4294 }
4295 }
4296
4297 rettv->vval.v_number = set_cmdline_str(argvars[0].vval.v_string, pos);
4298}
4299
Bram Moolenaar08c308a2019-09-04 17:48:15 +02004300/*
4301 * "setcmdpos()" function
4302 */
4303 void
4304f_setcmdpos(typval_T *argvars, typval_T *rettv)
4305{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004306 int pos;
Bram Moolenaar08c308a2019-09-04 17:48:15 +02004307
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004308 if (in_vim9script() && check_for_number_arg(argvars, 0) == FAIL)
4309 return;
4310
4311 pos = (int)tv_get_number(&argvars[0]) - 1;
Bram Moolenaar08c308a2019-09-04 17:48:15 +02004312 if (pos >= 0)
4313 rettv->vval.v_number = set_cmdline_pos(pos);
4314}
Yegappan Lakshmanan782b43d2022-01-08 18:43:40 +00004315#endif
Bram Moolenaar08c308a2019-09-04 17:48:15 +02004316
Bram Moolenaard7663c22019-08-06 21:59:57 +02004317/*
4318 * Return the first character of the current command line.
4319 */
4320 int
4321get_cmdline_firstc(void)
4322{
4323 return ccline.cmdfirstc;
4324}
4325
Bram Moolenaar071d4272004-06-13 20:20:40 +00004326/*
4327 * Get indices "num1,num2" that specify a range within a list (not a range of
4328 * text lines in a buffer!) from a string. Used for ":history" and ":clist".
4329 * Returns OK if parsed successfully, otherwise FAIL.
4330 */
4331 int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01004332get_list_range(char_u **str, int *num1, int *num2)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004333{
4334 int len;
4335 int first = FALSE;
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02004336 varnumber_T num;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004337
4338 *str = skipwhite(*str);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004339 if (**str == '-' || vim_isdigit(**str)) // parse "from" part of range
Bram Moolenaar071d4272004-06-13 20:20:40 +00004340 {
Bram Moolenaar16e9b852019-05-19 19:59:35 +02004341 vim_str2nr(*str, NULL, &len, 0, &num, NULL, 0, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004342 *str += len;
4343 *num1 = (int)num;
4344 first = TRUE;
4345 }
4346 *str = skipwhite(*str);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004347 if (**str == ',') // parse "to" part of range
Bram Moolenaar071d4272004-06-13 20:20:40 +00004348 {
4349 *str = skipwhite(*str + 1);
Bram Moolenaar16e9b852019-05-19 19:59:35 +02004350 vim_str2nr(*str, NULL, &len, 0, &num, NULL, 0, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004351 if (len > 0)
4352 {
4353 *num2 = (int)num;
4354 *str = skipwhite(*str + len);
4355 }
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004356 else if (!first) // no number given at all
Bram Moolenaar071d4272004-06-13 20:20:40 +00004357 return FAIL;
4358 }
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004359 else if (first) // only one number given
Bram Moolenaar071d4272004-06-13 20:20:40 +00004360 *num2 = *num1;
4361 return OK;
4362}
Bram Moolenaar1fd99c12016-06-09 20:24:28 +02004363
Bram Moolenaar071d4272004-06-13 20:20:40 +00004364#if defined(FEAT_CMDWIN) || defined(PROTO)
4365/*
Bram Moolenaar7bae0b12019-11-21 22:14:18 +01004366 * Check value of 'cedit' and set cedit_key.
4367 * Returns NULL if value is OK, error message otherwise.
4368 */
4369 char *
4370check_cedit(void)
4371{
4372 int n;
4373
4374 if (*p_cedit == NUL)
4375 cedit_key = -1;
4376 else
4377 {
4378 n = string_to_key(p_cedit, FALSE);
4379 if (vim_isprintc(n))
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00004380 return e_invalid_argument;
Bram Moolenaar7bae0b12019-11-21 22:14:18 +01004381 cedit_key = n;
4382 }
4383 return NULL;
4384}
4385
4386/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00004387 * Open a window on the current command line and history. Allow editing in
4388 * the window. Returns when the window is closed.
4389 * Returns:
4390 * CR if the command is to be executed
4391 * Ctrl_C if it is to be abandoned
4392 * K_IGNORE if editing continues
4393 */
4394 static int
Bram Moolenaar3bab9392017-04-07 15:42:25 +02004395open_cmdwin(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004396{
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02004397 bufref_T old_curbuf;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004398 win_T *old_curwin = curwin;
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02004399 bufref_T bufref;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004400 win_T *wp;
4401 int i;
4402 linenr_T lnum;
4403 int histtype;
4404 garray_T winsizes;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004405 int save_restart_edit = restart_edit;
4406 int save_State = State;
4407 int save_exmode = exmode_active;
Bram Moolenaar46152342005-09-07 21:18:43 +00004408#ifdef FEAT_RIGHTLEFT
4409 int save_cmdmsg_rl = cmdmsg_rl;
4410#endif
Bram Moolenaar42f06f92014-08-17 17:24:07 +02004411#ifdef FEAT_FOLDING
4412 int save_KeyTyped;
4413#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004414
Bram Moolenaar71223e22022-05-30 15:23:09 +01004415 // Can't do this when text or buffer is locked.
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004416 // Can't do this recursively. Can't do it when typing a password.
Bram Moolenaarbe990422022-05-30 16:01:42 +01004417 if (text_or_buf_locked()
4418 || cmdwin_type != 0
Bram Moolenaar071d4272004-06-13 20:20:40 +00004419# if defined(FEAT_CRYPT) || defined(FEAT_EVAL)
4420 || cmdline_star > 0
4421# endif
4422 )
4423 {
4424 beep_flush();
4425 return K_IGNORE;
4426 }
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02004427 set_bufref(&old_curbuf, curbuf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004428
Bram Moolenaar96e38a82019-09-09 18:35:33 +02004429 // Save current window sizes.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004430 win_size_save(&winsizes);
4431
Bram Moolenaar9e26f7d2019-01-22 22:08:09 +01004432 // When using completion in Insert mode with <C-R>=<C-F> one can open the
4433 // command line window, but we don't want the popup menu then.
4434 pum_undisplay();
4435
Bram Moolenaar96e38a82019-09-09 18:35:33 +02004436 // don't use a new tab page
Bram Moolenaare1004402020-10-24 20:49:43 +02004437 cmdmod.cmod_tab = 0;
4438 cmdmod.cmod_flags |= CMOD_NOSWAPFILE;
Bram Moolenaardf1bdc92006-02-23 21:32:16 +00004439
Bram Moolenaar96e38a82019-09-09 18:35:33 +02004440 // Create a window for the command-line buffer.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004441 if (win_split((int)p_cwh, WSP_BOT) == FAIL)
4442 {
4443 beep_flush();
Bram Moolenaar292b90d2020-03-18 15:23:16 +01004444 ga_clear(&winsizes);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004445 return K_IGNORE;
4446 }
Bram Moolenaar9b7cce22020-06-06 15:14:08 +02004447 // Don't let quitting the More prompt make this fail.
4448 got_int = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004449
Bram Moolenaarbb4b93e2021-01-26 21:35:08 +01004450 // Set "cmdwin_type" before any autocommands may mess things up.
4451 cmdwin_type = get_cmdline_type();
4452
Bram Moolenaar96e38a82019-09-09 18:35:33 +02004453 // Create the command-line buffer empty.
Bram Moolenaar9b7cce22020-06-06 15:14:08 +02004454 if (do_ecmd(0, NULL, NULL, NULL, ECMD_ONE, ECMD_HIDE, NULL) == FAIL)
4455 {
4456 // Some autocommand messed it up?
4457 win_close(curwin, TRUE);
4458 ga_clear(&winsizes);
Bram Moolenaarbed72df2021-01-27 20:34:29 +01004459 cmdwin_type = 0;
Bram Moolenaar9b7cce22020-06-06 15:14:08 +02004460 return Ctrl_C;
4461 }
Bram Moolenaar9b7cce22020-06-06 15:14:08 +02004462
Bram Moolenaar5e94a292020-03-19 18:46:57 +01004463 apply_autocmds(EVENT_BUFFILEPRE, NULL, NULL, FALSE, curbuf);
Bram Moolenaarb17ec4d2021-02-10 16:45:24 +01004464 (void)setfname(curbuf, (char_u *)_("[Command Line]"), NULL, TRUE);
Bram Moolenaar5e94a292020-03-19 18:46:57 +01004465 apply_autocmds(EVENT_BUFFILEPOST, NULL, NULL, FALSE, curbuf);
Bram Moolenaar31e5c602022-04-15 13:53:33 +01004466 set_option_value_give_err((char_u *)"bt",
4467 0L, (char_u *)"nofile", OPT_LOCAL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004468 curbuf->b_p_ma = TRUE;
Bram Moolenaar876f6d72009-04-29 10:05:51 +00004469#ifdef FEAT_FOLDING
4470 curwin->w_p_fen = FALSE;
4471#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004472# ifdef FEAT_RIGHTLEFT
Bram Moolenaar46152342005-09-07 21:18:43 +00004473 curwin->w_p_rl = cmdmsg_rl;
4474 cmdmsg_rl = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004475# endif
Bram Moolenaar3368ea22010-09-21 16:56:35 +02004476 RESET_BINDING(curwin);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004477
Bram Moolenaar96e38a82019-09-09 18:35:33 +02004478 // Don't allow switching to another buffer.
Bram Moolenaar18141832017-06-25 21:17:25 +02004479 ++curbuf_lock;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004480
Bram Moolenaar96e38a82019-09-09 18:35:33 +02004481 // Showing the prompt may have set need_wait_return, reset it.
Bram Moolenaar46152342005-09-07 21:18:43 +00004482 need_wait_return = FALSE;
4483
Bram Moolenaare8bd5ce2009-03-02 01:12:48 +00004484 histtype = hist_char2type(cmdwin_type);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004485 if (histtype == HIST_CMD || histtype == HIST_DEBUG)
4486 {
4487 if (p_wc == TAB)
4488 {
zeertzjq44068e92022-06-16 11:14:55 +01004489 add_map((char_u *)"<buffer> <Tab> <C-X><C-V>", MODE_INSERT, TRUE);
4490 add_map((char_u *)"<buffer> <Tab> a<C-X><C-V>", MODE_NORMAL, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004491 }
Bram Moolenaar31e5c602022-04-15 13:53:33 +01004492 set_option_value_give_err((char_u *)"ft",
4493 0L, (char_u *)"vim", OPT_LOCAL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004494 }
Bram Moolenaar18141832017-06-25 21:17:25 +02004495 --curbuf_lock;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004496
Bram Moolenaar96e38a82019-09-09 18:35:33 +02004497 // Reset 'textwidth' after setting 'filetype' (the Vim filetype plugin
4498 // sets 'textwidth' to 78).
Bram Moolenaarf4b8e572004-06-24 15:53:16 +00004499 curbuf->b_p_tw = 0;
4500
Bram Moolenaar96e38a82019-09-09 18:35:33 +02004501 // Fill the buffer with the history.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004502 init_history();
Bram Moolenaard7663c22019-08-06 21:59:57 +02004503 if (get_hislen() > 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004504 {
Bram Moolenaard7663c22019-08-06 21:59:57 +02004505 i = *get_hisidx(histtype);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004506 if (i >= 0)
4507 {
4508 lnum = 0;
4509 do
4510 {
Bram Moolenaard7663c22019-08-06 21:59:57 +02004511 if (++i == get_hislen())
Bram Moolenaar071d4272004-06-13 20:20:40 +00004512 i = 0;
Bram Moolenaard7663c22019-08-06 21:59:57 +02004513 if (get_histentry(histtype)[i].hisstr != NULL)
4514 ml_append(lnum++, get_histentry(histtype)[i].hisstr,
Bram Moolenaar071d4272004-06-13 20:20:40 +00004515 (colnr_T)0, FALSE);
4516 }
Bram Moolenaard7663c22019-08-06 21:59:57 +02004517 while (i != *get_hisidx(histtype));
Bram Moolenaar071d4272004-06-13 20:20:40 +00004518 }
4519 }
4520
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004521 // Replace the empty last line with the current command-line and put the
4522 // cursor there.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004523 ml_replace(curbuf->b_ml.ml_line_count, ccline.cmdbuff, TRUE);
4524 curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
4525 curwin->w_cursor.col = ccline.cmdpos;
Bram Moolenaar46152342005-09-07 21:18:43 +00004526 changed_line_abv_curs();
4527 invalidate_botline();
Bram Moolenaara4d158b2022-08-14 14:17:45 +01004528 redraw_later(UPD_SOME_VALID);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004529
Bram Moolenaar23324a02019-10-01 17:39:04 +02004530 // No Ex mode here!
Bram Moolenaar071d4272004-06-13 20:20:40 +00004531 exmode_active = 0;
4532
Bram Moolenaar24959102022-05-07 20:01:16 +01004533 State = MODE_NORMAL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004534 setmouse();
Bram Moolenaar071d4272004-06-13 20:20:40 +00004535
Bram Moolenaar23324a02019-10-01 17:39:04 +02004536 // Reset here so it can be set by a CmdWinEnter autocommand.
4537 cmdwin_result = 0;
4538
Bram Moolenaar96e38a82019-09-09 18:35:33 +02004539 // Trigger CmdwinEnter autocommands.
Bram Moolenaarfafcf0d2017-10-19 18:35:51 +02004540 trigger_cmd_autocmd(cmdwin_type, EVENT_CMDWINENTER);
Bram Moolenaar96e38a82019-09-09 18:35:33 +02004541 if (restart_edit != 0) // autocmd with ":startinsert"
Bram Moolenaar5495cc92006-08-16 14:23:04 +00004542 stuffcharReadbuff(K_NOP);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004543
4544 i = RedrawingDisabled;
4545 RedrawingDisabled = 0;
4546
4547 /*
4548 * Call the main loop until <CR> or CTRL-C is typed.
4549 */
Bram Moolenaar26a60b42005-02-22 08:49:11 +00004550 main_loop(TRUE, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004551
4552 RedrawingDisabled = i;
4553
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01004554# ifdef FEAT_FOLDING
Bram Moolenaar42f06f92014-08-17 17:24:07 +02004555 save_KeyTyped = KeyTyped;
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01004556# endif
Bram Moolenaar42f06f92014-08-17 17:24:07 +02004557
Bram Moolenaar96e38a82019-09-09 18:35:33 +02004558 // Trigger CmdwinLeave autocommands.
Bram Moolenaarfafcf0d2017-10-19 18:35:51 +02004559 trigger_cmd_autocmd(cmdwin_type, EVENT_CMDWINLEAVE);
Bram Moolenaar42f06f92014-08-17 17:24:07 +02004560
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01004561# ifdef FEAT_FOLDING
Bram Moolenaar96e38a82019-09-09 18:35:33 +02004562 // Restore KeyTyped in case it is modified by autocommands
Bram Moolenaar42f06f92014-08-17 17:24:07 +02004563 KeyTyped = save_KeyTyped;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004564# endif
4565
Bram Moolenaar071d4272004-06-13 20:20:40 +00004566 cmdwin_type = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004567 exmode_active = save_exmode;
4568
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004569 // Safety check: The old window or buffer was deleted: It's a bug when
4570 // this happens!
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02004571 if (!win_valid(old_curwin) || !bufref_valid(&old_curbuf))
Bram Moolenaar071d4272004-06-13 20:20:40 +00004572 {
4573 cmdwin_result = Ctrl_C;
Bram Moolenaar6d057012021-12-31 18:49:43 +00004574 emsg(_(e_active_window_or_buffer_deleted));
Bram Moolenaar071d4272004-06-13 20:20:40 +00004575 }
4576 else
4577 {
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01004578# if defined(FEAT_EVAL)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004579 // autocmds may abort script processing
Bram Moolenaar071d4272004-06-13 20:20:40 +00004580 if (aborting() && cmdwin_result != K_IGNORE)
4581 cmdwin_result = Ctrl_C;
4582# endif
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004583 // Set the new command line from the cmdline buffer.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004584 vim_free(ccline.cmdbuff);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004585 if (cmdwin_result == K_XF1 || cmdwin_result == K_XF2) // :qa[!] typed
Bram Moolenaar071d4272004-06-13 20:20:40 +00004586 {
Bram Moolenaar46152342005-09-07 21:18:43 +00004587 char *p = (cmdwin_result == K_XF2) ? "qa" : "qa!";
4588
4589 if (histtype == HIST_CMD)
4590 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004591 // Execute the command directly.
Bram Moolenaar46152342005-09-07 21:18:43 +00004592 ccline.cmdbuff = vim_strsave((char_u *)p);
4593 cmdwin_result = CAR;
4594 }
4595 else
4596 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004597 // First need to cancel what we were doing.
Bram Moolenaar46152342005-09-07 21:18:43 +00004598 ccline.cmdbuff = NULL;
4599 stuffcharReadbuff(':');
4600 stuffReadbuff((char_u *)p);
4601 stuffcharReadbuff(CAR);
4602 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004603 }
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004604 else if (cmdwin_result == K_XF2) // :qa typed
Bram Moolenaar071d4272004-06-13 20:20:40 +00004605 {
4606 ccline.cmdbuff = vim_strsave((char_u *)"qa");
4607 cmdwin_result = CAR;
4608 }
Bram Moolenaar9bd1a7e2011-05-19 14:50:54 +02004609 else if (cmdwin_result == Ctrl_C)
4610 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004611 // :q or :close, don't execute any command
4612 // and don't modify the cmd window.
Bram Moolenaar9bd1a7e2011-05-19 14:50:54 +02004613 ccline.cmdbuff = NULL;
4614 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004615 else
4616 ccline.cmdbuff = vim_strsave(ml_get_curline());
4617 if (ccline.cmdbuff == NULL)
Bram Moolenaar5a15b6a2017-07-11 15:11:57 +02004618 {
4619 ccline.cmdbuff = vim_strsave((char_u *)"");
4620 ccline.cmdlen = 0;
4621 ccline.cmdbufflen = 1;
4622 ccline.cmdpos = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004623 cmdwin_result = Ctrl_C;
Bram Moolenaar5a15b6a2017-07-11 15:11:57 +02004624 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004625 else
4626 {
4627 ccline.cmdlen = (int)STRLEN(ccline.cmdbuff);
4628 ccline.cmdbufflen = ccline.cmdlen + 1;
4629 ccline.cmdpos = curwin->w_cursor.col;
4630 if (ccline.cmdpos > ccline.cmdlen)
4631 ccline.cmdpos = ccline.cmdlen;
4632 if (cmdwin_result == K_IGNORE)
4633 {
4634 set_cmdspos_cursor();
4635 redrawcmd();
4636 }
4637 }
4638
Bram Moolenaarfa67fbe2015-06-25 18:20:36 +02004639# ifdef FEAT_CONCEAL
Bram Moolenaar96e38a82019-09-09 18:35:33 +02004640 // Avoid command-line window first character being concealed.
Bram Moolenaarfa67fbe2015-06-25 18:20:36 +02004641 curwin->w_p_cole = 0;
4642# endif
Bram Moolenaarb7e26702021-01-26 22:00:52 +01004643 // First go back to the original window.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004644 wp = curwin;
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02004645 set_bufref(&bufref, curbuf);
mityue697d482022-09-14 17:27:36 +01004646
Luuk van Baal3735f112022-09-15 12:43:26 +01004647 skip_win_fix_cursor = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004648 win_goto(old_curwin);
Bram Moolenaarb7e26702021-01-26 22:00:52 +01004649
4650 // win_goto() may trigger an autocommand that already closes the
4651 // cmdline window.
Bram Moolenaar8c6951f2021-02-06 18:08:45 +01004652 if (win_valid(wp) && wp != curwin)
Bram Moolenaarb7e26702021-01-26 22:00:52 +01004653 win_close(wp, TRUE);
Bram Moolenaar8006d692010-03-02 17:23:21 +01004654
Bram Moolenaar96e38a82019-09-09 18:35:33 +02004655 // win_close() may have already wiped the buffer when 'bh' is
Bram Moolenaar8c6951f2021-02-06 18:08:45 +01004656 // set to 'wipe', autocommands may have closed other windows
4657 if (bufref_valid(&bufref) && bufref.br_buf != curbuf)
Bram Moolenaara6e8f882019-12-14 16:18:15 +01004658 close_buffer(NULL, bufref.br_buf, DOBUF_WIPE, FALSE, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004659
Bram Moolenaar96e38a82019-09-09 18:35:33 +02004660 // Restore window sizes.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004661 win_size_restore(&winsizes);
Luuk van Baal3735f112022-09-15 12:43:26 +01004662 skip_win_fix_cursor = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004663 }
4664
4665 ga_clear(&winsizes);
4666 restart_edit = save_restart_edit;
Bram Moolenaar46152342005-09-07 21:18:43 +00004667# ifdef FEAT_RIGHTLEFT
4668 cmdmsg_rl = save_cmdmsg_rl;
4669# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004670
4671 State = save_State;
zeertzjqc9e8fd62022-07-26 18:12:38 +01004672 may_trigger_modechanged();
Bram Moolenaar071d4272004-06-13 20:20:40 +00004673 setmouse();
Bram Moolenaar071d4272004-06-13 20:20:40 +00004674
4675 return cmdwin_result;
4676}
mityua1198122021-11-20 19:13:39 +00004677
4678/*
4679 * Return TRUE if in the cmdwin, not editing the command line.
4680 */
4681 int
4682is_in_cmdwin(void)
4683{
4684 return cmdwin_type != 0 && get_cmdline_type() == NUL;
4685}
Bram Moolenaar96e38a82019-09-09 18:35:33 +02004686#endif // FEAT_CMDWIN
Bram Moolenaar071d4272004-06-13 20:20:40 +00004687
4688/*
4689 * Used for commands that either take a simple command string argument, or:
4690 * cmd << endmarker
4691 * {script}
4692 * endmarker
4693 * Returns a pointer to allocated memory with {script} or NULL.
4694 */
4695 char_u *
Bram Moolenaar6c2b7b82020-04-14 20:15:49 +02004696script_get(exarg_T *eap UNUSED, char_u *cmd UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004697{
Bram Moolenaar6c2b7b82020-04-14 20:15:49 +02004698#ifdef FEAT_EVAL
4699 list_T *l;
4700 listitem_T *li;
4701 char_u *s;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004702 garray_T ga;
4703
4704 if (cmd[0] != '<' || cmd[1] != '<' || eap->getline == NULL)
4705 return NULL;
Bram Moolenaar6c2b7b82020-04-14 20:15:49 +02004706 cmd += 2;
4707
Yegappan Lakshmanan1fc6ea92022-04-21 23:30:15 +01004708 l = heredoc_get(eap, cmd, TRUE, FALSE);
Bram Moolenaar6c2b7b82020-04-14 20:15:49 +02004709 if (l == NULL)
4710 return NULL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004711
4712 ga_init2(&ga, 1, 0x400);
4713
Bram Moolenaar6c2b7b82020-04-14 20:15:49 +02004714 FOR_ALL_LIST_ITEMS(l, li)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004715 {
Bram Moolenaar6c2b7b82020-04-14 20:15:49 +02004716 s = tv_get_string(&li->li_tv);
4717 ga_concat(&ga, s);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004718 ga_append(&ga, '\n');
Bram Moolenaar071d4272004-06-13 20:20:40 +00004719 }
Bram Moolenaar269ec652004-07-29 08:43:53 +00004720 ga_append(&ga, NUL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004721
Bram Moolenaar6c2b7b82020-04-14 20:15:49 +02004722 list_free(l);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004723 return (char_u *)ga.ga_data;
Bram Moolenaar6c2b7b82020-04-14 20:15:49 +02004724#else
4725 return NULL;
4726#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004727}
Bram Moolenaarda6c0332019-09-01 16:01:30 +02004728
4729#if defined(FEAT_EVAL) || defined(PROTO)
4730/*
4731 * This function is used by f_input() and f_inputdialog() functions. The third
4732 * argument to f_input() specifies the type of completion to use at the
4733 * prompt. The third argument to f_inputdialog() specifies the value to return
4734 * when the user cancels the prompt.
4735 */
4736 void
4737get_user_input(
4738 typval_T *argvars,
4739 typval_T *rettv,
4740 int inputdialog,
4741 int secret)
4742{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004743 char_u *prompt;
Bram Moolenaarda6c0332019-09-01 16:01:30 +02004744 char_u *p = NULL;
4745 int c;
4746 char_u buf[NUMBUFLEN];
4747 int cmd_silent_save = cmd_silent;
4748 char_u *defstr = (char_u *)"";
4749 int xp_type = EXPAND_NOTHING;
4750 char_u *xp_arg = NULL;
4751
4752 rettv->v_type = VAR_STRING;
4753 rettv->vval.v_string = NULL;
Bram Moolenaardfc33a62020-04-29 22:30:13 +02004754 if (input_busy)
4755 return; // this doesn't work recursively.
Bram Moolenaarda6c0332019-09-01 16:01:30 +02004756
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004757 if (in_vim9script()
4758 && (check_for_string_arg(argvars, 0) == FAIL
4759 || check_for_opt_string_arg(argvars, 1) == FAIL
4760 || (argvars[1].v_type != VAR_UNKNOWN
4761 && check_for_opt_string_arg(argvars, 2) == FAIL)))
4762 return;
4763
4764 prompt = tv_get_string_chk(&argvars[0]);
4765
Bram Moolenaarda6c0332019-09-01 16:01:30 +02004766#ifdef NO_CONSOLE_INPUT
4767 // While starting up, there is no place to enter text. When running tests
4768 // with --not-a-term we assume feedkeys() will be used.
4769 if (no_console_input() && !is_not_a_term())
4770 return;
4771#endif
4772
4773 cmd_silent = FALSE; // Want to see the prompt.
4774 if (prompt != NULL)
4775 {
4776 // Only the part of the message after the last NL is considered as
4777 // prompt for the command line
4778 p = vim_strrchr(prompt, '\n');
4779 if (p == NULL)
4780 p = prompt;
4781 else
4782 {
4783 ++p;
4784 c = *p;
4785 *p = NUL;
4786 msg_start();
4787 msg_clr_eos();
4788 msg_puts_attr((char *)prompt, get_echo_attr());
4789 msg_didout = FALSE;
4790 msg_starthere();
4791 *p = c;
4792 }
4793 cmdline_row = msg_row;
4794
4795 if (argvars[1].v_type != VAR_UNKNOWN)
4796 {
4797 defstr = tv_get_string_buf_chk(&argvars[1], buf);
4798 if (defstr != NULL)
4799 stuffReadbuffSpec(defstr);
4800
4801 if (!inputdialog && argvars[2].v_type != VAR_UNKNOWN)
4802 {
4803 char_u *xp_name;
4804 int xp_namelen;
Bram Moolenaar05c17342022-02-25 20:57:11 +00004805 long argt = 0;
Bram Moolenaarda6c0332019-09-01 16:01:30 +02004806
4807 // input() with a third argument: completion
4808 rettv->vval.v_string = NULL;
4809
4810 xp_name = tv_get_string_buf_chk(&argvars[2], buf);
4811 if (xp_name == NULL)
4812 return;
4813
4814 xp_namelen = (int)STRLEN(xp_name);
4815
4816 if (parse_compl_arg(xp_name, xp_namelen, &xp_type, &argt,
4817 &xp_arg) == FAIL)
4818 return;
4819 }
4820 }
4821
4822 if (defstr != NULL)
4823 {
4824 int save_ex_normal_busy = ex_normal_busy;
Bram Moolenaardfc33a62020-04-29 22:30:13 +02004825 int save_vgetc_busy = vgetc_busy;
4826 int save_input_busy = input_busy;
Bram Moolenaarda6c0332019-09-01 16:01:30 +02004827
Bram Moolenaardfc33a62020-04-29 22:30:13 +02004828 input_busy |= vgetc_busy;
Bram Moolenaarda6c0332019-09-01 16:01:30 +02004829 ex_normal_busy = 0;
Bram Moolenaardfc33a62020-04-29 22:30:13 +02004830 vgetc_busy = 0;
Bram Moolenaarda6c0332019-09-01 16:01:30 +02004831 rettv->vval.v_string =
4832 getcmdline_prompt(secret ? NUL : '@', p, get_echo_attr(),
4833 xp_type, xp_arg);
4834 ex_normal_busy = save_ex_normal_busy;
Bram Moolenaardfc33a62020-04-29 22:30:13 +02004835 vgetc_busy = save_vgetc_busy;
4836 input_busy = save_input_busy;
Bram Moolenaarda6c0332019-09-01 16:01:30 +02004837 }
4838 if (inputdialog && rettv->vval.v_string == NULL
4839 && argvars[1].v_type != VAR_UNKNOWN
4840 && argvars[2].v_type != VAR_UNKNOWN)
4841 rettv->vval.v_string = vim_strsave(tv_get_string_buf(
4842 &argvars[2], buf));
4843
4844 vim_free(xp_arg);
4845
4846 // since the user typed this, no need to wait for return
4847 need_wait_return = FALSE;
4848 msg_didout = FALSE;
4849 }
4850 cmd_silent = cmd_silent_save;
4851}
4852#endif