blob: a35924a570746b1310b84e0c0cd8d956fea9309f [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_docmd.c: functions for executing an Ex command line.
12 */
13
14#include "vim.h"
15
Bram Moolenaar071d4272004-06-13 20:20:40 +000016static int quitmore = 0;
17static int ex_pressedreturn = FALSE;
18#ifndef FEAT_PRINTER
19# define ex_hardcopy ex_ni
20#endif
21
Bram Moolenaar071d4272004-06-13 20:20:40 +000022#ifdef FEAT_EVAL
Bram Moolenaar20b23c62020-08-20 15:25:00 +020023static char_u *do_one_cmd(char_u **, int, cstack_T *, char_u *(*fgetline)(int, void *, int, getline_opt_T), void *cookie);
Bram Moolenaar071d4272004-06-13 20:20:40 +000024#else
Bram Moolenaar20b23c62020-08-20 15:25:00 +020025static char_u *do_one_cmd(char_u **, int, char_u *(*fgetline)(int, void *, int, getline_opt_T), void *cookie);
Bram Moolenaar217e1b82019-12-01 21:41:28 +010026static int if_level = 0; // depth in :if
Bram Moolenaar071d4272004-06-13 20:20:40 +000027#endif
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010028static void append_command(char_u *cmd);
Bram Moolenaar071d4272004-06-13 20:20:40 +000029
Bram Moolenaar071d4272004-06-13 20:20:40 +000030#ifndef FEAT_MENU
31# define ex_emenu ex_ni
32# define ex_menu ex_ni
33# define ex_menutranslate ex_ni
34#endif
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010035static void ex_autocmd(exarg_T *eap);
36static void ex_doautocmd(exarg_T *eap);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010037static void ex_bunload(exarg_T *eap);
38static void ex_buffer(exarg_T *eap);
39static void ex_bmodified(exarg_T *eap);
40static void ex_bnext(exarg_T *eap);
41static void ex_bprevious(exarg_T *eap);
42static void ex_brewind(exarg_T *eap);
43static void ex_blast(exarg_T *eap);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010044static char_u *getargcmd(char_u **);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010045static int getargopt(exarg_T *eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +000046#ifndef FEAT_QUICKFIX
47# define ex_make ex_ni
Bram Moolenaar86b68352004-12-27 21:59:20 +000048# define ex_cbuffer ex_ni
Bram Moolenaar071d4272004-06-13 20:20:40 +000049# define ex_cc ex_ni
50# define ex_cnext ex_ni
Bram Moolenaar3ff33112019-05-03 21:56:35 +020051# define ex_cbelow ex_ni
Bram Moolenaar071d4272004-06-13 20:20:40 +000052# define ex_cfile ex_ni
53# define qf_list ex_ni
54# define qf_age ex_ni
Bram Moolenaarf6acffb2016-07-16 16:54:24 +020055# define qf_history ex_ni
Bram Moolenaar071d4272004-06-13 20:20:40 +000056# define ex_helpgrep ex_ni
Bram Moolenaar86b68352004-12-27 21:59:20 +000057# define ex_vimgrep ex_ni
Bram Moolenaar071d4272004-06-13 20:20:40 +000058#endif
Bram Moolenaar4033c552017-09-16 20:54:51 +020059#if !defined(FEAT_QUICKFIX)
Bram Moolenaar071d4272004-06-13 20:20:40 +000060# define ex_cclose ex_ni
61# define ex_copen ex_ni
62# define ex_cwindow ex_ni
Bram Moolenaardcb17002016-07-07 18:58:59 +020063# define ex_cbottom ex_ni
Bram Moolenaar071d4272004-06-13 20:20:40 +000064#endif
Bram Moolenaar1e015462005-09-25 22:16:38 +000065#if !defined(FEAT_QUICKFIX) || !defined(FEAT_EVAL)
66# define ex_cexpr ex_ni
67#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +000068
Bram Moolenaarc2af0af2020-08-23 21:06:02 +020069static linenr_T default_address(exarg_T *eap);
Bram Moolenaarb7316892019-05-01 18:08:42 +020070static linenr_T get_address(exarg_T *, char_u **, cmd_addr_T addr_type, int skip, int silent, int to_other_file, int address_count);
Bram Moolenaarc2af0af2020-08-23 21:06:02 +020071static void address_default_all(exarg_T *eap);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010072static void get_flags(exarg_T *eap);
Bram Moolenaar85363ab2010-07-18 13:58:26 +020073#if !defined(FEAT_PERL) \
74 || !defined(FEAT_PYTHON) || !defined(FEAT_PYTHON3) \
75 || !defined(FEAT_TCL) \
76 || !defined(FEAT_RUBY) \
77 || !defined(FEAT_LUA) \
78 || !defined(FEAT_MZSCHEME)
Bram Moolenaar7bb75552007-07-16 18:39:49 +000079# define HAVE_EX_SCRIPT_NI
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010080static void ex_script_ni(exarg_T *eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +000081#endif
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010082static char *invalid_range(exarg_T *eap);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010083static void correct_range(exarg_T *eap);
Bram Moolenaard857f0e2005-06-21 22:37:39 +000084#ifdef FEAT_QUICKFIX
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010085static char_u *replace_makeprg(exarg_T *eap, char_u *p, char_u **cmdlinep);
Bram Moolenaard857f0e2005-06-21 22:37:39 +000086#endif
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010087static char_u *repl_cmdline(exarg_T *eap, char_u *src, int srclen, char_u *repl, char_u **cmdlinep);
88static void ex_highlight(exarg_T *eap);
89static void ex_colorscheme(exarg_T *eap);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010090static void ex_cquit(exarg_T *eap);
91static void ex_quit_all(exarg_T *eap);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010092static void ex_close(exarg_T *eap);
93static void ex_win_close(int forceit, win_T *win, tabpage_T *tp);
94static void ex_only(exarg_T *eap);
95static void ex_resize(exarg_T *eap);
96static void ex_stag(exarg_T *eap);
97static void ex_tabclose(exarg_T *eap);
98static void ex_tabonly(exarg_T *eap);
99static void ex_tabnext(exarg_T *eap);
100static void ex_tabmove(exarg_T *eap);
101static void ex_tabs(exarg_T *eap);
Bram Moolenaar4033c552017-09-16 20:54:51 +0200102#if defined(FEAT_QUICKFIX)
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100103static void ex_pclose(exarg_T *eap);
104static void ex_ptag(exarg_T *eap);
105static void ex_pedit(exarg_T *eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000106#else
107# define ex_pclose ex_ni
108# define ex_ptag ex_ni
109# define ex_pedit ex_ni
110#endif
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100111static void ex_hide(exarg_T *eap);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100112static void ex_exit(exarg_T *eap);
113static void ex_print(exarg_T *eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000114#ifdef FEAT_BYTEOFF
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100115static void ex_goto(exarg_T *eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000116#else
117# define ex_goto ex_ni
118#endif
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100119static void ex_shell(exarg_T *eap);
120static void ex_preserve(exarg_T *eap);
121static void ex_recover(exarg_T *eap);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100122static void ex_mode(exarg_T *eap);
123static void ex_wrongmodifier(exarg_T *eap);
124static void ex_find(exarg_T *eap);
125static void ex_open(exarg_T *eap);
126static void ex_edit(exarg_T *eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000127#ifndef FEAT_GUI
128# define ex_gui ex_nogui
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100129static void ex_nogui(exarg_T *eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000130#endif
Bram Moolenaar4f974752019-02-17 17:44:42 +0100131#if defined(FEAT_GUI_MSWIN) && defined(FEAT_MENU) && defined(FEAT_TEAROFF)
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100132static void ex_tearoff(exarg_T *eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000133#else
134# define ex_tearoff ex_ni
135#endif
Bram Moolenaar29a2c082018-03-05 21:06:23 +0100136#if (defined(FEAT_GUI_MSWIN) || defined(FEAT_GUI_GTK) \
137 || defined(FEAT_TERM_POPUP_MENU)) && defined(FEAT_MENU)
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100138static void ex_popup(exarg_T *eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000139#else
140# define ex_popup ex_ni
141#endif
142#ifndef FEAT_GUI_MSWIN
143# define ex_simalt ex_ni
144#endif
Bram Moolenaarcef9dcc2005-12-06 19:50:41 +0000145#if !defined(FEAT_GUI_MSWIN) && !defined(FEAT_GUI_GTK) && !defined(FEAT_GUI_MOTIF)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000146# define gui_mch_find_dialog ex_ni
147# define gui_mch_replace_dialog ex_ni
148#endif
Bram Moolenaarcef9dcc2005-12-06 19:50:41 +0000149#if !defined(FEAT_GUI_GTK)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000150# define ex_helpfind ex_ni
151#endif
152#ifndef FEAT_CSCOPE
Bram Moolenaard4db7712016-11-12 19:16:46 +0100153# define ex_cscope ex_ni
154# define ex_scscope ex_ni
155# define ex_cstag ex_ni
Bram Moolenaar071d4272004-06-13 20:20:40 +0000156#endif
157#ifndef FEAT_SYN_HL
158# define ex_syntax ex_ni
Bram Moolenaar860cae12010-06-05 23:22:07 +0200159# define ex_ownsyntax ex_ni
Bram Moolenaarf71a3db2006-03-12 21:50:18 +0000160#endif
Bram Moolenaarf7512552013-06-06 14:55:19 +0200161#if !defined(FEAT_SYN_HL) || !defined(FEAT_PROFILE)
Bram Moolenaar8a7f5a22013-06-06 14:01:46 +0200162# define ex_syntime ex_ni
163#endif
Bram Moolenaarf71a3db2006-03-12 21:50:18 +0000164#ifndef FEAT_SPELL
Bram Moolenaarb765d632005-06-07 21:00:02 +0000165# define ex_spell ex_ni
Bram Moolenaar402d2fe2005-04-15 21:00:38 +0000166# define ex_mkspell ex_ni
Bram Moolenaarf417f2b2005-06-23 22:29:21 +0000167# define ex_spelldump ex_ni
Bram Moolenaar362e1a32006-03-06 23:29:24 +0000168# define ex_spellinfo ex_ni
Bram Moolenaara1ba8112005-06-28 23:23:32 +0000169# define ex_spellrepall ex_ni
Bram Moolenaar402d2fe2005-04-15 21:00:38 +0000170#endif
Bram Moolenaar55debbe2010-05-23 23:34:36 +0200171#ifndef FEAT_PERSISTENT_UNDO
172# define ex_rundo ex_ni
173# define ex_wundo ex_ni
174#endif
Bram Moolenaar0ba04292010-07-14 23:23:17 +0200175#ifndef FEAT_LUA
176# define ex_lua ex_script_ni
177# define ex_luado ex_ni
178# define ex_luafile ex_ni
179#endif
Bram Moolenaar325b7a22004-07-05 15:58:32 +0000180#ifndef FEAT_MZSCHEME
181# define ex_mzscheme ex_script_ni
182# define ex_mzfile ex_ni
183#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000184#ifndef FEAT_PERL
185# define ex_perl ex_script_ni
186# define ex_perldo ex_ni
187#endif
188#ifndef FEAT_PYTHON
189# define ex_python ex_script_ni
Bram Moolenaard620aa92013-05-17 16:40:06 +0200190# define ex_pydo ex_ni
Bram Moolenaar071d4272004-06-13 20:20:40 +0000191# define ex_pyfile ex_ni
192#endif
Bram Moolenaarbd5e15f2010-07-17 21:19:38 +0200193#ifndef FEAT_PYTHON3
Bram Moolenaar368373e2010-07-19 20:46:22 +0200194# define ex_py3 ex_script_ni
Bram Moolenaar3dab2802013-05-15 18:28:13 +0200195# define ex_py3do ex_ni
Bram Moolenaarbd5e15f2010-07-17 21:19:38 +0200196# define ex_py3file ex_ni
197#endif
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +0100198#if !defined(FEAT_PYTHON) && !defined(FEAT_PYTHON3)
199# define ex_pyx ex_script_ni
200# define ex_pyxdo ex_ni
201# define ex_pyxfile ex_ni
202#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000203#ifndef FEAT_TCL
204# define ex_tcl ex_script_ni
205# define ex_tcldo ex_ni
206# define ex_tclfile ex_ni
207#endif
208#ifndef FEAT_RUBY
209# define ex_ruby ex_script_ni
210# define ex_rubydo ex_ni
211# define ex_rubyfile ex_ni
212#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000213#ifndef FEAT_KEYMAP
214# define ex_loadkeymap ex_ni
215#endif
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100216static void ex_swapname(exarg_T *eap);
217static void ex_syncbind(exarg_T *eap);
218static void ex_read(exarg_T *eap);
219static void ex_pwd(exarg_T *eap);
220static void ex_equal(exarg_T *eap);
221static void ex_sleep(exarg_T *eap);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100222static void ex_winsize(exarg_T *eap);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100223static void ex_wincmd(exarg_T *eap);
Bram Moolenaar843ee412004-06-30 16:16:41 +0000224#if defined(FEAT_GUI) || defined(UNIX) || defined(VMS) || defined(MSWIN)
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100225static void ex_winpos(exarg_T *eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000226#else
227# define ex_winpos ex_ni
228#endif
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100229static void ex_operators(exarg_T *eap);
230static void ex_put(exarg_T *eap);
231static void ex_copymove(exarg_T *eap);
232static void ex_submagic(exarg_T *eap);
233static void ex_join(exarg_T *eap);
234static void ex_at(exarg_T *eap);
235static void ex_bang(exarg_T *eap);
236static void ex_undo(exarg_T *eap);
Bram Moolenaar55debbe2010-05-23 23:34:36 +0200237#ifdef FEAT_PERSISTENT_UNDO
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100238static void ex_wundo(exarg_T *eap);
239static void ex_rundo(exarg_T *eap);
Bram Moolenaar55debbe2010-05-23 23:34:36 +0200240#endif
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100241static void ex_redo(exarg_T *eap);
242static void ex_later(exarg_T *eap);
243static void ex_redir(exarg_T *eap);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100244static void ex_redrawstatus(exarg_T *eap);
Bram Moolenaare12bab32019-01-08 22:02:56 +0100245static void ex_redrawtabline(exarg_T *eap);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100246static void close_redir(void);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100247static void ex_mark(exarg_T *eap);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100248static void ex_startinsert(exarg_T *eap);
249static void ex_stopinsert(exarg_T *eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000250#ifdef FEAT_FIND_ID
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100251static void ex_checkpath(exarg_T *eap);
252static void ex_findpat(exarg_T *eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000253#else
254# define ex_findpat ex_ni
255# define ex_checkpath ex_ni
256#endif
Bram Moolenaar4033c552017-09-16 20:54:51 +0200257#if defined(FEAT_FIND_ID) && defined(FEAT_QUICKFIX)
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100258static void ex_psearch(exarg_T *eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000259#else
260# define ex_psearch ex_ni
261#endif
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100262static void ex_tag(exarg_T *eap);
263static void ex_tag_cmd(exarg_T *eap, char_u *name);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000264#ifndef FEAT_EVAL
Bram Moolenaar1b1e9df2020-10-10 22:26:52 +0200265# define ex_block ex_ni
Bram Moolenaare4ce8252019-08-04 15:30:16 +0200266# define ex_break ex_ni
267# define ex_breakadd ex_ni
268# define ex_breakdel ex_ni
269# define ex_breaklist ex_ni
270# define ex_call ex_ni
271# define ex_catch ex_ni
272# define ex_compiler ex_ni
Bram Moolenaare4ce8252019-08-04 15:30:16 +0200273# define ex_continue ex_ni
274# define ex_debug ex_ni
275# define ex_debuggreedy ex_ni
Bram Moolenaar822ba242020-05-24 23:00:18 +0200276# define ex_defcompile ex_ni
Bram Moolenaare4ce8252019-08-04 15:30:16 +0200277# define ex_delfunction ex_ni
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100278# define ex_disassemble ex_ni
Bram Moolenaar071d4272004-06-13 20:20:40 +0000279# define ex_echo ex_ni
280# define ex_echohl ex_ni
Bram Moolenaar071d4272004-06-13 20:20:40 +0000281# define ex_else ex_ni
Bram Moolenaar1b1e9df2020-10-10 22:26:52 +0200282# define ex_endblock ex_ni
Bram Moolenaare4ce8252019-08-04 15:30:16 +0200283# define ex_endfunction ex_ni
284# define ex_endif ex_ni
285# define ex_endtry ex_ni
Bram Moolenaar071d4272004-06-13 20:20:40 +0000286# define ex_endwhile ex_ni
Bram Moolenaare4ce8252019-08-04 15:30:16 +0200287# define ex_eval ex_ni
288# define ex_execute ex_ni
Bram Moolenaar340c59e2021-04-24 20:37:03 +0200289# define ex_incdec ex_ni
Bram Moolenaare4ce8252019-08-04 15:30:16 +0200290# define ex_finally ex_ni
291# define ex_finish ex_ni
292# define ex_function ex_ni
293# define ex_if ex_ni
294# define ex_let ex_ni
Bram Moolenaard47f50b2020-09-26 15:20:42 +0200295# define ex_var ex_ni
Bram Moolenaare4ce8252019-08-04 15:30:16 +0200296# define ex_lockvar ex_ni
297# define ex_oldfiles ex_ni
298# define ex_options ex_ni
299# define ex_packadd ex_ni
300# define ex_packloadall ex_ni
301# define ex_return ex_ni
302# define ex_scriptnames ex_ni
Bram Moolenaar071d4272004-06-13 20:20:40 +0000303# define ex_throw ex_ni
304# define ex_try ex_ni
Bram Moolenaar071d4272004-06-13 20:20:40 +0000305# define ex_unlet ex_ni
Bram Moolenaar65c1b012005-01-31 19:02:28 +0000306# define ex_unlockvar ex_ni
Bram Moolenaare4ce8252019-08-04 15:30:16 +0200307# define ex_while ex_ni
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100308# define ex_import ex_ni
309# define ex_export ex_ni
Bram Moolenaar071d4272004-06-13 20:20:40 +0000310#endif
Bram Moolenaar84538072019-07-28 14:15:42 +0200311#ifndef FEAT_SESSION
Bram Moolenaar071d4272004-06-13 20:20:40 +0000312# define ex_loadview ex_ni
313#endif
Bram Moolenaardefa0672019-07-21 19:25:37 +0200314#ifndef FEAT_VIMINFO
Bram Moolenaar071d4272004-06-13 20:20:40 +0000315# define ex_viminfo ex_ni
316#endif
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100317static void ex_behave(exarg_T *eap);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100318static void ex_filetype(exarg_T *eap);
319static void ex_setfiletype(exarg_T *eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000320#ifndef FEAT_DIFF
Bram Moolenaar2df6dcc2004-07-12 15:53:54 +0000321# define ex_diffoff ex_ni
Bram Moolenaar071d4272004-06-13 20:20:40 +0000322# define ex_diffpatch ex_ni
323# define ex_diffgetput ex_ni
324# define ex_diffsplit ex_ni
325# define ex_diffthis ex_ni
326# define ex_diffupdate ex_ni
327#endif
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100328static void ex_digraphs(exarg_T *eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000329#ifdef FEAT_SEARCH_EXTRA
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100330static void ex_nohlsearch(exarg_T *eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000331#else
332# define ex_nohlsearch ex_ni
333# define ex_match ex_ni
334#endif
335#ifdef FEAT_CRYPT
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100336static void ex_X(exarg_T *eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000337#else
338# define ex_X ex_ni
339#endif
340#ifdef FEAT_FOLDING
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100341static void ex_fold(exarg_T *eap);
342static void ex_foldopen(exarg_T *eap);
343static void ex_folddo(exarg_T *eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000344#else
345# define ex_fold ex_ni
346# define ex_foldopen ex_ni
347# define ex_folddo ex_ni
348#endif
Bram Moolenaar13505972019-01-24 15:04:48 +0100349#if !(defined(HAVE_LOCALE_H) || defined(X_LOCALE))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000350# define ex_language ex_ni
351#endif
352#ifndef FEAT_SIGNS
353# define ex_sign ex_ni
354#endif
Bram Moolenaar009b2592004-10-24 19:18:58 +0000355#ifndef FEAT_NETBEANS_INTG
Bram Moolenaarb26e6322010-05-22 21:34:09 +0200356# define ex_nbclose ex_ni
Bram Moolenaar009b2592004-10-24 19:18:58 +0000357# define ex_nbkey ex_ni
Bram Moolenaarb26e6322010-05-22 21:34:09 +0200358# define ex_nbstart ex_ni
Bram Moolenaar009b2592004-10-24 19:18:58 +0000359#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000360
Bram Moolenaar05159a02005-02-26 23:04:13 +0000361#ifndef FEAT_PROFILE
362# define ex_profile ex_ni
363#endif
Bram Moolenaare4f25e42017-07-07 11:54:15 +0200364#ifndef FEAT_TERMINAL
365# define ex_terminal ex_ni
366#endif
Bram Moolenaard4aa83a2019-05-09 18:59:31 +0200367#if !defined(FEAT_X11) || !defined(FEAT_XCLIPBOARD)
368# define ex_xrestore ex_ni
369#endif
Bram Moolenaar05ad5ff2019-11-30 22:48:27 +0100370#if !defined(FEAT_PROP_POPUP)
Bram Moolenaar682725c2019-05-25 20:10:37 +0200371# define ex_popupclear ex_ni
372#endif
Bram Moolenaar05159a02005-02-26 23:04:13 +0000373
Bram Moolenaar071d4272004-06-13 20:20:40 +0000374/*
375 * Declare cmdnames[].
376 */
377#define DO_DECLARE_EXCMD
378#include "ex_cmds.h"
Bram Moolenaar6de5e122017-04-20 21:55:44 +0200379#include "ex_cmdidxs.h"
Bram Moolenaare5e0fbc2017-03-25 14:51:01 +0100380
Bram Moolenaar071d4272004-06-13 20:20:40 +0000381static char_u dollar_command[2] = {'$', 0};
382
383
384#ifdef FEAT_EVAL
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100385// Struct for storing a line inside a while/for loop
Bram Moolenaar071d4272004-06-13 20:20:40 +0000386typedef struct
387{
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100388 char_u *line; // command line
389 linenr_T lnum; // sourcing_lnum of the line
Bram Moolenaar071d4272004-06-13 20:20:40 +0000390} wcmd_T;
391
392/*
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000393 * Structure used to store info for line position in a while or for loop.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000394 * This is required, because do_one_cmd() may invoke ex_function(), which
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000395 * reads more lines that may come from the while/for loop.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000396 */
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000397struct loop_cookie
Bram Moolenaar071d4272004-06-13 20:20:40 +0000398{
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100399 garray_T *lines_gap; // growarray with line info
400 int current_line; // last read line from growarray
401 int repeating; // TRUE when looping a second time
402 // When "repeating" is FALSE use "getline" and "cookie" to get lines
Bram Moolenaar20b23c62020-08-20 15:25:00 +0200403 char_u *(*getline)(int, void *, int, getline_opt_T);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000404 void *cookie;
405};
406
Bram Moolenaar20b23c62020-08-20 15:25:00 +0200407static char_u *get_loop_line(int c, void *cookie, int indent, getline_opt_T options);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100408static int store_loop_line(garray_T *gap, char_u *line);
409static void free_cmdlines(garray_T *gap);
Bram Moolenaared203462004-06-16 11:19:22 +0000410
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100411// Struct to save a few things while debugging. Used in do_cmdline() only.
Bram Moolenaared203462004-06-16 11:19:22 +0000412struct dbg_stuff
413{
414 int trylevel;
415 int force_abort;
416 except_T *caught_stack;
417 char_u *vv_exception;
418 char_u *vv_throwpoint;
419 int did_emsg;
420 int got_int;
421 int did_throw;
422 int need_rethrow;
423 int check_cstack;
424 except_T *current_exception;
425};
426
Bram Moolenaared203462004-06-16 11:19:22 +0000427 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +0100428save_dbg_stuff(struct dbg_stuff *dsp)
Bram Moolenaared203462004-06-16 11:19:22 +0000429{
430 dsp->trylevel = trylevel; trylevel = 0;
431 dsp->force_abort = force_abort; force_abort = FALSE;
432 dsp->caught_stack = caught_stack; caught_stack = NULL;
433 dsp->vv_exception = v_exception(NULL);
434 dsp->vv_throwpoint = v_throwpoint(NULL);
435
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100436 // Necessary for debugging an inactive ":catch", ":finally", ":endtry"
Bram Moolenaared203462004-06-16 11:19:22 +0000437 dsp->did_emsg = did_emsg; did_emsg = FALSE;
438 dsp->got_int = got_int; got_int = FALSE;
439 dsp->did_throw = did_throw; did_throw = FALSE;
440 dsp->need_rethrow = need_rethrow; need_rethrow = FALSE;
441 dsp->check_cstack = check_cstack; check_cstack = FALSE;
442 dsp->current_exception = current_exception; current_exception = NULL;
443}
444
445 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +0100446restore_dbg_stuff(struct dbg_stuff *dsp)
Bram Moolenaared203462004-06-16 11:19:22 +0000447{
448 suppress_errthrow = FALSE;
449 trylevel = dsp->trylevel;
450 force_abort = dsp->force_abort;
451 caught_stack = dsp->caught_stack;
452 (void)v_exception(dsp->vv_exception);
453 (void)v_throwpoint(dsp->vv_throwpoint);
454 did_emsg = dsp->did_emsg;
455 got_int = dsp->got_int;
456 did_throw = dsp->did_throw;
457 need_rethrow = dsp->need_rethrow;
458 check_cstack = dsp->check_cstack;
459 current_exception = dsp->current_exception;
460}
Bram Moolenaar071d4272004-06-13 20:20:40 +0000461#endif
462
Bram Moolenaar071d4272004-06-13 20:20:40 +0000463/*
464 * do_exmode(): Repeatedly get commands for the "Ex" mode, until the ":vi"
465 * command is given.
466 */
467 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +0100468do_exmode(
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100469 int improved) // TRUE for "improved Ex" mode
Bram Moolenaar071d4272004-06-13 20:20:40 +0000470{
471 int save_msg_scroll;
472 int prev_msg_row;
473 linenr_T prev_line;
Bram Moolenaar79518e22017-02-17 16:31:35 +0100474 varnumber_T changedtick;
Bram Moolenaardf177f62005-02-22 08:39:57 +0000475
476 if (improved)
477 exmode_active = EXMODE_VIM;
478 else
479 exmode_active = EXMODE_NORMAL;
480 State = NORMAL;
=?UTF-8?q?Magnus=20Gro=C3=9F?=f1e88762021-09-12 13:39:55 +0200481 trigger_modechanged();
Bram Moolenaardf177f62005-02-22 08:39:57 +0000482
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100483 // When using ":global /pat/ visual" and then "Q" we return to continue
484 // the :global command.
Bram Moolenaardf177f62005-02-22 08:39:57 +0000485 if (global_busy)
486 return;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000487
488 save_msg_scroll = msg_scroll;
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100489 ++RedrawingDisabled; // don't redisplay the window
490 ++no_wait_return; // don't wait for return
Bram Moolenaar071d4272004-06-13 20:20:40 +0000491#ifdef FEAT_GUI
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100492 // Ignore scrollbar and mouse events in Ex mode
Bram Moolenaar071d4272004-06-13 20:20:40 +0000493 ++hold_gui_events;
494#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000495
Bram Moolenaar32526b32019-01-19 17:43:09 +0100496 msg(_("Entering Ex mode. Type \"visual\" to go to Normal mode."));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000497 while (exmode_active)
498 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100499 // Check for a ":normal" command and no more characters left.
Bram Moolenaar7c626922005-02-07 22:01:03 +0000500 if (ex_normal_busy > 0 && typebuf.tb_len == 0)
501 {
502 exmode_active = FALSE;
503 break;
504 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000505 msg_scroll = TRUE;
506 need_wait_return = FALSE;
507 ex_pressedreturn = FALSE;
508 ex_no_reprint = FALSE;
Bram Moolenaar95c526e2017-02-25 14:59:34 +0100509 changedtick = CHANGEDTICK(curbuf);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000510 prev_msg_row = msg_row;
511 prev_line = curwin->w_cursor.lnum;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000512 if (improved)
513 {
514 cmdline_row = msg_row;
515 do_cmdline(NULL, getexline, NULL, 0);
516 }
517 else
518 do_cmdline(NULL, getexmodeline, NULL, DOCMD_NOWAIT);
519 lines_left = Rows - 1;
520
Bram Moolenaardf177f62005-02-22 08:39:57 +0000521 if ((prev_line != curwin->w_cursor.lnum
Bram Moolenaar95c526e2017-02-25 14:59:34 +0100522 || changedtick != CHANGEDTICK(curbuf)) && !ex_no_reprint)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000523 {
Bram Moolenaardf177f62005-02-22 08:39:57 +0000524 if (curbuf->b_ml.ml_flags & ML_EMPTY)
Bram Moolenaar74409f62022-01-01 15:58:22 +0000525 emsg(_(e_empty_buffer));
Bram Moolenaardf177f62005-02-22 08:39:57 +0000526 else
Bram Moolenaar071d4272004-06-13 20:20:40 +0000527 {
Bram Moolenaardf177f62005-02-22 08:39:57 +0000528 if (ex_pressedreturn)
529 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100530 // go up one line, to overwrite the ":<CR>" line, so the
531 // output doesn't contain empty lines.
Bram Moolenaardf177f62005-02-22 08:39:57 +0000532 msg_row = prev_msg_row;
533 if (prev_msg_row == Rows - 1)
534 msg_row--;
535 }
536 msg_col = 0;
537 print_line_no_prefix(curwin->w_cursor.lnum, FALSE, FALSE);
538 msg_clr_eos();
Bram Moolenaar071d4272004-06-13 20:20:40 +0000539 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000540 }
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100541 else if (ex_pressedreturn && !ex_no_reprint) // must be at EOF
Bram Moolenaardf177f62005-02-22 08:39:57 +0000542 {
543 if (curbuf->b_ml.ml_flags & ML_EMPTY)
Bram Moolenaar74409f62022-01-01 15:58:22 +0000544 emsg(_(e_empty_buffer));
Bram Moolenaardf177f62005-02-22 08:39:57 +0000545 else
Bram Moolenaarb09feaa2022-01-02 20:20:45 +0000546 emsg(_(e_at_end_of_file));
Bram Moolenaardf177f62005-02-22 08:39:57 +0000547 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000548 }
549
550#ifdef FEAT_GUI
551 --hold_gui_events;
552#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000553 --RedrawingDisabled;
554 --no_wait_return;
555 update_screen(CLEAR);
556 need_wait_return = FALSE;
557 msg_scroll = save_msg_scroll;
558}
559
560/*
Bram Moolenaar4facea32019-10-12 20:17:40 +0200561 * Print the executed command for when 'verbose' is set.
562 * When "lnum" is 0 only print the command.
563 */
564 static void
565msg_verbose_cmd(linenr_T lnum, char_u *cmd)
566{
567 ++no_wait_return;
568 verbose_enter_scroll();
569
570 if (lnum == 0)
571 smsg(_("Executing: %s"), cmd);
572 else
573 smsg(_("line %ld: %s"), (long)lnum, cmd);
574 if (msg_silent == 0)
575 msg_puts("\n"); // don't overwrite this
576
577 verbose_leave_scroll();
578 --no_wait_return;
579}
580
581/*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000582 * Execute a simple command line. Used for translated commands like "*".
583 */
584 int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +0100585do_cmdline_cmd(char_u *cmd)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000586{
587 return do_cmdline(cmd, NULL, NULL,
588 DOCMD_VERBOSE|DOCMD_NOWAIT|DOCMD_KEYTYPED);
589}
590
591/*
Bram Moolenaar47a2abf2020-11-25 20:12:11 +0100592 * Execute the "+cmd" argument of "edit +cmd fname" and the like.
593 * This allows for using a range without ":" in Vim9 script.
594 */
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +0200595 static int
Bram Moolenaar47a2abf2020-11-25 20:12:11 +0100596do_cmd_argument(char_u *cmd)
597{
598 return do_cmdline(cmd, NULL, NULL,
599 DOCMD_VERBOSE|DOCMD_NOWAIT|DOCMD_KEYTYPED|DOCMD_RANGEOK);
600}
601
602/*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000603 * do_cmdline(): execute one Ex command line
604 *
605 * 1. Execute "cmdline" when it is not NULL.
Bram Moolenaarbf55e142010-11-16 11:32:01 +0100606 * If "cmdline" is NULL, or more lines are needed, fgetline() is used.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000607 * 2. Split up in parts separated with '|'.
608 *
609 * This function can be called recursively!
610 *
611 * flags:
612 * DOCMD_VERBOSE - The command will be included in the error message.
613 * DOCMD_NOWAIT - Don't call wait_return() and friends.
Bram Moolenaarbf55e142010-11-16 11:32:01 +0100614 * DOCMD_REPEAT - Repeat execution until fgetline() returns NULL.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000615 * DOCMD_KEYTYPED - Don't reset KeyTyped.
616 * DOCMD_EXCRESET - Reset the exception environment (used for debugging).
617 * DOCMD_KEEPLINE - Store first typed line (for repeating with ".").
618 *
619 * return FAIL if cmdline could not be executed, OK otherwise
620 */
621 int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +0100622do_cmdline(
623 char_u *cmdline,
Bram Moolenaar66250c92020-08-20 15:02:42 +0200624 char_u *(*fgetline)(int, void *, int, getline_opt_T),
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100625 void *cookie, // argument for fgetline()
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +0100626 int flags)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000627{
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100628 char_u *next_cmdline; // next cmd to execute
629 char_u *cmdline_copy = NULL; // copy of cmd line
630 int used_getline = FALSE; // used "fgetline" to obtain command
631 static int recursive = 0; // recursive depth
Bram Moolenaar071d4272004-06-13 20:20:40 +0000632 int msg_didout_before_start = 0;
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100633 int count = 0; // line number count
634 int did_inc = FALSE; // incremented RedrawingDisabled
Bram Moolenaar071d4272004-06-13 20:20:40 +0000635 int retval = OK;
636#ifdef FEAT_EVAL
Bram Moolenaarddef1292019-12-16 17:10:33 +0100637 cstack_T cstack; // conditional stack
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100638 garray_T lines_ga; // keep lines for ":while"/":for"
639 int current_line = 0; // active line in lines_ga
Bram Moolenaard5053d02020-06-28 15:51:16 +0200640 int current_line_before = 0;
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100641 char_u *fname = NULL; // function or script name
642 linenr_T *breakpoint = NULL; // ptr to breakpoint field in cookie
643 int *dbg_tick = NULL; // ptr to dbg_tick field in cookie
644 struct dbg_stuff debug_saved; // saved things for debug mode
Bram Moolenaar071d4272004-06-13 20:20:40 +0000645 int initial_trylevel;
Bram Moolenaar25e0f582020-05-25 22:36:50 +0200646 msglist_T **saved_msg_list = NULL;
Bram Moolenaar683581e2020-10-22 21:22:58 +0200647 msglist_T *private_msg_list = NULL;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000648
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100649 // "fgetline" and "cookie" passed to do_one_cmd()
Bram Moolenaar66250c92020-08-20 15:02:42 +0200650 char_u *(*cmd_getline)(int, void *, int, getline_opt_T);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000651 void *cmd_cookie;
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000652 struct loop_cookie cmd_loop_cookie;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000653 void *real_cookie;
Bram Moolenaar05159a02005-02-26 23:04:13 +0000654 int getline_is_func;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000655#else
Bram Moolenaarbf55e142010-11-16 11:32:01 +0100656# define cmd_getline fgetline
Bram Moolenaar071d4272004-06-13 20:20:40 +0000657# define cmd_cookie cookie
658#endif
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100659 static int call_depth = 0; // recursiveness
Bram Moolenaar2196bce2020-04-12 20:01:11 +0200660#ifdef FEAT_EVAL
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100661 // For every pair of do_cmdline()/do_one_cmd() calls, use an extra memory
662 // location for storing error messages to be converted to an exception.
663 // This ensures that the do_errthrow() call in do_one_cmd() does not
664 // combine the messages stored by an earlier invocation of do_one_cmd()
665 // with the command name of the later one. This would happen when
666 // BufWritePost autocommands are executed after a write error.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000667 saved_msg_list = msg_list;
668 msg_list = &private_msg_list;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000669#endif
670
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100671 // It's possible to create an endless loop with ":execute", catch that
672 // here. The value of 200 allows nested function calls, ":source", etc.
673 // Allow 200 or 'maxfuncdepth', whatever is larger.
Bram Moolenaarb094ff42017-01-02 16:16:39 +0100674 if (call_depth >= 200
675#ifdef FEAT_EVAL
676 && call_depth >= p_mfd
677#endif
678 )
Bram Moolenaar071d4272004-06-13 20:20:40 +0000679 {
Bram Moolenaar1a992222021-12-31 17:25:48 +0000680 emsg(_(e_command_too_recursive));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000681#ifdef FEAT_EVAL
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100682 // When converting to an exception, we do not include the command name
683 // since this is not an error of the specific command.
Bram Moolenaarddef1292019-12-16 17:10:33 +0100684 do_errthrow((cstack_T *)NULL, (char_u *)NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000685 msg_list = saved_msg_list;
686#endif
687 return FAIL;
688 }
689 ++call_depth;
690
691#ifdef FEAT_EVAL
Bram Moolenaarce0370d2021-01-26 19:32:53 +0100692 CLEAR_FIELD(cstack);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000693 cstack.cs_idx = -1;
Bram Moolenaar04935fb2022-01-08 16:19:22 +0000694 ga_init2(&lines_ga, sizeof(wcmd_T), 10);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000695
Bram Moolenaarbf55e142010-11-16 11:32:01 +0100696 real_cookie = getline_cookie(fgetline, cookie);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000697
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100698 // Inside a function use a higher nesting level.
Bram Moolenaarbf55e142010-11-16 11:32:01 +0100699 getline_is_func = getline_equal(fgetline, cookie, get_func_line);
Bram Moolenaar05159a02005-02-26 23:04:13 +0000700 if (getline_is_func && ex_nesting_level == func_level(real_cookie))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000701 ++ex_nesting_level;
702
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100703 // Get the function or script name and the address where the next breakpoint
704 // line and the debug tick for a function or script are stored.
Bram Moolenaar05159a02005-02-26 23:04:13 +0000705 if (getline_is_func)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000706 {
707 fname = func_name(real_cookie);
708 breakpoint = func_breakpoint(real_cookie);
709 dbg_tick = func_dbg_tick(real_cookie);
710 }
Bram Moolenaarbf55e142010-11-16 11:32:01 +0100711 else if (getline_equal(fgetline, cookie, getsourceline))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000712 {
Bram Moolenaar1a47ae32019-12-29 23:04:25 +0100713 fname = SOURCING_NAME;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000714 breakpoint = source_breakpoint(real_cookie);
715 dbg_tick = source_dbg_tick(real_cookie);
716 }
717
718 /*
719 * Initialize "force_abort" and "suppress_errthrow" at the top level.
720 */
721 if (!recursive)
722 {
723 force_abort = FALSE;
724 suppress_errthrow = FALSE;
725 }
726
727 /*
728 * If requested, store and reset the global values controlling the
Bram Moolenaar89d40322006-08-29 15:30:07 +0000729 * exception handling (used when debugging). Otherwise clear it to avoid
730 * a bogus compiler warning when the optimizer uses inline functions...
Bram Moolenaar071d4272004-06-13 20:20:40 +0000731 */
Bram Moolenaarb4872942006-05-13 10:32:52 +0000732 if (flags & DOCMD_EXCRESET)
Bram Moolenaared203462004-06-16 11:19:22 +0000733 save_dbg_stuff(&debug_saved);
Bram Moolenaar89d40322006-08-29 15:30:07 +0000734 else
Bram Moolenaara80faa82020-04-12 19:37:17 +0200735 CLEAR_FIELD(debug_saved);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000736
737 initial_trylevel = trylevel;
738
739 /*
740 * "did_throw" will be set to TRUE when an exception is being thrown.
741 */
742 did_throw = FALSE;
743#endif
744 /*
745 * "did_emsg" will be set to TRUE when emsg() is used, in which case we
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000746 * cancel the whole command line, and any if/endif or loop.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000747 * If force_abort is set, we cancel everything.
748 */
Bram Moolenaareeece9e2020-11-20 19:26:48 +0100749#ifdef FEAT_EVAL
750 did_emsg_cumul += did_emsg;
751#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000752 did_emsg = FALSE;
753
754 /*
755 * KeyTyped is only set when calling vgetc(). Reset it here when not
756 * calling vgetc() (sourced command lines).
757 */
Bram Moolenaarbf55e142010-11-16 11:32:01 +0100758 if (!(flags & DOCMD_KEYTYPED)
759 && !getline_equal(fgetline, cookie, getexline))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000760 KeyTyped = FALSE;
761
762 /*
763 * Continue executing command lines:
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000764 * - when inside an ":if", ":while" or ":for"
Bram Moolenaar071d4272004-06-13 20:20:40 +0000765 * - for multiple commands on one line, separated with '|'
766 * - when repeating until there are no more lines (for ":source")
767 */
768 next_cmdline = cmdline;
769 do
770 {
Bram Moolenaar05159a02005-02-26 23:04:13 +0000771#ifdef FEAT_EVAL
Bram Moolenaarbf55e142010-11-16 11:32:01 +0100772 getline_is_func = getline_equal(fgetline, cookie, get_func_line);
Bram Moolenaar05159a02005-02-26 23:04:13 +0000773#endif
774
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100775 // stop skipping cmds for an error msg after all endif/while/for
Bram Moolenaar071d4272004-06-13 20:20:40 +0000776 if (next_cmdline == NULL
777#ifdef FEAT_EVAL
778 && !force_abort
779 && cstack.cs_idx < 0
Bram Moolenaar05159a02005-02-26 23:04:13 +0000780 && !(getline_is_func && func_has_abort(real_cookie))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000781#endif
782 )
Bram Moolenaareeece9e2020-11-20 19:26:48 +0100783 {
784#ifdef FEAT_EVAL
785 did_emsg_cumul += did_emsg;
786#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000787 did_emsg = FALSE;
Bram Moolenaareeece9e2020-11-20 19:26:48 +0100788 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000789
790 /*
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000791 * 1. If repeating a line in a loop, get a line from lines_ga.
Bram Moolenaarbf55e142010-11-16 11:32:01 +0100792 * 2. If no line given: Get an allocated line with fgetline().
Bram Moolenaar071d4272004-06-13 20:20:40 +0000793 * 3. If a line is given: Make a copy, so we can mess with it.
794 */
795
796#ifdef FEAT_EVAL
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100797 // 1. If repeating, get a previous line from lines_ga.
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000798 if (cstack.cs_looplevel > 0 && current_line < lines_ga.ga_len)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000799 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100800 // Each '|' separated command is stored separately in lines_ga, to
801 // be able to jump to it. Don't use next_cmdline now.
Bram Moolenaard23a8232018-02-10 18:45:26 +0100802 VIM_CLEAR(cmdline_copy);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000803
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100804 // Check if a function has returned or, unless it has an unclosed
805 // try conditional, aborted.
Bram Moolenaar05159a02005-02-26 23:04:13 +0000806 if (getline_is_func)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000807 {
Bram Moolenaar05159a02005-02-26 23:04:13 +0000808# ifdef FEAT_PROFILE
Bram Moolenaar371d5402006-03-20 21:47:49 +0000809 if (do_profiling == PROF_YES)
Bram Moolenaar05159a02005-02-26 23:04:13 +0000810 func_line_end(real_cookie);
811# endif
812 if (func_has_ended(real_cookie))
813 {
814 retval = FAIL;
815 break;
816 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000817 }
Bram Moolenaar05159a02005-02-26 23:04:13 +0000818#ifdef FEAT_PROFILE
Bram Moolenaar371d5402006-03-20 21:47:49 +0000819 else if (do_profiling == PROF_YES
Bram Moolenaarbf55e142010-11-16 11:32:01 +0100820 && getline_equal(fgetline, cookie, getsourceline))
Bram Moolenaar05159a02005-02-26 23:04:13 +0000821 script_line_end();
822#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000823
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100824 // Check if a sourced file hit a ":finish" command.
Bram Moolenaarbf55e142010-11-16 11:32:01 +0100825 if (source_finished(fgetline, cookie))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000826 {
827 retval = FAIL;
828 break;
829 }
830
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100831 // If breakpoints have been added/deleted need to check for it.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000832 if (breakpoint != NULL && dbg_tick != NULL
833 && *dbg_tick != debug_tick)
834 {
835 *breakpoint = dbg_find_breakpoint(
Bram Moolenaarbf55e142010-11-16 11:32:01 +0100836 getline_equal(fgetline, cookie, getsourceline),
Bram Moolenaar1a47ae32019-12-29 23:04:25 +0100837 fname, SOURCING_LNUM);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000838 *dbg_tick = debug_tick;
839 }
840
841 next_cmdline = ((wcmd_T *)(lines_ga.ga_data))[current_line].line;
Bram Moolenaar1a47ae32019-12-29 23:04:25 +0100842 SOURCING_LNUM = ((wcmd_T *)(lines_ga.ga_data))[current_line].lnum;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000843
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100844 // Did we encounter a breakpoint?
Bram Moolenaar071d4272004-06-13 20:20:40 +0000845 if (breakpoint != NULL && *breakpoint != 0
Bram Moolenaar1a47ae32019-12-29 23:04:25 +0100846 && *breakpoint <= SOURCING_LNUM)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000847 {
Bram Moolenaar1a47ae32019-12-29 23:04:25 +0100848 dbg_breakpoint(fname, SOURCING_LNUM);
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100849 // Find next breakpoint.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000850 *breakpoint = dbg_find_breakpoint(
Bram Moolenaarbf55e142010-11-16 11:32:01 +0100851 getline_equal(fgetline, cookie, getsourceline),
Bram Moolenaar1a47ae32019-12-29 23:04:25 +0100852 fname, SOURCING_LNUM);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000853 *dbg_tick = debug_tick;
854 }
Bram Moolenaar05159a02005-02-26 23:04:13 +0000855# ifdef FEAT_PROFILE
Bram Moolenaar371d5402006-03-20 21:47:49 +0000856 if (do_profiling == PROF_YES)
Bram Moolenaar05159a02005-02-26 23:04:13 +0000857 {
858 if (getline_is_func)
Bram Moolenaarb2049902021-01-24 12:53:53 +0100859 func_line_start(real_cookie, SOURCING_LNUM);
Bram Moolenaarbf55e142010-11-16 11:32:01 +0100860 else if (getline_equal(fgetline, cookie, getsourceline))
Bram Moolenaar05159a02005-02-26 23:04:13 +0000861 script_line_start();
862 }
863# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000864 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000865#endif
866
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100867 // 2. If no line given, get an allocated line with fgetline().
Bram Moolenaar071d4272004-06-13 20:20:40 +0000868 if (next_cmdline == NULL)
869 {
870 /*
871 * Need to set msg_didout for the first line after an ":if",
872 * otherwise the ":if" will be overwritten.
873 */
Bram Moolenaarbf55e142010-11-16 11:32:01 +0100874 if (count == 1 && getline_equal(fgetline, cookie, getexline))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000875 msg_didout = TRUE;
Bram Moolenaarbf55e142010-11-16 11:32:01 +0100876 if (fgetline == NULL || (next_cmdline = fgetline(':', cookie,
Bram Moolenaar071d4272004-06-13 20:20:40 +0000877#ifdef FEAT_EVAL
878 cstack.cs_idx < 0 ? 0 : (cstack.cs_idx + 1) * 2
879#else
880 0
881#endif
Bram Moolenaar8242ebb2020-12-29 11:15:01 +0100882 , in_vim9script() ? GETLINE_CONCAT_CONTBAR
883 : GETLINE_CONCAT_CONT)) == NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000884 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100885 // Don't call wait_return for aborted command line. The NULL
886 // returned for the end of a sourced file or executed function
887 // doesn't do this.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000888 if (KeyTyped && !(flags & DOCMD_REPEAT))
889 need_wait_return = FALSE;
890 retval = FAIL;
891 break;
892 }
893 used_getline = TRUE;
894
895 /*
896 * Keep the first typed line. Clear it when more lines are typed.
897 */
898 if (flags & DOCMD_KEEPLINE)
899 {
900 vim_free(repeat_cmdline);
901 if (count == 0)
902 repeat_cmdline = vim_strsave(next_cmdline);
903 else
904 repeat_cmdline = NULL;
905 }
906 }
907
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100908 // 3. Make a copy of the command so we can mess with it.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000909 else if (cmdline_copy == NULL)
910 {
911 next_cmdline = vim_strsave(next_cmdline);
912 if (next_cmdline == NULL)
913 {
Bram Moolenaare29a27f2021-07-20 21:07:36 +0200914 emsg(_(e_out_of_memory));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000915 retval = FAIL;
916 break;
917 }
918 }
919 cmdline_copy = next_cmdline;
920
921#ifdef FEAT_EVAL
922 /*
Bram Moolenaard5053d02020-06-28 15:51:16 +0200923 * Inside a while/for loop, and when the command looks like a ":while"
924 * or ":for", the line is stored, because we may need it later when
925 * looping.
926 *
927 * When there is a '|' and another command, it is stored separately,
928 * because we need to be able to jump back to it from an
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000929 * :endwhile/:endfor.
Bram Moolenaard5053d02020-06-28 15:51:16 +0200930 *
931 * Pass a different "fgetline" function to do_one_cmd() below,
932 * that it stores lines in or reads them from "lines_ga". Makes it
933 * possible to define a function inside a while/for loop and handles
934 * line continuation.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000935 */
Bram Moolenaard5053d02020-06-28 15:51:16 +0200936 if ((cstack.cs_looplevel > 0 || has_loop_cmd(next_cmdline)))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000937 {
Bram Moolenaard5053d02020-06-28 15:51:16 +0200938 cmd_getline = get_loop_line;
939 cmd_cookie = (void *)&cmd_loop_cookie;
940 cmd_loop_cookie.lines_gap = &lines_ga;
941 cmd_loop_cookie.current_line = current_line;
942 cmd_loop_cookie.getline = fgetline;
943 cmd_loop_cookie.cookie = cookie;
944 cmd_loop_cookie.repeating = (current_line < lines_ga.ga_len);
945
946 // Save the current line when encountering it the first time.
947 if (current_line == lines_ga.ga_len
948 && store_loop_line(&lines_ga, next_cmdline) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000949 {
950 retval = FAIL;
951 break;
952 }
Bram Moolenaard5053d02020-06-28 15:51:16 +0200953 current_line_before = current_line;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000954 }
Bram Moolenaard5053d02020-06-28 15:51:16 +0200955 else
956 {
957 cmd_getline = fgetline;
958 cmd_cookie = cookie;
959 }
960
Bram Moolenaar071d4272004-06-13 20:20:40 +0000961 did_endif = FALSE;
962#endif
963
964 if (count++ == 0)
965 {
966 /*
967 * All output from the commands is put below each other, without
968 * waiting for a return. Don't do this when executing commands
969 * from a script or when being called recursive (e.g. for ":e
970 * +command file").
971 */
972 if (!(flags & DOCMD_NOWAIT) && !recursive)
973 {
974 msg_didout_before_start = msg_didout;
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100975 msg_didany = FALSE; // no output yet
Bram Moolenaar071d4272004-06-13 20:20:40 +0000976 msg_start();
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100977 msg_scroll = TRUE; // put messages below each other
978 ++no_wait_return; // don't wait for return until finished
Bram Moolenaar071d4272004-06-13 20:20:40 +0000979 ++RedrawingDisabled;
980 did_inc = TRUE;
981 }
982 }
983
Bram Moolenaar823654b2020-05-29 23:03:09 +0200984 if ((p_verbose >= 15 && SOURCING_NAME != NULL) || p_verbose >= 16)
Bram Moolenaar1a47ae32019-12-29 23:04:25 +0100985 msg_verbose_cmd(SOURCING_LNUM, cmdline_copy);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000986
987 /*
988 * 2. Execute one '|' separated command.
989 * do_one_cmd() will return NULL if there is no trailing '|'.
990 * "cmdline_copy" can change, e.g. for '%' and '#' expansion.
991 */
992 ++recursive;
Bram Moolenaar47a2abf2020-11-25 20:12:11 +0100993 next_cmdline = do_one_cmd(&cmdline_copy, flags,
Bram Moolenaar071d4272004-06-13 20:20:40 +0000994#ifdef FEAT_EVAL
995 &cstack,
996#endif
997 cmd_getline, cmd_cookie);
998 --recursive;
999
1000#ifdef FEAT_EVAL
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001001 if (cmd_cookie == (void *)&cmd_loop_cookie)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001002 // Use "current_line" from "cmd_loop_cookie", it may have been
1003 // incremented when defining a function.
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001004 current_line = cmd_loop_cookie.current_line;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001005#endif
1006
1007 if (next_cmdline == NULL)
1008 {
Bram Moolenaard23a8232018-02-10 18:45:26 +01001009 VIM_CLEAR(cmdline_copy);
Bram Moolenaard7663c22019-08-06 21:59:57 +02001010
Bram Moolenaar071d4272004-06-13 20:20:40 +00001011 /*
1012 * If the command was typed, remember it for the ':' register.
1013 * Do this AFTER executing the command to make :@: work.
1014 */
Bram Moolenaarbf55e142010-11-16 11:32:01 +01001015 if (getline_equal(fgetline, cookie, getexline)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001016 && new_last_cmdline != NULL)
1017 {
1018 vim_free(last_cmdline);
1019 last_cmdline = new_last_cmdline;
1020 new_last_cmdline = NULL;
1021 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001022 }
1023 else
1024 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001025 // need to copy the command after the '|' to cmdline_copy, for the
1026 // next do_one_cmd()
Bram Moolenaara7241f52008-06-24 20:39:31 +00001027 STRMOVE(cmdline_copy, next_cmdline);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001028 next_cmdline = cmdline_copy;
1029 }
1030
1031
1032#ifdef FEAT_EVAL
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001033 // reset did_emsg for a function that is not aborted by an error
Bram Moolenaar071d4272004-06-13 20:20:40 +00001034 if (did_emsg && !force_abort
Bram Moolenaarbf55e142010-11-16 11:32:01 +01001035 && getline_equal(fgetline, cookie, get_func_line)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001036 && !func_has_abort(real_cookie))
Bram Moolenaareeece9e2020-11-20 19:26:48 +01001037 {
1038 // did_emsg_cumul is not set here
Bram Moolenaar071d4272004-06-13 20:20:40 +00001039 did_emsg = FALSE;
Bram Moolenaareeece9e2020-11-20 19:26:48 +01001040 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001041
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001042 if (cstack.cs_looplevel > 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001043 {
1044 ++current_line;
1045
1046 /*
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001047 * An ":endwhile", ":endfor" and ":continue" is handled here.
1048 * If we were executing commands, jump back to the ":while" or
1049 * ":for".
1050 * If we were not executing commands, decrement cs_looplevel.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001051 */
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001052 if (cstack.cs_lflags & (CSL_HAD_CONT | CSL_HAD_ENDLOOP))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001053 {
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001054 cstack.cs_lflags &= ~(CSL_HAD_CONT | CSL_HAD_ENDLOOP);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001055
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001056 // Jump back to the matching ":while" or ":for". Be careful
1057 // not to use a cs_line[] from an entry that isn't a ":while"
1058 // or ":for": It would make "current_line" invalid and can
1059 // cause a crash.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001060 if (!did_emsg && !got_int && !did_throw
1061 && cstack.cs_idx >= 0
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001062 && (cstack.cs_flags[cstack.cs_idx]
1063 & (CSF_WHILE | CSF_FOR))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001064 && cstack.cs_line[cstack.cs_idx] >= 0
1065 && (cstack.cs_flags[cstack.cs_idx] & CSF_ACTIVE))
1066 {
1067 current_line = cstack.cs_line[cstack.cs_idx];
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001068 // remember we jumped there
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001069 cstack.cs_lflags |= CSL_HAD_LOOP;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001070 line_breakcheck(); // check if CTRL-C typed
Bram Moolenaar071d4272004-06-13 20:20:40 +00001071
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001072 // Check for the next breakpoint at or after the ":while"
1073 // or ":for".
Bram Moolenaar071d4272004-06-13 20:20:40 +00001074 if (breakpoint != NULL)
1075 {
1076 *breakpoint = dbg_find_breakpoint(
Bram Moolenaarbf55e142010-11-16 11:32:01 +01001077 getline_equal(fgetline, cookie, getsourceline),
Bram Moolenaar071d4272004-06-13 20:20:40 +00001078 fname,
1079 ((wcmd_T *)lines_ga.ga_data)[current_line].lnum-1);
1080 *dbg_tick = debug_tick;
1081 }
1082 }
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001083 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00001084 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001085 // can only get here with ":endwhile" or ":endfor"
Bram Moolenaar071d4272004-06-13 20:20:40 +00001086 if (cstack.cs_idx >= 0)
Bram Moolenaarbb761a72005-01-06 23:19:09 +00001087 rewind_conditionals(&cstack, cstack.cs_idx - 1,
1088 CSF_WHILE | CSF_FOR, &cstack.cs_looplevel);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001089 }
1090 }
1091
1092 /*
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001093 * For a ":while" or ":for" we need to remember the line number.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001094 */
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001095 else if (cstack.cs_lflags & CSL_HAD_LOOP)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001096 {
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001097 cstack.cs_lflags &= ~CSL_HAD_LOOP;
Bram Moolenaard5053d02020-06-28 15:51:16 +02001098 cstack.cs_line[cstack.cs_idx] = current_line_before;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001099 }
1100 }
1101
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001102 // Check for the next breakpoint after a watchexpression
Bram Moolenaarc6f9f732018-02-11 19:06:26 +01001103 if (breakpoint != NULL && has_watchexpr())
1104 {
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01001105 *breakpoint = dbg_find_breakpoint(FALSE, fname, SOURCING_LNUM);
Bram Moolenaarc6f9f732018-02-11 19:06:26 +01001106 *dbg_tick = debug_tick;
1107 }
1108
Bram Moolenaar071d4272004-06-13 20:20:40 +00001109 /*
1110 * When not inside any ":while" loop, clear remembered lines.
1111 */
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001112 if (cstack.cs_looplevel == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001113 {
1114 if (lines_ga.ga_len > 0)
1115 {
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01001116 SOURCING_LNUM =
Bram Moolenaar071d4272004-06-13 20:20:40 +00001117 ((wcmd_T *)lines_ga.ga_data)[lines_ga.ga_len - 1].lnum;
1118 free_cmdlines(&lines_ga);
1119 }
1120 current_line = 0;
1121 }
1122
1123 /*
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001124 * A ":finally" makes did_emsg, got_int, and did_throw pending for
1125 * being restored at the ":endtry". Reset them here and set the
1126 * ACTIVE and FINALLY flags, so that the finally clause gets executed.
1127 * This includes the case where a missing ":endif", ":endwhile" or
1128 * ":endfor" was detected by the ":finally" itself.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001129 */
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001130 if (cstack.cs_lflags & CSL_HAD_FINA)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001131 {
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001132 cstack.cs_lflags &= ~CSL_HAD_FINA;
1133 report_make_pending(cstack.cs_pending[cstack.cs_idx]
1134 & (CSTP_ERROR | CSTP_INTERRUPT | CSTP_THROW),
Bram Moolenaar071d4272004-06-13 20:20:40 +00001135 did_throw ? (void *)current_exception : NULL);
1136 did_emsg = got_int = did_throw = FALSE;
1137 cstack.cs_flags[cstack.cs_idx] |= CSF_ACTIVE | CSF_FINALLY;
1138 }
1139
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001140 // Update global "trylevel" for recursive calls to do_cmdline() from
1141 // within this loop.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001142 trylevel = initial_trylevel + cstack.cs_trylevel;
1143
1144 /*
Bram Moolenaarc1762cc2007-05-10 16:56:30 +00001145 * If the outermost try conditional (across function calls and sourced
Bram Moolenaar071d4272004-06-13 20:20:40 +00001146 * files) is aborted because of an error, an interrupt, or an uncaught
1147 * exception, cancel everything. If it is left normally, reset
1148 * force_abort to get the non-EH compatible abortion behavior for
1149 * the rest of the script.
1150 */
1151 if (trylevel == 0 && !did_emsg && !got_int && !did_throw)
1152 force_abort = FALSE;
1153
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001154 // Convert an interrupt to an exception if appropriate.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001155 (void)do_intthrow(&cstack);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001156#endif // FEAT_EVAL
Bram Moolenaar071d4272004-06-13 20:20:40 +00001157
1158 }
1159 /*
1160 * Continue executing command lines when:
1161 * - no CTRL-C typed, no aborting error, no exception thrown or try
1162 * conditionals need to be checked for executing finally clauses or
1163 * catching an interrupt exception
1164 * - didn't get an error message or lines are not typed
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001165 * - there is a command after '|', inside a :if, :while, :for or :try, or
Bram Moolenaar071d4272004-06-13 20:20:40 +00001166 * looping for ":source" command or function call.
1167 */
1168 while (!((got_int
1169#ifdef FEAT_EVAL
Bram Moolenaar227c58a2021-04-28 20:40:44 +02001170 || (did_emsg && (force_abort || in_vim9script()))
1171 || did_throw
Bram Moolenaar071d4272004-06-13 20:20:40 +00001172#endif
1173 )
1174#ifdef FEAT_EVAL
1175 && cstack.cs_trylevel == 0
1176#endif
1177 )
Bram Moolenaar00b8ae02012-08-23 18:43:10 +02001178 && !(did_emsg
1179#ifdef FEAT_EVAL
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001180 // Keep going when inside try/catch, so that the error can be
1181 // deal with, except when it is a syntax error, it may cause
1182 // the :endtry to be missed.
Bram Moolenaar00b8ae02012-08-23 18:43:10 +02001183 && (cstack.cs_trylevel == 0 || did_emsg_syntax)
1184#endif
1185 && used_getline
Bram Moolenaarbf55e142010-11-16 11:32:01 +01001186 && (getline_equal(fgetline, cookie, getexmodeline)
1187 || getline_equal(fgetline, cookie, getexline)))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001188 && (next_cmdline != NULL
1189#ifdef FEAT_EVAL
1190 || cstack.cs_idx >= 0
1191#endif
1192 || (flags & DOCMD_REPEAT)));
1193
1194 vim_free(cmdline_copy);
Bram Moolenaar00b8ae02012-08-23 18:43:10 +02001195 did_emsg_syntax = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001196#ifdef FEAT_EVAL
1197 free_cmdlines(&lines_ga);
1198 ga_clear(&lines_ga);
1199
1200 if (cstack.cs_idx >= 0)
1201 {
1202 /*
1203 * If a sourced file or executed function ran to its end, report the
1204 * unclosed conditional.
Bram Moolenaar227c58a2021-04-28 20:40:44 +02001205 * In Vim9 script do not give a second error, executing aborts after
1206 * the first one.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001207 */
Bram Moolenaar227c58a2021-04-28 20:40:44 +02001208 if (!got_int && !did_throw && !(did_emsg && in_vim9script())
Bram Moolenaarbf55e142010-11-16 11:32:01 +01001209 && ((getline_equal(fgetline, cookie, getsourceline)
1210 && !source_finished(fgetline, cookie))
1211 || (getline_equal(fgetline, cookie, get_func_line)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001212 && !func_has_ended(real_cookie))))
1213 {
1214 if (cstack.cs_flags[cstack.cs_idx] & CSF_TRY)
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00001215 emsg(_(e_missing_endtry));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001216 else if (cstack.cs_flags[cstack.cs_idx] & CSF_WHILE)
Bram Moolenaar1a992222021-12-31 17:25:48 +00001217 emsg(_(e_missing_endwhile));
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001218 else if (cstack.cs_flags[cstack.cs_idx] & CSF_FOR)
Bram Moolenaar1a992222021-12-31 17:25:48 +00001219 emsg(_(e_missing_endfor));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001220 else
Bram Moolenaar1a992222021-12-31 17:25:48 +00001221 emsg(_(e_missing_endif));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001222 }
1223
1224 /*
1225 * Reset "trylevel" in case of a ":finish" or ":return" or a missing
1226 * ":endtry" in a sourced file or executed function. If the try
1227 * conditional is in its finally clause, ignore anything pending.
1228 * If it is in a catch clause, finish the caught exception.
Bram Moolenaarbb761a72005-01-06 23:19:09 +00001229 * Also cleanup any "cs_forinfo" structures.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001230 */
1231 do
Bram Moolenaarbb761a72005-01-06 23:19:09 +00001232 {
1233 int idx = cleanup_conditionals(&cstack, 0, TRUE);
1234
Bram Moolenaar89e5d682005-01-17 22:06:23 +00001235 if (idx >= 0)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001236 --idx; // remove try block not in its finally clause
Bram Moolenaarbb761a72005-01-06 23:19:09 +00001237 rewind_conditionals(&cstack, idx, CSF_WHILE | CSF_FOR,
1238 &cstack.cs_looplevel);
1239 }
1240 while (cstack.cs_idx >= 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001241 trylevel = initial_trylevel;
1242 }
1243
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001244 // If a missing ":endtry", ":endwhile", ":endfor", or ":endif" or a memory
1245 // lack was reported above and the error message is to be converted to an
1246 // exception, do this now after rewinding the cstack.
Bram Moolenaarbf55e142010-11-16 11:32:01 +01001247 do_errthrow(&cstack, getline_equal(fgetline, cookie, get_func_line)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001248 ? (char_u *)"endfunction" : (char_u *)NULL);
1249
1250 if (trylevel == 0)
1251 {
Bram Moolenaar820d55a2020-10-10 15:05:23 +02001252 // Just in case did_throw got set but current_exception wasn't.
1253 if (current_exception == NULL)
1254 did_throw = FALSE;
1255
Bram Moolenaar071d4272004-06-13 20:20:40 +00001256 /*
1257 * When an exception is being thrown out of the outermost try
1258 * conditional, discard the uncaught exception, disable the conversion
1259 * of interrupts or errors to exceptions, and ensure that no more
1260 * commands are executed.
1261 */
1262 if (did_throw)
Bram Moolenaar620c9592021-07-31 21:32:31 +02001263 handle_did_throw();
Bram Moolenaar071d4272004-06-13 20:20:40 +00001264
1265 /*
1266 * On an interrupt or an aborting error not converted to an exception,
1267 * disable the conversion of errors to exceptions. (Interrupts are not
Bram Moolenaar2196bce2020-04-12 20:01:11 +02001268 * converted anymore, here.) This enables also the interrupt message
Bram Moolenaar071d4272004-06-13 20:20:40 +00001269 * when force_abort is set and did_emsg unset in case of an interrupt
1270 * from a finally clause after an error.
1271 */
1272 else if (got_int || (did_emsg && force_abort))
1273 suppress_errthrow = TRUE;
1274 }
1275
1276 /*
1277 * The current cstack will be freed when do_cmdline() returns. An uncaught
1278 * exception will have to be rethrown in the previous cstack. If a function
1279 * has just returned or a script file was just finished and the previous
1280 * cstack belongs to the same function or, respectively, script file, it
1281 * will have to be checked for finally clauses to be executed due to the
1282 * ":return" or ":finish". This is done in do_one_cmd().
1283 */
1284 if (did_throw)
1285 need_rethrow = TRUE;
Bram Moolenaarbf55e142010-11-16 11:32:01 +01001286 if ((getline_equal(fgetline, cookie, getsourceline)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001287 && ex_nesting_level > source_level(real_cookie))
Bram Moolenaarbf55e142010-11-16 11:32:01 +01001288 || (getline_equal(fgetline, cookie, get_func_line)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001289 && ex_nesting_level > func_level(real_cookie) + 1))
1290 {
1291 if (!did_throw)
1292 check_cstack = TRUE;
1293 }
1294 else
1295 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001296 // When leaving a function, reduce nesting level.
Bram Moolenaarbf55e142010-11-16 11:32:01 +01001297 if (getline_equal(fgetline, cookie, get_func_line))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001298 --ex_nesting_level;
1299 /*
1300 * Go to debug mode when returning from a function in which we are
1301 * single-stepping.
1302 */
Bram Moolenaarbf55e142010-11-16 11:32:01 +01001303 if ((getline_equal(fgetline, cookie, getsourceline)
1304 || getline_equal(fgetline, cookie, get_func_line))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001305 && ex_nesting_level + 1 <= debug_break_level)
Bram Moolenaarbf55e142010-11-16 11:32:01 +01001306 do_debug(getline_equal(fgetline, cookie, getsourceline)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001307 ? (char_u *)_("End of sourced file")
1308 : (char_u *)_("End of function"));
1309 }
1310
1311 /*
1312 * Restore the exception environment (done after returning from the
1313 * debugger).
1314 */
1315 if (flags & DOCMD_EXCRESET)
Bram Moolenaared203462004-06-16 11:19:22 +00001316 restore_dbg_stuff(&debug_saved);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001317
1318 msg_list = saved_msg_list;
Bram Moolenaar292b90d2020-03-18 15:23:16 +01001319
1320 // Cleanup if "cs_emsg_silent_list" remains.
1321 if (cstack.cs_emsg_silent_list != NULL)
1322 {
1323 eslist_T *elem, *temp;
1324
1325 for (elem = cstack.cs_emsg_silent_list; elem != NULL; elem = temp)
1326 {
1327 temp = elem->next;
1328 vim_free(elem);
1329 }
1330 }
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001331#endif // FEAT_EVAL
Bram Moolenaar071d4272004-06-13 20:20:40 +00001332
1333 /*
1334 * If there was too much output to fit on the command line, ask the user to
1335 * hit return before redrawing the screen. With the ":global" command we do
1336 * this only once after the command is finished.
1337 */
1338 if (did_inc)
1339 {
1340 --RedrawingDisabled;
1341 --no_wait_return;
1342 msg_scroll = FALSE;
1343
1344 /*
1345 * When just finished an ":if"-":else" which was typed, no need to
1346 * wait for hit-return. Also for an error situation.
1347 */
1348 if (retval == FAIL
1349#ifdef FEAT_EVAL
1350 || (did_endif && KeyTyped && !did_emsg)
1351#endif
1352 )
1353 {
1354 need_wait_return = FALSE;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001355 msg_didany = FALSE; // don't wait when restarting edit
Bram Moolenaar071d4272004-06-13 20:20:40 +00001356 }
1357 else if (need_wait_return)
1358 {
1359 /*
1360 * The msg_start() above clears msg_didout. The wait_return we do
1361 * here should not overwrite the command that may be shown before
1362 * doing that.
1363 */
1364 msg_didout |= msg_didout_before_start;
1365 wait_return(FALSE);
1366 }
1367 }
1368
Bram Moolenaar2a942252012-11-28 23:03:07 +01001369#ifdef FEAT_EVAL
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001370 did_endif = FALSE; // in case do_cmdline used recursively
Bram Moolenaar2a942252012-11-28 23:03:07 +01001371#else
Bram Moolenaar071d4272004-06-13 20:20:40 +00001372 /*
1373 * Reset if_level, in case a sourced script file contains more ":if" than
1374 * ":endif" (could be ":if x | foo | endif").
1375 */
1376 if_level = 0;
Bram Moolenaar2e18a122012-11-28 19:10:54 +01001377#endif
Bram Moolenaard4ad0d42012-11-28 17:34:48 +01001378
Bram Moolenaar071d4272004-06-13 20:20:40 +00001379 --call_depth;
1380 return retval;
1381}
1382
Bram Moolenaar335c8c72021-07-31 21:44:35 +02001383#if defined(FEAT_EVAL) || defined(PROTO)
Bram Moolenaar620c9592021-07-31 21:32:31 +02001384/*
1385 * Handle when "did_throw" is set after executing commands.
1386 */
1387 void
1388handle_did_throw()
1389{
1390 char *p = NULL;
1391 msglist_T *messages = NULL;
Bram Moolenaar9e0ee592021-07-31 22:17:28 +02001392 ESTACK_CHECK_DECLARATION
Bram Moolenaar620c9592021-07-31 21:32:31 +02001393
1394 /*
1395 * If the uncaught exception is a user exception, report it as an
1396 * error. If it is an error exception, display the saved error
1397 * message now. For an interrupt exception, do nothing; the
1398 * interrupt message is given elsewhere.
1399 */
1400 switch (current_exception->type)
1401 {
1402 case ET_USER:
1403 vim_snprintf((char *)IObuff, IOSIZE,
Bram Moolenaard88be5b2022-01-04 19:57:55 +00001404 _(e_exception_not_caught_str),
Bram Moolenaar620c9592021-07-31 21:32:31 +02001405 current_exception->value);
1406 p = (char *)vim_strsave(IObuff);
1407 break;
1408 case ET_ERROR:
1409 messages = current_exception->messages;
1410 current_exception->messages = NULL;
1411 break;
1412 case ET_INTERRUPT:
1413 break;
1414 }
1415
1416 estack_push(ETYPE_EXCEPT, current_exception->throw_name,
1417 current_exception->throw_lnum);
1418 ESTACK_CHECK_SETUP
1419 current_exception->throw_name = NULL;
1420
1421 discard_current_exception(); // uses IObuff if 'verbose'
1422 suppress_errthrow = TRUE;
1423 force_abort = TRUE;
1424
1425 if (messages != NULL)
1426 {
1427 do
1428 {
1429 msglist_T *next = messages->next;
1430 int save_compiling = estack_compiling;
1431
1432 estack_compiling = messages->msg_compiling;
1433 emsg(messages->msg);
1434 vim_free(messages->msg);
1435 vim_free(messages->sfile);
1436 vim_free(messages);
1437 messages = next;
1438 estack_compiling = save_compiling;
1439 }
1440 while (messages != NULL);
1441 }
1442 else if (p != NULL)
1443 {
1444 emsg(p);
1445 vim_free(p);
1446 }
1447 vim_free(SOURCING_NAME);
1448 ESTACK_CHECK_NOW
1449 estack_pop();
1450}
1451
Bram Moolenaar071d4272004-06-13 20:20:40 +00001452/*
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001453 * Obtain a line when inside a ":while" or ":for" loop.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001454 */
1455 static char_u *
Bram Moolenaar20b23c62020-08-20 15:25:00 +02001456get_loop_line(int c, void *cookie, int indent, getline_opt_T options)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001457{
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001458 struct loop_cookie *cp = (struct loop_cookie *)cookie;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001459 wcmd_T *wp;
1460 char_u *line;
1461
1462 if (cp->current_line + 1 >= cp->lines_gap->ga_len)
1463 {
1464 if (cp->repeating)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001465 return NULL; // trying to read past ":endwhile"/":endfor"
Bram Moolenaar071d4272004-06-13 20:20:40 +00001466
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001467 // First time inside the ":while"/":for": get line normally.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001468 if (cp->getline == NULL)
Bram Moolenaarc97f9a52021-12-28 20:59:56 +00001469 line = getcmdline(c, 0L, indent, 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001470 else
Bram Moolenaar20b23c62020-08-20 15:25:00 +02001471 line = cp->getline(c, cp->cookie, indent, options);
Bram Moolenaard68071d2006-05-02 22:08:30 +00001472 if (line != NULL && store_loop_line(cp->lines_gap, line) == OK)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001473 ++cp->current_line;
1474
1475 return line;
1476 }
1477
1478 KeyTyped = FALSE;
1479 ++cp->current_line;
1480 wp = (wcmd_T *)(cp->lines_gap->ga_data) + cp->current_line;
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01001481 SOURCING_LNUM = wp->lnum;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001482 return vim_strsave(wp->line);
1483}
1484
1485/*
1486 * Store a line in "gap" so that a ":while" loop can execute it again.
1487 */
1488 static int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01001489store_loop_line(garray_T *gap, char_u *line)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001490{
1491 if (ga_grow(gap, 1) == FAIL)
1492 return FAIL;
1493 ((wcmd_T *)(gap->ga_data))[gap->ga_len].line = vim_strsave(line);
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01001494 ((wcmd_T *)(gap->ga_data))[gap->ga_len].lnum = SOURCING_LNUM;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001495 ++gap->ga_len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001496 return OK;
1497}
1498
1499/*
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001500 * Free the lines stored for a ":while" or ":for" loop.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001501 */
1502 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01001503free_cmdlines(garray_T *gap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001504{
1505 while (gap->ga_len > 0)
1506 {
1507 vim_free(((wcmd_T *)(gap->ga_data))[gap->ga_len - 1].line);
1508 --gap->ga_len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001509 }
1510}
1511#endif
1512
1513/*
Bram Moolenaar89d40322006-08-29 15:30:07 +00001514 * If "fgetline" is get_loop_line(), return TRUE if the getline it uses equals
1515 * "func". * Otherwise return TRUE when "fgetline" equals "func".
Bram Moolenaar071d4272004-06-13 20:20:40 +00001516 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001517 int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01001518getline_equal(
Bram Moolenaar66250c92020-08-20 15:02:42 +02001519 char_u *(*fgetline)(int, void *, int, getline_opt_T),
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001520 void *cookie UNUSED, // argument for fgetline()
Bram Moolenaar66250c92020-08-20 15:02:42 +02001521 char_u *(*func)(int, void *, int, getline_opt_T))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001522{
1523#ifdef FEAT_EVAL
Bram Moolenaar20b23c62020-08-20 15:25:00 +02001524 char_u *(*gp)(int, void *, int, getline_opt_T);
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001525 struct loop_cookie *cp;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001526
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001527 // When "fgetline" is "get_loop_line()" use the "cookie" to find the
1528 // function that's originally used to obtain the lines. This may be
1529 // nested several levels.
Bram Moolenaar89d40322006-08-29 15:30:07 +00001530 gp = fgetline;
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001531 cp = (struct loop_cookie *)cookie;
1532 while (gp == get_loop_line)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001533 {
1534 gp = cp->getline;
1535 cp = cp->cookie;
1536 }
1537 return gp == func;
1538#else
Bram Moolenaar89d40322006-08-29 15:30:07 +00001539 return fgetline == func;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001540#endif
1541}
1542
Bram Moolenaar071d4272004-06-13 20:20:40 +00001543/*
Bram Moolenaar89d40322006-08-29 15:30:07 +00001544 * If "fgetline" is get_loop_line(), return the cookie used by the original
Bram Moolenaar071d4272004-06-13 20:20:40 +00001545 * getline function. Otherwise return "cookie".
1546 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001547 void *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01001548getline_cookie(
Bram Moolenaar66250c92020-08-20 15:02:42 +02001549 char_u *(*fgetline)(int, void *, int, getline_opt_T) UNUSED,
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001550 void *cookie) // argument for fgetline()
Bram Moolenaar071d4272004-06-13 20:20:40 +00001551{
Bram Moolenaar13505972019-01-24 15:04:48 +01001552#ifdef FEAT_EVAL
Bram Moolenaar20b23c62020-08-20 15:25:00 +02001553 char_u *(*gp)(int, void *, int, getline_opt_T);
Bram Moolenaard5053d02020-06-28 15:51:16 +02001554 struct loop_cookie *cp;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001555
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001556 // When "fgetline" is "get_loop_line()" use the "cookie" to find the
1557 // cookie that's originally used to obtain the lines. This may be nested
1558 // several levels.
Bram Moolenaar89d40322006-08-29 15:30:07 +00001559 gp = fgetline;
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001560 cp = (struct loop_cookie *)cookie;
1561 while (gp == get_loop_line)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001562 {
1563 gp = cp->getline;
1564 cp = cp->cookie;
1565 }
1566 return cp;
Bram Moolenaar13505972019-01-24 15:04:48 +01001567#else
Bram Moolenaar071d4272004-06-13 20:20:40 +00001568 return cookie;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001569#endif
Bram Moolenaar13505972019-01-24 15:04:48 +01001570}
Bram Moolenaar071d4272004-06-13 20:20:40 +00001571
Bram Moolenaard5053d02020-06-28 15:51:16 +02001572#if defined(FEAT_EVAL) || defined(PROT)
1573/*
1574 * Get the next line source line without advancing.
1575 */
1576 char_u *
1577getline_peek(
Bram Moolenaar66250c92020-08-20 15:02:42 +02001578 char_u *(*fgetline)(int, void *, int, getline_opt_T) UNUSED,
Bram Moolenaard5053d02020-06-28 15:51:16 +02001579 void *cookie) // argument for fgetline()
1580{
Bram Moolenaar20b23c62020-08-20 15:25:00 +02001581 char_u *(*gp)(int, void *, int, getline_opt_T);
Bram Moolenaard5053d02020-06-28 15:51:16 +02001582 struct loop_cookie *cp;
1583 wcmd_T *wp;
1584
1585 // When "fgetline" is "get_loop_line()" use the "cookie" to find the
1586 // cookie that's originally used to obtain the lines. This may be nested
1587 // several levels.
1588 gp = fgetline;
1589 cp = (struct loop_cookie *)cookie;
1590 while (gp == get_loop_line)
1591 {
1592 if (cp->current_line + 1 < cp->lines_gap->ga_len)
1593 {
1594 // executing lines a second time, use the stored copy
1595 wp = (wcmd_T *)(cp->lines_gap->ga_data) + cp->current_line + 1;
1596 return wp->line;
1597 }
1598 gp = cp->getline;
1599 cp = cp->cookie;
1600 }
1601 if (gp == getsourceline)
1602 return source_nextline(cp);
1603 return NULL;
1604}
1605#endif
1606
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01001607
1608/*
1609 * Helper function to apply an offset for buffer commands, i.e. ":bdelete",
1610 * ":bwipeout", etc.
1611 * Returns the buffer number.
1612 */
1613 static int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01001614compute_buffer_local_count(int addr_type, int lnum, int offset)
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01001615{
1616 buf_T *buf;
Bram Moolenaar4d84d932014-11-30 14:50:16 +01001617 buf_T *nextbuf;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01001618 int count = offset;
1619
1620 buf = firstbuf;
1621 while (buf->b_next != NULL && buf->b_fnum < lnum)
1622 buf = buf->b_next;
1623 while (count != 0)
1624 {
Bram Moolenaar4d84d932014-11-30 14:50:16 +01001625 count += (offset < 0) ? 1 : -1;
1626 nextbuf = (offset < 0) ? buf->b_prev : buf->b_next;
1627 if (nextbuf == NULL)
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01001628 break;
Bram Moolenaar4d84d932014-11-30 14:50:16 +01001629 buf = nextbuf;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01001630 if (addr_type == ADDR_LOADED_BUFFERS)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001631 // skip over unloaded buffers
Bram Moolenaar4d84d932014-11-30 14:50:16 +01001632 while (buf->b_ml.ml_mfp == NULL)
1633 {
1634 nextbuf = (offset < 0) ? buf->b_prev : buf->b_next;
1635 if (nextbuf == NULL)
1636 break;
1637 buf = nextbuf;
1638 }
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01001639 }
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001640 // we might have gone too far, last buffer is not loadedd
Bram Moolenaar4d84d932014-11-30 14:50:16 +01001641 if (addr_type == ADDR_LOADED_BUFFERS)
1642 while (buf->b_ml.ml_mfp == NULL)
1643 {
1644 nextbuf = (offset >= 0) ? buf->b_prev : buf->b_next;
1645 if (nextbuf == NULL)
1646 break;
1647 buf = nextbuf;
1648 }
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01001649 return buf->b_fnum;
1650}
1651
Bram Moolenaarb7316892019-05-01 18:08:42 +02001652/*
1653 * Return the window number of "win".
1654 * When "win" is NULL return the number of windows.
1655 */
Bram Moolenaarf240e182014-11-27 18:33:02 +01001656 static int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01001657current_win_nr(win_T *win)
Bram Moolenaarf240e182014-11-27 18:33:02 +01001658{
1659 win_T *wp;
1660 int nr = 0;
1661
Bram Moolenaar29323592016-07-24 22:04:11 +02001662 FOR_ALL_WINDOWS(wp)
Bram Moolenaarf240e182014-11-27 18:33:02 +01001663 {
1664 ++nr;
1665 if (wp == win)
1666 break;
1667 }
1668 return nr;
1669}
1670
1671 static int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01001672current_tab_nr(tabpage_T *tab)
Bram Moolenaarf240e182014-11-27 18:33:02 +01001673{
1674 tabpage_T *tp;
1675 int nr = 0;
1676
Bram Moolenaar29323592016-07-24 22:04:11 +02001677 FOR_ALL_TABPAGES(tp)
Bram Moolenaarf240e182014-11-27 18:33:02 +01001678 {
1679 ++nr;
1680 if (tp == tab)
1681 break;
1682 }
1683 return nr;
1684}
1685
Bram Moolenaar6e36b1c2020-07-17 20:47:51 +02001686 static int
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001687comment_start(char_u *p, int starts_with_colon UNUSED)
1688{
1689#ifdef FEAT_EVAL
1690 if (in_vim9script())
Bram Moolenaar93f82cb2020-12-12 21:25:56 +01001691 return p[0] == '#' && !starts_with_colon;
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001692#endif
1693 return *p == '"';
1694}
1695
Bram Moolenaarf240e182014-11-27 18:33:02 +01001696# define CURRENT_WIN_NR current_win_nr(curwin)
1697# define LAST_WIN_NR current_win_nr(NULL)
1698# define CURRENT_TAB_NR current_tab_nr(curtab)
1699# define LAST_TAB_NR current_tab_nr(NULL)
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01001700
Bram Moolenaar071d4272004-06-13 20:20:40 +00001701/*
1702 * Execute one Ex command.
1703 *
Bram Moolenaar47a2abf2020-11-25 20:12:11 +01001704 * If "flags" has DOCMD_VERBOSE, the command will be included in the error
1705 * message.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001706 *
1707 * 1. skip comment lines and leading space
1708 * 2. handle command modifiers
Bram Moolenaar1c40a662014-11-27 16:38:11 +01001709 * 3. find the command
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01001710 * 4. parse range
Bram Moolenaar1c40a662014-11-27 16:38:11 +01001711 * 5. Parse the command.
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01001712 * 6. parse arguments
1713 * 7. switch on command name
Bram Moolenaar071d4272004-06-13 20:20:40 +00001714 *
Bram Moolenaar89d40322006-08-29 15:30:07 +00001715 * Note: "fgetline" can be NULL.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001716 *
1717 * This function may be called recursively!
1718 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001719 static char_u *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01001720do_one_cmd(
Bram Moolenaarddef1292019-12-16 17:10:33 +01001721 char_u **cmdlinep,
Bram Moolenaar47a2abf2020-11-25 20:12:11 +01001722 int flags,
Bram Moolenaar071d4272004-06-13 20:20:40 +00001723#ifdef FEAT_EVAL
Bram Moolenaarddef1292019-12-16 17:10:33 +01001724 cstack_T *cstack,
Bram Moolenaar071d4272004-06-13 20:20:40 +00001725#endif
Bram Moolenaar20b23c62020-08-20 15:25:00 +02001726 char_u *(*fgetline)(int, void *, int, getline_opt_T),
Bram Moolenaarddef1292019-12-16 17:10:33 +01001727 void *cookie) // argument for fgetline()
Bram Moolenaar071d4272004-06-13 20:20:40 +00001728{
Bram Moolenaarddef1292019-12-16 17:10:33 +01001729 char_u *p;
1730 linenr_T lnum;
1731 long n;
1732 char *errormsg = NULL; // error message
1733 char_u *after_modifier = NULL;
1734 exarg_T ea; // Ex command arguments
Bram Moolenaarddef1292019-12-16 17:10:33 +01001735 cmdmod_T save_cmdmod;
1736 int save_reg_executing = reg_executing;
1737 int ni; // set when Not Implemented
1738 char_u *cmd;
Bram Moolenaar6e36b1c2020-07-17 20:47:51 +02001739 int starts_with_colon = FALSE;
Bram Moolenaar83f37b92020-02-23 14:35:01 +01001740#ifdef FEAT_EVAL
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02001741 int may_have_range;
Bram Moolenaar39f3b142021-02-14 12:57:36 +01001742 int vim9script;
Bram Moolenaarb4bcea42020-10-28 13:53:50 +01001743 int did_set_expr_line = FALSE;
Bram Moolenaar83f37b92020-02-23 14:35:01 +01001744#endif
Bram Moolenaar47a2abf2020-11-25 20:12:11 +01001745 int sourcing = flags & DOCMD_VERBOSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001746
Bram Moolenaara80faa82020-04-12 19:37:17 +02001747 CLEAR_FIELD(ea);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001748 ea.line1 = 1;
1749 ea.line2 = 1;
1750#ifdef FEAT_EVAL
1751 ++ex_nesting_level;
1752#endif
1753
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001754 // When the last file has not been edited :q has to be typed twice.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001755 if (quitmore
1756#ifdef FEAT_EVAL
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001757 // avoid that a function call in 'statusline' does this
Bram Moolenaar89d40322006-08-29 15:30:07 +00001758 && !getline_equal(fgetline, cookie, get_func_line)
Bram Moolenaarb2c5a5a2013-02-14 22:11:39 +01001759#endif
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001760 // avoid that an autocommand, e.g. QuitPre, does this
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01001761 && !getline_equal(fgetline, cookie, getnextac))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001762 --quitmore;
1763
1764 /*
1765 * Reset browse, confirm, etc.. They are restored when returning, for
1766 * recursive calls.
1767 */
1768 save_cmdmod = cmdmod;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001769
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001770 // "#!anything" is handled like a comment.
Bram Moolenaarcbb37ad2006-08-16 15:04:21 +00001771 if ((*cmdlinep)[0] == '#' && (*cmdlinep)[1] == '!')
1772 goto doend;
1773
Bram Moolenaar33c4dbb2018-08-14 16:06:16 +02001774/*
1775 * 1. Skip comment lines and leading white space and colons.
1776 * 2. Handle command modifiers.
1777 */
1778 // The "ea" structure holds the arguments that can be used.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001779 ea.cmd = *cmdlinep;
Bram Moolenaareffed932018-08-14 13:38:17 +02001780 ea.cmdlinep = cmdlinep;
1781 ea.getline = fgetline;
1782 ea.cookie = cookie;
1783#ifdef FEAT_EVAL
1784 ea.cstack = cstack;
Bram Moolenaar83f37b92020-02-23 14:35:01 +01001785 starts_with_colon = *skipwhite(ea.cmd) == ':';
Bram Moolenaar071d4272004-06-13 20:20:40 +00001786#endif
Bram Moolenaare1004402020-10-24 20:49:43 +02001787 if (parse_command_modifiers(&ea, &errormsg, &cmdmod, FALSE) == FAIL)
Bram Moolenaareffed932018-08-14 13:38:17 +02001788 goto doend;
Bram Moolenaar5661ed62020-10-24 17:19:16 +02001789 apply_cmdmod(&cmdmod);
Bram Moolenaar2379f872021-02-14 14:07:34 +01001790#ifdef FEAT_EVAL
Bram Moolenaar39f3b142021-02-14 12:57:36 +01001791 vim9script = in_vim9script();
Bram Moolenaar2379f872021-02-14 14:07:34 +01001792#endif
Bram Moolenaar7b668e82016-08-23 23:51:21 +02001793 after_modifier = ea.cmd;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001794
1795#ifdef FEAT_EVAL
1796 ea.skip = did_emsg || got_int || did_throw || (cstack->cs_idx >= 0
1797 && !(cstack->cs_flags[cstack->cs_idx] & CSF_ACTIVE));
1798#else
1799 ea.skip = (if_level > 0);
1800#endif
1801
Bram Moolenaar071d4272004-06-13 20:20:40 +00001802/*
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01001803 * 3. Skip over the range to find the command. Let "p" point to after it.
1804 *
1805 * We need the command to know what kind of range it uses.
1806 */
1807 cmd = ea.cmd;
Bram Moolenaar3d48e252020-07-15 14:15:52 +02001808#ifdef FEAT_EVAL
Bram Moolenaare88c8e82020-11-01 17:03:37 +01001809 // In Vim9 script a colon is required before the range. This may also be
1810 // after command modifiers.
Bram Moolenaar47a2abf2020-11-25 20:12:11 +01001811 if (vim9script && (flags & DOCMD_RANGEOK) == 0)
Bram Moolenaare88c8e82020-11-01 17:03:37 +01001812 {
1813 may_have_range = FALSE;
1814 for (p = ea.cmd; p >= *cmdlinep; --p)
1815 {
1816 if (*p == ':')
1817 may_have_range = TRUE;
1818 if (p < ea.cmd && !VIM_ISWHITE(*p))
1819 break;
1820 }
1821 }
1822 else
1823 may_have_range = TRUE;
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02001824 if (may_have_range)
Bram Moolenaar3d48e252020-07-15 14:15:52 +02001825#endif
Bram Moolenaar3bd8de42020-09-14 16:37:34 +02001826 ea.cmd = skip_range(ea.cmd, TRUE, NULL);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001827
1828#ifdef FEAT_EVAL
Bram Moolenaare88c8e82020-11-01 17:03:37 +01001829 if (vim9script && !may_have_range)
Bram Moolenaardf069ee2020-06-22 23:02:51 +02001830 {
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02001831 if (ea.cmd == cmd + 1 && *cmd == '$')
1832 // should be "$VAR = val"
1833 --ea.cmd;
Bram Moolenaar2e2d7582021-03-03 21:22:41 +01001834 p = find_ex_command(&ea, NULL, lookup_scriptitem, NULL);
Bram Moolenaar36113e42020-11-02 21:08:47 +01001835 if (ea.cmdidx == CMD_SIZE)
1836 {
1837 char_u *ar = skip_range(ea.cmd, TRUE, NULL);
1838
1839 // If a ':' before the range is missing, give a clearer error
1840 // message.
Bram Moolenaar8ac681a2021-06-15 20:06:34 +02001841 if (ar > ea.cmd && !ea.skip)
Bram Moolenaar36113e42020-11-02 21:08:47 +01001842 {
Bram Moolenaar6e2c2c52020-12-25 19:25:45 +01001843 semsg(_(e_colon_required_before_range_str), ea.cmd);
Bram Moolenaar36113e42020-11-02 21:08:47 +01001844 goto doend;
1845 }
1846 }
Bram Moolenaardf069ee2020-06-22 23:02:51 +02001847 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001848 else
1849#endif
1850 p = find_ex_command(&ea, NULL, NULL, NULL);
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01001851
Bram Moolenaar7feb35e2018-08-21 17:49:54 +02001852#ifdef FEAT_EVAL
1853# ifdef FEAT_PROFILE
1854 // Count this line for profiling if skip is TRUE.
1855 if (do_profiling == PROF_YES
1856 && (!ea.skip || cstack->cs_idx == 0 || (cstack->cs_idx > 0
1857 && (cstack->cs_flags[cstack->cs_idx - 1] & CSF_ACTIVE))))
1858 {
1859 int skip = did_emsg || got_int || did_throw;
1860
1861 if (ea.cmdidx == CMD_catch)
1862 skip = !skip && !(cstack->cs_idx >= 0
1863 && (cstack->cs_flags[cstack->cs_idx] & CSF_THROWN)
1864 && !(cstack->cs_flags[cstack->cs_idx] & CSF_CAUGHT));
1865 else if (ea.cmdidx == CMD_else || ea.cmdidx == CMD_elseif)
1866 skip = skip || !(cstack->cs_idx >= 0
1867 && !(cstack->cs_flags[cstack->cs_idx]
1868 & (CSF_ACTIVE | CSF_TRUE)));
1869 else if (ea.cmdidx == CMD_finally)
1870 skip = FALSE;
1871 else if (ea.cmdidx != CMD_endif
1872 && ea.cmdidx != CMD_endfor
1873 && ea.cmdidx != CMD_endtry
1874 && ea.cmdidx != CMD_endwhile)
1875 skip = ea.skip;
1876
1877 if (!skip)
1878 {
1879 if (getline_equal(fgetline, cookie, get_func_line))
1880 func_line_exec(getline_cookie(fgetline, cookie));
1881 else if (getline_equal(fgetline, cookie, getsourceline))
1882 script_line_exec();
1883 }
1884 }
1885# endif
1886
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001887 // May go to debug mode. If this happens and the ">quit" debug command is
1888 // used, throw an interrupt exception and skip the next command.
Bram Moolenaar7feb35e2018-08-21 17:49:54 +02001889 dbg_check_breakpoint(&ea);
1890 if (!ea.skip && got_int)
1891 {
1892 ea.skip = TRUE;
1893 (void)do_intthrow(cstack);
1894 }
1895#endif
1896
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01001897/*
1898 * 4. parse a range specifier of the form: addr [,addr] [;addr] ..
Bram Moolenaar071d4272004-06-13 20:20:40 +00001899 *
1900 * where 'addr' is:
1901 *
1902 * % (entire file)
1903 * $ [+-NUM]
1904 * 'x [+-NUM] (where x denotes a currently defined mark)
1905 * . [+-NUM]
1906 * [+-NUM]..
1907 * NUM
1908 *
1909 * The ea.cmd pointer is updated to point to the first character following the
1910 * range spec. If an initial address is found, but no second, the upper bound
1911 * is equal to the lower.
1912 */
1913
Bram Moolenaar25190db2019-05-04 15:05:28 +02001914 // ea.addr_type for user commands is set by find_ucmd
Bram Moolenaar84c8e5a2015-01-14 15:47:36 +01001915 if (!IS_USER_CMDIDX(ea.cmdidx))
1916 {
1917 if (ea.cmdidx != CMD_SIZE)
1918 ea.addr_type = cmdnames[(int)ea.cmdidx].cmd_addr_type;
1919 else
1920 ea.addr_type = ADDR_LINES;
1921
Bram Moolenaar25190db2019-05-04 15:05:28 +02001922 // :wincmd range depends on the argument.
Bram Moolenaar164f3262015-01-14 21:22:01 +01001923 if (ea.cmdidx == CMD_wincmd && p != NULL)
1924 get_wincmd_addr_type(skipwhite(p), &ea);
Bram Moolenaar25190db2019-05-04 15:05:28 +02001925#ifdef FEAT_QUICKFIX
1926 // :.cc in quickfix window uses line number
1927 if ((ea.cmdidx == CMD_cc || ea.cmdidx == CMD_ll) && bt_quickfix(curbuf))
1928 ea.addr_type = ADDR_OTHER;
1929#endif
Bram Moolenaar84c8e5a2015-01-14 15:47:36 +01001930 }
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01001931
Bram Moolenaar84c8e5a2015-01-14 15:47:36 +01001932 ea.cmd = cmd;
Bram Moolenaar3d48e252020-07-15 14:15:52 +02001933#ifdef FEAT_EVAL
Bram Moolenaarc2af0af2020-08-23 21:06:02 +02001934 if (!may_have_range)
1935 ea.line1 = ea.line2 = default_address(&ea);
1936 else
Bram Moolenaar3d48e252020-07-15 14:15:52 +02001937#endif
1938 if (parse_cmd_address(&ea, &errormsg, FALSE) == FAIL)
1939 goto doend;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001940
Bram Moolenaar071d4272004-06-13 20:20:40 +00001941/*
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01001942 * 5. Parse the command.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001943 */
1944
1945 /*
1946 * Skip ':' and any white space
1947 */
1948 ea.cmd = skipwhite(ea.cmd);
1949 while (*ea.cmd == ':')
1950 ea.cmd = skipwhite(ea.cmd + 1);
1951
1952 /*
1953 * If we got a line, but no command, then go to the line.
1954 * If we find a '|' or '\n' we set ea.nextcmd.
1955 */
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001956 if (*ea.cmd == NUL || comment_start(ea.cmd, starts_with_colon)
1957 || (ea.nextcmd = check_nextcmd(ea.cmd)) != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001958 {
1959 /*
1960 * strange vi behaviour:
1961 * ":3" jumps to line 3
Bram Moolenaarb8554302021-02-15 21:30:30 +01001962 * ":3|..." prints line 3 (not in Vim9 script)
1963 * ":|" prints current line (not in Vim9 script)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001964 */
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001965 if (ea.skip) // skip this if inside :if
Bram Moolenaar071d4272004-06-13 20:20:40 +00001966 goto doend;
Bram Moolenaare4eed8c2021-12-01 15:22:56 +00001967 errormsg = ex_range_without_command(&ea);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001968 goto doend;
1969 }
1970
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001971 // If this looks like an undefined user command and there are CmdUndefined
1972 // autocommands defined, trigger the matching autocommands.
Bram Moolenaard5005162014-08-22 23:05:54 +02001973 if (p != NULL && ea.cmdidx == CMD_SIZE && !ea.skip
1974 && ASCII_ISUPPER(*ea.cmd)
1975 && has_cmdundefined())
1976 {
Bram Moolenaard5005162014-08-22 23:05:54 +02001977 int ret;
1978
Bram Moolenaar5a31b462014-08-23 14:16:20 +02001979 p = ea.cmd;
Bram Moolenaard5005162014-08-22 23:05:54 +02001980 while (ASCII_ISALNUM(*p))
1981 ++p;
Bram Moolenaar158ea172020-06-18 17:28:39 +02001982 p = vim_strnsave(ea.cmd, p - ea.cmd);
Bram Moolenaard5005162014-08-22 23:05:54 +02001983 ret = apply_autocmds(EVENT_CMDUNDEFINED, p, p, TRUE, NULL);
1984 vim_free(p);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001985 // If the autocommands did something and didn't cause an error, try
1986 // finding the command again.
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01001987 p = (ret
1988#ifdef FEAT_EVAL
1989 && !aborting()
Bram Moolenaard5005162014-08-22 23:05:54 +02001990#endif
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001991 ) ? find_ex_command(&ea, NULL, NULL, NULL) : ea.cmd;
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01001992 }
Bram Moolenaard5005162014-08-22 23:05:54 +02001993
Bram Moolenaar071d4272004-06-13 20:20:40 +00001994 if (p == NULL)
1995 {
1996 if (!ea.skip)
Bram Moolenaard1510ee2021-01-04 16:15:58 +01001997 errormsg = _(e_ambiguous_use_of_user_defined_command);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001998 goto doend;
1999 }
Bram Moolenaarac9fb182019-04-27 13:04:13 +02002000 // Check for wrong commands.
Bram Moolenaar6f9a4762017-06-22 20:39:17 +02002001 if (*p == '!' && ea.cmd[1] == 0151 && ea.cmd[0] == 78
2002 && !IS_USER_CMDIDX(ea.cmdidx))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002003 {
2004 errormsg = uc_fun_cmd();
2005 goto doend;
2006 }
Bram Moolenaarac9fb182019-04-27 13:04:13 +02002007
Bram Moolenaar071d4272004-06-13 20:20:40 +00002008 if (ea.cmdidx == CMD_SIZE)
2009 {
2010 if (!ea.skip)
2011 {
Bram Moolenaarb09feaa2022-01-02 20:20:45 +00002012 STRCPY(IObuff, _(e_not_an_editor_command));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002013 if (!sourcing)
Bram Moolenaar7b668e82016-08-23 23:51:21 +02002014 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002015 // If the modifier was parsed OK the error must be in the
2016 // following command
Bram Moolenaar7b668e82016-08-23 23:51:21 +02002017 if (after_modifier != NULL)
2018 append_command(after_modifier);
2019 else
2020 append_command(*cmdlinep);
2021 }
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002022 errormsg = (char *)IObuff;
Bram Moolenaar00b8ae02012-08-23 18:43:10 +02002023 did_emsg_syntax = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002024 }
2025 goto doend;
2026 }
2027
Bram Moolenaar958636c2014-10-21 20:01:58 +02002028 ni = (!IS_USER_CMDIDX(ea.cmdidx)
2029 && (cmdnames[ea.cmdidx].cmd_func == ex_ni
Bram Moolenaar7bb75552007-07-16 18:39:49 +00002030#ifdef HAVE_EX_SCRIPT_NI
2031 || cmdnames[ea.cmdidx].cmd_func == ex_script_ni
2032#endif
2033 ));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002034
2035#ifndef FEAT_EVAL
2036 /*
2037 * When the expression evaluation is disabled, recognize the ":if" and
2038 * ":endif" commands and ignore everything in between it.
2039 */
2040 if (ea.cmdidx == CMD_if)
2041 ++if_level;
2042 if (if_level)
2043 {
2044 if (ea.cmdidx == CMD_endif)
2045 --if_level;
2046 goto doend;
2047 }
2048
2049#endif
2050
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002051 // forced commands
Bram Moolenaar196b3b02008-06-20 16:51:41 +00002052 if (*p == '!' && ea.cmdidx != CMD_substitute
2053 && ea.cmdidx != CMD_smagic && ea.cmdidx != CMD_snomagic)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002054 {
2055 ++p;
2056 ea.forceit = TRUE;
2057 }
2058 else
2059 ea.forceit = FALSE;
2060
2061/*
Bram Moolenaarb7316892019-05-01 18:08:42 +02002062 * 6. Parse arguments. Then check for errors.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002063 */
Bram Moolenaar958636c2014-10-21 20:01:58 +02002064 if (!IS_USER_CMDIDX(ea.cmdidx))
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00002065 ea.argt = (long)cmdnames[(int)ea.cmdidx].cmd_argt;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002066
2067 if (!ea.skip)
2068 {
2069#ifdef HAVE_SANDBOX
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002070 if (sandbox != 0 && !(ea.argt & EX_SBOXOK))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002071 {
Bram Moolenaar8c62a082019-02-08 14:34:10 +01002072 // Command not allowed in sandbox.
Bram Moolenaard8e44472021-07-21 22:20:33 +02002073 errormsg = _(e_not_allowed_in_sandbox);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002074 goto doend;
2075 }
2076#endif
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002077 if (restricted != 0 && (ea.argt & EX_RESTRICT))
Bram Moolenaar8c62a082019-02-08 14:34:10 +01002078 {
Bram Moolenaard82a47d2022-01-05 20:24:39 +00002079 errormsg = _(e_command_not_allowed_in_rvim);
Bram Moolenaar8c62a082019-02-08 14:34:10 +01002080 goto doend;
2081 }
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002082 if (!curbuf->b_p_ma && (ea.argt & EX_MODIFY))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002083 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002084 // Command not allowed in non-'modifiable' buffer
Bram Moolenaar108010a2021-06-27 22:03:33 +02002085 errormsg = _(e_cannot_make_changes_modifiable_is_off);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002086 goto doend;
2087 }
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00002088
Bram Moolenaar37394ff2020-07-25 19:38:18 +02002089 if (!IS_USER_CMDIDX(ea.cmdidx))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002090 {
Bram Moolenaar37394ff2020-07-25 19:38:18 +02002091#ifdef FEAT_CMDWIN
2092 if (cmdwin_type != 0 && !(ea.argt & EX_CMDWIN))
2093 {
2094 // Command not allowed in the command line window
Bram Moolenaar108010a2021-06-27 22:03:33 +02002095 errormsg = _(e_invalid_in_cmdline_window);
Bram Moolenaar37394ff2020-07-25 19:38:18 +02002096 goto doend;
2097 }
2098#endif
2099 if (text_locked() && !(ea.argt & EX_LOCK_OK))
2100 {
2101 // Command not allowed when text is locked
2102 errormsg = _(get_text_locked_msg());
2103 goto doend;
2104 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002105 }
Bram Moolenaar379fb762018-08-30 15:58:28 +02002106
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002107 // Disallow editing another buffer when "curbuf_lock" is set.
2108 // Do allow ":checktime" (it is postponed).
2109 // Do allow ":edit" (check for an argument later).
2110 // Do allow ":file" with no arguments (check for an argument later).
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02002111 if (!(ea.argt & (EX_CMDWIN | EX_LOCK_OK))
Bram Moolenaar5555acc2006-04-07 21:33:12 +00002112 && ea.cmdidx != CMD_checktime
Bram Moolenaar379fb762018-08-30 15:58:28 +02002113 && ea.cmdidx != CMD_edit
2114 && ea.cmdidx != CMD_file
Bram Moolenaar958636c2014-10-21 20:01:58 +02002115 && !IS_USER_CMDIDX(ea.cmdidx)
Bram Moolenaar910f66f2006-04-05 20:41:53 +00002116 && curbuf_locked())
2117 goto doend;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002118
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002119 if (!ni && !(ea.argt & EX_RANGE) && ea.addr_count > 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002120 {
Bram Moolenaar460ae5d2022-01-01 14:19:49 +00002121 errormsg = _(e_no_range_allowed);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002122 goto doend;
2123 }
2124 }
2125
Bram Moolenaar460ae5d2022-01-01 14:19:49 +00002126 if (!ni && !(ea.argt & EX_BANG) && ea.forceit)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002127 {
Bram Moolenaar460ae5d2022-01-01 14:19:49 +00002128 errormsg = _(e_no_bang_allowed);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002129 goto doend;
2130 }
2131
2132 /*
2133 * Don't complain about the range if it is not used
2134 * (could happen if line_count is accidentally set to 0).
2135 */
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002136 if (!ea.skip && !ni && (ea.argt & EX_RANGE))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002137 {
2138 /*
2139 * If the range is backwards, ask for confirmation and, if given, swap
2140 * ea.line1 & ea.line2 so it's forwards again.
2141 * When global command is busy, don't ask, will fail below.
2142 */
2143 if (!global_busy && ea.line1 > ea.line2)
2144 {
Bram Moolenaara5792f52005-11-23 21:25:05 +00002145 if (msg_silent == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002146 {
Bram Moolenaara5792f52005-11-23 21:25:05 +00002147 if (sourcing || exmode_active)
2148 {
Bram Moolenaarb09feaa2022-01-02 20:20:45 +00002149 errormsg = _(e_backwards_range_given);
Bram Moolenaara5792f52005-11-23 21:25:05 +00002150 goto doend;
2151 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002152 if (ask_yesno((char_u *)
2153 _("Backwards range given, OK to swap"), FALSE) != 'y')
Bram Moolenaara5792f52005-11-23 21:25:05 +00002154 goto doend;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002155 }
2156 lnum = ea.line1;
2157 ea.line1 = ea.line2;
2158 ea.line2 = lnum;
2159 }
2160 if ((errormsg = invalid_range(&ea)) != NULL)
2161 goto doend;
2162 }
2163
Bram Moolenaarb7316892019-05-01 18:08:42 +02002164 if ((ea.addr_type == ADDR_OTHER) && ea.addr_count == 0)
2165 // default is 1, not cursor
Bram Moolenaar071d4272004-06-13 20:20:40 +00002166 ea.line2 = 1;
2167
2168 correct_range(&ea);
2169
2170#ifdef FEAT_FOLDING
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002171 if (((ea.argt & EX_WHOLEFOLD) || ea.addr_count >= 2) && !global_busy
Bram Moolenaara3306952016-01-02 21:41:06 +01002172 && ea.addr_type == ADDR_LINES)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002173 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002174 // Put the first line at the start of a closed fold, put the last line
2175 // at the end of a closed fold.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002176 (void)hasFolding(ea.line1, &ea.line1, NULL);
2177 (void)hasFolding(ea.line2, NULL, &ea.line2);
2178 }
2179#endif
2180
2181#ifdef FEAT_QUICKFIX
2182 /*
Bram Moolenaar86b68352004-12-27 21:59:20 +00002183 * For the ":make" and ":grep" commands we insert the 'makeprg'/'grepprg'
Bram Moolenaar071d4272004-06-13 20:20:40 +00002184 * option here, so things like % get expanded.
2185 */
Bram Moolenaard857f0e2005-06-21 22:37:39 +00002186 p = replace_makeprg(&ea, p, cmdlinep);
2187 if (p == NULL)
2188 goto doend;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002189#endif
2190
2191 /*
2192 * Skip to start of argument.
2193 * Don't do this for the ":!" command, because ":!! -l" needs the space.
2194 */
2195 if (ea.cmdidx == CMD_bang)
2196 ea.arg = p;
2197 else
2198 ea.arg = skipwhite(p);
2199
Bram Moolenaar379fb762018-08-30 15:58:28 +02002200 // ":file" cannot be run with an argument when "curbuf_lock" is set
2201 if (ea.cmdidx == CMD_file && *ea.arg != NUL && curbuf_locked())
2202 goto doend;
2203
Bram Moolenaar071d4272004-06-13 20:20:40 +00002204 /*
2205 * Check for "++opt=val" argument.
2206 * Must be first, allow ":w ++enc=utf8 !cmd"
2207 */
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002208 if (ea.argt & EX_ARGOPT)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002209 while (ea.arg[0] == '+' && ea.arg[1] == '+')
2210 if (getargopt(&ea) == FAIL && !ni)
2211 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00002212 errormsg = _(e_invalid_argument);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002213 goto doend;
2214 }
2215
2216 if (ea.cmdidx == CMD_write || ea.cmdidx == CMD_update)
2217 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002218 if (*ea.arg == '>') // append
Bram Moolenaar071d4272004-06-13 20:20:40 +00002219 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002220 if (*++ea.arg != '>') // typed wrong
Bram Moolenaar071d4272004-06-13 20:20:40 +00002221 {
Bram Moolenaarb09feaa2022-01-02 20:20:45 +00002222 errormsg = _(e_use_w_or_w_gt_gt);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002223 goto doend;
2224 }
2225 ea.arg = skipwhite(ea.arg + 1);
2226 ea.append = TRUE;
2227 }
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002228 else if (*ea.arg == '!' && ea.cmdidx == CMD_write) // :w !filter
Bram Moolenaar071d4272004-06-13 20:20:40 +00002229 {
2230 ++ea.arg;
2231 ea.usefilter = TRUE;
2232 }
2233 }
2234
2235 if (ea.cmdidx == CMD_read)
2236 {
2237 if (ea.forceit)
2238 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002239 ea.usefilter = TRUE; // :r! filter if ea.forceit
Bram Moolenaar071d4272004-06-13 20:20:40 +00002240 ea.forceit = FALSE;
2241 }
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002242 else if (*ea.arg == '!') // :r !filter
Bram Moolenaar071d4272004-06-13 20:20:40 +00002243 {
2244 ++ea.arg;
2245 ea.usefilter = TRUE;
2246 }
2247 }
2248
2249 if (ea.cmdidx == CMD_lshift || ea.cmdidx == CMD_rshift)
2250 {
2251 ea.amount = 1;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002252 while (*ea.arg == *ea.cmd) // count number of '>' or '<'
Bram Moolenaar071d4272004-06-13 20:20:40 +00002253 {
2254 ++ea.arg;
2255 ++ea.amount;
2256 }
2257 ea.arg = skipwhite(ea.arg);
2258 }
2259
2260 /*
2261 * Check for "+command" argument, before checking for next command.
2262 * Don't do this for ":read !cmd" and ":write !cmd".
2263 */
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002264 if ((ea.argt & EX_CMDARG) && !ea.usefilter)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002265 ea.do_ecmd_cmd = getargcmd(&ea.arg);
2266
2267 /*
Bram Moolenaar63b91732021-08-05 20:40:03 +02002268 * For commands that do not use '|' inside their argument: Check for '|' to
2269 * separate commands and '"' or '#' to start comments.
2270 *
2271 * Otherwise: Check for <newline> to end a shell command.
Bram Moolenaardf177f62005-02-22 08:39:57 +00002272 * Also do this for ":read !cmd", ":write !cmd" and ":global".
Bram Moolenaar63b91732021-08-05 20:40:03 +02002273 * Also do this inside a { - } block after :command and :autocmd.
Bram Moolenaardf177f62005-02-22 08:39:57 +00002274 * Any others?
Bram Moolenaar071d4272004-06-13 20:20:40 +00002275 */
Bram Moolenaar63b91732021-08-05 20:40:03 +02002276 if ((ea.argt & EX_TRLBAR) && !ea.usefilter)
2277 {
Bram Moolenaarac485062022-03-23 19:45:01 +00002278 separate_nextcmd(&ea, FALSE);
Bram Moolenaar63b91732021-08-05 20:40:03 +02002279 }
Bram Moolenaardf177f62005-02-22 08:39:57 +00002280 else if (ea.cmdidx == CMD_bang
Bram Moolenaar67883b42017-07-27 22:57:00 +02002281 || ea.cmdidx == CMD_terminal
Bram Moolenaardf177f62005-02-22 08:39:57 +00002282 || ea.cmdidx == CMD_global
2283 || ea.cmdidx == CMD_vglobal
Bram Moolenaar63b91732021-08-05 20:40:03 +02002284 || ea.usefilter
Bram Moolenaar6f6d58c2021-08-05 21:17:32 +02002285#ifdef FEAT_EVAL
2286 || inside_block(&ea)
2287#endif
2288 )
Bram Moolenaar071d4272004-06-13 20:20:40 +00002289 {
2290 for (p = ea.arg; *p; ++p)
2291 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002292 // Remove one backslash before a newline, so that it's possible to
2293 // pass a newline to the shell and also a newline that is preceded
2294 // with a backslash. This makes it impossible to end a shell
2295 // command in a backslash, but that doesn't appear useful.
2296 // Halving the number of backslashes is incompatible with previous
2297 // versions.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002298 if (*p == '\\' && p[1] == '\n')
Bram Moolenaara7241f52008-06-24 20:39:31 +00002299 STRMOVE(p, p + 1);
Bram Moolenaarf87dac02021-12-15 17:53:40 +00002300 else if (*p == '\n' && !(ea.argt & EX_EXPR_ARG))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002301 {
2302 ea.nextcmd = p + 1;
2303 *p = NUL;
2304 break;
2305 }
2306 }
2307 }
2308
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002309 if ((ea.argt & EX_DFLALL) && ea.addr_count == 0)
Bram Moolenaarc2af0af2020-08-23 21:06:02 +02002310 address_default_all(&ea);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002311
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002312 // accept numbered register only when no count allowed (:put)
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002313 if ( (ea.argt & EX_REGSTR)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002314 && *ea.arg != NUL
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002315 // Do not allow register = for user commands
Bram Moolenaar958636c2014-10-21 20:01:58 +02002316 && (!IS_USER_CMDIDX(ea.cmdidx) || *ea.arg != '=')
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002317 && !((ea.argt & EX_COUNT) && VIM_ISDIGIT(*ea.arg)))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002318 {
Bram Moolenaar85de2062011-05-05 14:26:41 +02002319#ifndef FEAT_CLIPBOARD
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002320 // check these explicitly for a more specific error message
Bram Moolenaar85de2062011-05-05 14:26:41 +02002321 if (*ea.arg == '*' || *ea.arg == '+')
Bram Moolenaar071d4272004-06-13 20:20:40 +00002322 {
Bram Moolenaar74409f62022-01-01 15:58:22 +00002323 errormsg = _(e_invalid_register_name);
Bram Moolenaar85de2062011-05-05 14:26:41 +02002324 goto doend;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002325 }
2326#endif
Bram Moolenaar958636c2014-10-21 20:01:58 +02002327 if (valid_yank_reg(*ea.arg, (ea.cmdidx != CMD_put
2328 && !IS_USER_CMDIDX(ea.cmdidx))))
Bram Moolenaar85de2062011-05-05 14:26:41 +02002329 {
2330 ea.regname = *ea.arg++;
2331#ifdef FEAT_EVAL
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002332 // for '=' register: accept the rest of the line as an expression
Bram Moolenaar85de2062011-05-05 14:26:41 +02002333 if (ea.arg[-1] == '=' && ea.arg[0] != NUL)
2334 {
kuuote08d7b1c2021-10-04 22:17:36 +01002335 if (!ea.skip)
2336 {
2337 set_expr_line(vim_strsave(ea.arg), &ea);
2338 did_set_expr_line = TRUE;
2339 }
Bram Moolenaar85de2062011-05-05 14:26:41 +02002340 ea.arg += STRLEN(ea.arg);
2341 }
2342#endif
2343 ea.arg = skipwhite(ea.arg);
2344 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002345 }
2346
2347 /*
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002348 * Check for a count. When accepting a EX_BUFNAME, don't use "123foo" as a
Bram Moolenaar071d4272004-06-13 20:20:40 +00002349 * count, it's a buffer name.
2350 */
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002351 if ((ea.argt & EX_COUNT) && VIM_ISDIGIT(*ea.arg)
Dominique Pelle4781d6f2021-05-18 21:46:31 +02002352 && (!(ea.argt & EX_BUFNAME) || *(p = skipdigits(ea.arg + 1)) == NUL
Bram Moolenaar1c465442017-03-12 20:10:05 +01002353 || VIM_ISWHITE(*p)))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002354 {
Bram Moolenaaraf377e32021-11-29 12:12:43 +00002355 n = getdigits_quoted(&ea.arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002356 ea.arg = skipwhite(ea.arg);
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002357 if (n <= 0 && !ni && (ea.argt & EX_ZEROR) == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002358 {
Bram Moolenaar74409f62022-01-01 15:58:22 +00002359 errormsg = _(e_positive_count_required);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002360 goto doend;
2361 }
Bram Moolenaarb7316892019-05-01 18:08:42 +02002362 if (ea.addr_type != ADDR_LINES) // e.g. :buffer 2, :sleep 3
Bram Moolenaar071d4272004-06-13 20:20:40 +00002363 {
2364 ea.line2 = n;
2365 if (ea.addr_count == 0)
2366 ea.addr_count = 1;
2367 }
2368 else
2369 {
2370 ea.line1 = ea.line2;
Bram Moolenaar3cf21b32022-01-11 19:34:16 +00002371 if (ea.line2 >= LONG_MAX - (n - 1))
2372 ea.line2 = LONG_MAX; // avoid overflow
2373 else
2374 ea.line2 += n - 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002375 ++ea.addr_count;
2376 /*
2377 * Be vi compatible: no error message for out of range.
2378 */
Bram Moolenaarb7316892019-05-01 18:08:42 +02002379 if (ea.line2 > curbuf->b_ml.ml_line_count)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002380 ea.line2 = curbuf->b_ml.ml_line_count;
2381 }
2382 }
Bram Moolenaardf177f62005-02-22 08:39:57 +00002383
2384 /*
2385 * Check for flags: 'l', 'p' and '#'.
2386 */
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002387 if (ea.argt & EX_FLAGS)
Bram Moolenaardf177f62005-02-22 08:39:57 +00002388 get_flags(&ea);
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002389 if (!ni && !(ea.argt & EX_EXTRA) && *ea.arg != NUL
2390 && *ea.arg != '"' && (*ea.arg != '|' || (ea.argt & EX_TRLBAR) == 0))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002391 {
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002392 // no arguments allowed but there is something
Bram Moolenaar74409f62022-01-01 15:58:22 +00002393 errormsg = ex_errmsg(e_trailing_characters_str, ea.arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002394 goto doend;
2395 }
2396
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002397 if (!ni && (ea.argt & EX_NEEDARG) && *ea.arg == NUL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002398 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00002399 errormsg = _(e_argument_required);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002400 goto doend;
2401 }
2402
2403#ifdef FEAT_EVAL
2404 /*
2405 * Skip the command when it's not going to be executed.
2406 * The commands like :if, :endif, etc. always need to be executed.
2407 * Also make an exception for commands that handle a trailing command
2408 * themselves.
2409 */
2410 if (ea.skip)
2411 {
2412 switch (ea.cmdidx)
2413 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002414 // commands that need evaluation
Bram Moolenaar071d4272004-06-13 20:20:40 +00002415 case CMD_while:
2416 case CMD_endwhile:
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00002417 case CMD_for:
2418 case CMD_endfor:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002419 case CMD_if:
2420 case CMD_elseif:
2421 case CMD_else:
2422 case CMD_endif:
2423 case CMD_try:
2424 case CMD_catch:
2425 case CMD_finally:
2426 case CMD_endtry:
2427 case CMD_function:
Bram Moolenaarab55c682020-03-01 19:41:43 +01002428 case CMD_def:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002429 break;
2430
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002431 // Commands that handle '|' themselves. Check: A command should
2432 // either have the EX_TRLBAR flag, appear in this list or appear in
2433 // the list at ":help :bar".
Bram Moolenaar071d4272004-06-13 20:20:40 +00002434 case CMD_aboveleft:
2435 case CMD_and:
2436 case CMD_belowright:
2437 case CMD_botright:
2438 case CMD_browse:
2439 case CMD_call:
2440 case CMD_confirm:
Bram Moolenaar8f76e6b2019-11-26 16:50:30 +01002441 case CMD_const:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002442 case CMD_delfunction:
2443 case CMD_djump:
2444 case CMD_dlist:
2445 case CMD_dsearch:
2446 case CMD_dsplit:
2447 case CMD_echo:
2448 case CMD_echoerr:
2449 case CMD_echomsg:
2450 case CMD_echon:
Bram Moolenaara76b3152020-02-16 16:20:21 +01002451 case CMD_eval:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002452 case CMD_execute:
Bram Moolenaar7b668e82016-08-23 23:51:21 +02002453 case CMD_filter:
Bram Moolenaar30fd8202020-09-26 15:09:30 +02002454 case CMD_final:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002455 case CMD_help:
2456 case CMD_hide:
2457 case CMD_ijump:
2458 case CMD_ilist:
2459 case CMD_isearch:
2460 case CMD_isplit:
Bram Moolenaard4755bb2004-09-02 19:12:26 +00002461 case CMD_keepalt:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002462 case CMD_keepjumps:
2463 case CMD_keepmarks:
Bram Moolenaara939e432013-11-09 05:30:26 +01002464 case CMD_keeppatterns:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002465 case CMD_leftabove:
2466 case CMD_let:
2467 case CMD_lockmarks:
Bram Moolenaarcc4423a2019-11-26 17:05:00 +01002468 case CMD_lockvar:
Bram Moolenaar0ba04292010-07-14 23:23:17 +02002469 case CMD_lua:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002470 case CMD_match:
Bram Moolenaar325b7a22004-07-05 15:58:32 +00002471 case CMD_mzscheme:
Bram Moolenaar5803ae62014-03-23 16:04:02 +01002472 case CMD_noautocmd:
2473 case CMD_noswapfile:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002474 case CMD_perl:
2475 case CMD_psearch:
Bram Moolenaar368373e2010-07-19 20:46:22 +02002476 case CMD_py3:
Bram Moolenaarb6590522010-07-21 16:00:43 +02002477 case CMD_python3:
Bram Moolenaar30fd8202020-09-26 15:09:30 +02002478 case CMD_python:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002479 case CMD_return:
2480 case CMD_rightbelow:
2481 case CMD_ruby:
2482 case CMD_silent:
2483 case CMD_smagic:
2484 case CMD_snomagic:
2485 case CMD_substitute:
2486 case CMD_syntax:
Bram Moolenaara226a6d2006-02-26 23:59:20 +00002487 case CMD_tab:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002488 case CMD_tcl:
2489 case CMD_throw:
2490 case CMD_tilde:
2491 case CMD_topleft:
2492 case CMD_unlet:
Bram Moolenaarcc4423a2019-11-26 17:05:00 +01002493 case CMD_unlockvar:
Bram Moolenaar30fd8202020-09-26 15:09:30 +02002494 case CMD_var:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002495 case CMD_verbose:
2496 case CMD_vertical:
Bram Moolenaar12bde492011-06-13 01:19:56 +02002497 case CMD_wincmd:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002498 break;
2499
2500 default: goto doend;
2501 }
2502 }
2503#endif
2504
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002505 if (ea.argt & EX_XFILE)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002506 {
2507 if (expand_filename(&ea, cmdlinep, &errormsg) == FAIL)
2508 goto doend;
2509 }
2510
Bram Moolenaar071d4272004-06-13 20:20:40 +00002511 /*
2512 * Accept buffer name. Cannot be used at the same time with a buffer
2513 * number. Don't do this for a user command.
2514 */
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002515 if ((ea.argt & EX_BUFNAME) && *ea.arg != NUL && ea.addr_count == 0
Bram Moolenaar958636c2014-10-21 20:01:58 +02002516 && !IS_USER_CMDIDX(ea.cmdidx))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002517 {
2518 /*
2519 * :bdelete, :bwipeout and :bunload take several arguments, separated
2520 * by spaces: find next space (skipping over escaped characters).
2521 * The others take one argument: ignore trailing spaces.
2522 */
2523 if (ea.cmdidx == CMD_bdelete || ea.cmdidx == CMD_bwipeout
2524 || ea.cmdidx == CMD_bunload)
2525 p = skiptowhite_esc(ea.arg);
2526 else
2527 {
2528 p = ea.arg + STRLEN(ea.arg);
Bram Moolenaar1c465442017-03-12 20:10:05 +01002529 while (p > ea.arg && VIM_ISWHITE(p[-1]))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002530 --p;
2531 }
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002532 ea.line2 = buflist_findpat(ea.arg, p, (ea.argt & EX_BUFUNL) != 0,
Bram Moolenaar0c279bb2013-03-19 14:25:54 +01002533 FALSE, FALSE);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002534 if (ea.line2 < 0) // failed
Bram Moolenaar071d4272004-06-13 20:20:40 +00002535 goto doend;
2536 ea.addr_count = 1;
2537 ea.arg = skipwhite(p);
2538 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002539
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002540 // The :try command saves the emsg_silent flag, reset it here when
2541 // ":silent! try" was used, it should only apply to :try itself.
Bram Moolenaar5661ed62020-10-24 17:19:16 +02002542 if (ea.cmdidx == CMD_try && cmdmod.cmod_did_esilent > 0)
Bram Moolenaar2be57332018-02-13 18:05:18 +01002543 {
Bram Moolenaar5661ed62020-10-24 17:19:16 +02002544 emsg_silent -= cmdmod.cmod_did_esilent;
Bram Moolenaar2be57332018-02-13 18:05:18 +01002545 if (emsg_silent < 0)
2546 emsg_silent = 0;
Bram Moolenaar5661ed62020-10-24 17:19:16 +02002547 cmdmod.cmod_did_esilent = 0;
Bram Moolenaar2be57332018-02-13 18:05:18 +01002548 }
2549
Bram Moolenaar071d4272004-06-13 20:20:40 +00002550/*
Bram Moolenaar2be57332018-02-13 18:05:18 +01002551 * 7. Execute the command.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002552 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002553
Bram Moolenaar958636c2014-10-21 20:01:58 +02002554 if (IS_USER_CMDIDX(ea.cmdidx))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002555 {
2556 /*
2557 * Execute a user-defined command.
2558 */
2559 do_ucmd(&ea);
2560 }
2561 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00002562 {
2563 /*
Bram Moolenaarac9fb182019-04-27 13:04:13 +02002564 * Call the function to execute the builtin command.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002565 */
2566 ea.errmsg = NULL;
2567 (cmdnames[ea.cmdidx].cmd_func)(&ea);
2568 if (ea.errmsg != NULL)
Bram Moolenaar8930caa2020-07-23 16:37:03 +02002569 errormsg = ea.errmsg;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002570 }
2571
2572#ifdef FEAT_EVAL
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002573 // Set flag that any command was executed, used by ex_vim9script().
Bram Moolenaard3f8a9e2021-02-17 21:57:03 +01002574 // Not if this was a command that wasn't executed or :endif.
Yegappan Lakshmanan85b43c62022-03-21 19:45:17 +00002575 if (sourcing_a_script(&ea)
Bram Moolenaard3f8a9e2021-02-17 21:57:03 +01002576 && current_sctx.sc_sid > 0
2577 && ea.cmdidx != CMD_endif
2578 && (cstack->cs_idx < 0
2579 || (cstack->cs_flags[cstack->cs_idx] & CSF_ACTIVE)))
Bram Moolenaar2b327002020-12-26 15:39:31 +01002580 SCRIPT_ITEM(current_sctx.sc_sid)->sn_state = SN_STATE_HAD_COMMAND;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002581
Bram Moolenaar071d4272004-06-13 20:20:40 +00002582 /*
2583 * If the command just executed called do_cmdline(), any throw or ":return"
2584 * or ":finish" encountered there must also check the cstack of the still
2585 * active do_cmdline() that called this do_one_cmd(). Rethrow an uncaught
2586 * exception, or reanimate a returned function or finished script file and
2587 * return or finish it again.
2588 */
2589 if (need_rethrow)
2590 do_throw(cstack);
2591 else if (check_cstack)
2592 {
Bram Moolenaar89d40322006-08-29 15:30:07 +00002593 if (source_finished(fgetline, cookie))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002594 do_finish(&ea, TRUE);
Bram Moolenaar89d40322006-08-29 15:30:07 +00002595 else if (getline_equal(fgetline, cookie, get_func_line)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002596 && current_func_returned())
2597 do_return(&ea, TRUE, FALSE, NULL);
2598 }
2599 need_rethrow = check_cstack = FALSE;
2600#endif
2601
2602doend:
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002603 if (curwin->w_cursor.lnum == 0) // can happen with zero line number
Bram Moolenaar6de5e122017-04-20 21:55:44 +02002604 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00002605 curwin->w_cursor.lnum = 1;
Bram Moolenaar6de5e122017-04-20 21:55:44 +02002606 curwin->w_cursor.col = 0;
2607 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002608
2609 if (errormsg != NULL && *errormsg != NUL && !did_emsg)
2610 {
Bram Moolenaarbed34f02022-01-19 20:48:37 +00002611 if (sourcing || !KeyTyped)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002612 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002613 if (errormsg != (char *)IObuff)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002614 {
2615 STRCPY(IObuff, errormsg);
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002616 errormsg = (char *)IObuff;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002617 }
Bram Moolenaara6f4d612011-09-21 19:10:46 +02002618 append_command(*cmdlinep);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002619 }
2620 emsg(errormsg);
2621 }
2622#ifdef FEAT_EVAL
2623 do_errthrow(cstack,
Bram Moolenaar958636c2014-10-21 20:01:58 +02002624 (ea.cmdidx != CMD_SIZE && !IS_USER_CMDIDX(ea.cmdidx))
2625 ? cmdnames[(int)ea.cmdidx].cmd_name : (char_u *)NULL);
Bram Moolenaarb4bcea42020-10-28 13:53:50 +01002626
2627 if (did_set_expr_line)
2628 set_expr_line(NULL, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002629#endif
2630
Bram Moolenaare1004402020-10-24 20:49:43 +02002631 undo_cmdmod(&cmdmod);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002632 cmdmod = save_cmdmod;
Bram Moolenaar9a2c0912019-03-30 14:26:18 +01002633 reg_executing = save_reg_executing;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002634
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002635 if (ea.nextcmd && *ea.nextcmd == NUL) // not really a next command
Bram Moolenaar071d4272004-06-13 20:20:40 +00002636 ea.nextcmd = NULL;
2637
2638#ifdef FEAT_EVAL
2639 --ex_nesting_level;
Bram Moolenaarb171fb12020-06-24 20:34:03 +02002640 vim_free(ea.cmdline_tofree);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002641#endif
2642
2643 return ea.nextcmd;
2644}
Bram Moolenaar071d4272004-06-13 20:20:40 +00002645
Bram Moolenaar8930caa2020-07-23 16:37:03 +02002646static char ex_error_buf[MSG_BUF_LEN];
2647
2648/*
2649 * Return an error message with argument included.
2650 * Uses a static buffer, only the last error will be kept.
2651 * "msg" will be translated, caller should use N_().
2652 */
2653 char *
2654ex_errmsg(char *msg, char_u *arg)
2655{
2656 vim_snprintf(ex_error_buf, MSG_BUF_LEN, _(msg), arg);
2657 return ex_error_buf;
2658}
2659
Bram Moolenaar071d4272004-06-13 20:20:40 +00002660/*
Bram Moolenaare4eed8c2021-12-01 15:22:56 +00002661 * Handle a range without a command.
2662 * Returns an error message on failure.
2663 */
2664 char *
2665ex_range_without_command(exarg_T *eap)
2666{
2667 char *errormsg = NULL;
2668
2669 if ((*eap->cmd == '|' || (exmode_active && eap->line1 != eap->line2))
2670#ifdef FEAT_EVAL
2671 && !in_vim9script()
2672#endif
2673 )
2674 {
2675 eap->cmdidx = CMD_print;
2676 eap->argt = EX_RANGE+EX_COUNT+EX_TRLBAR;
2677 if ((errormsg = invalid_range(eap)) == NULL)
2678 {
2679 correct_range(eap);
2680 ex_print(eap);
2681 }
2682 }
2683 else if (eap->addr_count != 0)
2684 {
2685 if (eap->line2 > curbuf->b_ml.ml_line_count)
2686 {
2687 // With '-' in 'cpoptions' a line number past the file is an
2688 // error, otherwise put it at the end of the file.
2689 if (vim_strchr(p_cpo, CPO_MINUS) != NULL)
2690 eap->line2 = -1;
2691 else
2692 eap->line2 = curbuf->b_ml.ml_line_count;
2693 }
2694
2695 if (eap->line2 < 0)
2696 errormsg = _(e_invalid_range);
2697 else
2698 {
2699 if (eap->line2 == 0)
2700 curwin->w_cursor.lnum = 1;
2701 else
2702 curwin->w_cursor.lnum = eap->line2;
2703 beginline(BL_SOL | BL_FIX);
2704 }
2705 }
2706 return errormsg;
2707}
2708
2709/*
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002710 * Check for an Ex command with optional tail.
2711 * If there is a match advance "pp" to the argument and return TRUE.
Bram Moolenaar68854a82022-01-31 18:59:13 +00002712 * If "noparen" is TRUE do not recognize the command followed by "(" or ".".
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002713 */
2714 static int
2715checkforcmd_opt(
2716 char_u **pp, // start of command
2717 char *cmd, // name of command
2718 int len, // required length
2719 int noparen)
2720{
2721 int i;
2722
2723 for (i = 0; cmd[i] != NUL; ++i)
2724 if (((char_u *)cmd)[i] != (*pp)[i])
2725 break;
Bram Moolenaar68854a82022-01-31 18:59:13 +00002726 if (i >= len && !isalpha((*pp)[i]) && (*pp)[i] != '_'
2727 && (!noparen || ((*pp)[i] != '(' && (*pp)[i] != '.')))
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002728 {
2729 *pp = skipwhite(*pp + i);
2730 return TRUE;
2731 }
2732 return FALSE;
2733}
2734
2735/*
2736 * Check for an Ex command with optional tail.
2737 * If there is a match advance "pp" to the argument and return TRUE.
2738 */
2739 int
2740checkforcmd(
2741 char_u **pp, // start of command
2742 char *cmd, // name of command
2743 int len) // required length
2744{
2745 return checkforcmd_opt(pp, cmd, len, FALSE);
2746}
2747
2748/*
Bram Moolenaar68854a82022-01-31 18:59:13 +00002749 * Check for an Ex command with optional tail, not followed by "(" or ".".
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002750 * If there is a match advance "pp" to the argument and return TRUE.
2751 */
Bram Moolenaare4db17f2021-08-01 21:19:43 +02002752 int
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002753checkforcmd_noparen(
2754 char_u **pp, // start of command
2755 char *cmd, // name of command
2756 int len) // required length
2757{
2758 return checkforcmd_opt(pp, cmd, len, TRUE);
2759}
2760
2761/*
Bram Moolenaareffed932018-08-14 13:38:17 +02002762 * Parse and skip over command modifiers:
2763 * - update eap->cmd
Bram Moolenaare1004402020-10-24 20:49:43 +02002764 * - store flags in "cmod".
Bram Moolenaareffed932018-08-14 13:38:17 +02002765 * - Set ex_pressedreturn for an empty command line.
Bram Moolenaar33c4dbb2018-08-14 16:06:16 +02002766 * When "skip_only" is TRUE the global variables are not changed, except for
2767 * "cmdmod".
Bram Moolenaare1004402020-10-24 20:49:43 +02002768 * When "skip_only" is FALSE then undo_cmdmod() must be called later to free
2769 * any cmod_filter_regmatch.regprog.
Bram Moolenaar5661ed62020-10-24 17:19:16 +02002770 * Call apply_cmdmod() to get the side effects of the modifiers:
2771 * - Increment "sandbox" for ":sandbox"
2772 * - set p_verbose for ":verbose"
Bram Moolenaare1004402020-10-24 20:49:43 +02002773 * - set msg_silent for ":silent"
2774 * - set 'eventignore' to "all" for ":noautocmd"
Bram Moolenaareffed932018-08-14 13:38:17 +02002775 * Return FAIL when the command is not to be executed.
2776 * May set "errormsg" to an error message.
2777 */
2778 int
Bram Moolenaare1004402020-10-24 20:49:43 +02002779parse_command_modifiers(
2780 exarg_T *eap,
2781 char **errormsg,
2782 cmdmod_T *cmod,
2783 int skip_only)
Bram Moolenaareffed932018-08-14 13:38:17 +02002784{
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002785 char_u *p;
2786 int starts_with_colon = FALSE;
Bram Moolenaarbc510062022-02-14 21:19:04 +00002787 int vim9script = in_vim9script();
Bram Moolenaareffed932018-08-14 13:38:17 +02002788
Bram Moolenaare1004402020-10-24 20:49:43 +02002789 CLEAR_POINTER(cmod);
Bram Moolenaar5b1d6e92022-02-11 20:33:48 +00002790 cmod->cmod_flags = sticky_cmdmod_flags;
Bram Moolenaareffed932018-08-14 13:38:17 +02002791
Bram Moolenaar33c4dbb2018-08-14 16:06:16 +02002792 // Repeat until no more command modifiers are found.
Bram Moolenaareffed932018-08-14 13:38:17 +02002793 for (;;)
2794 {
Bram Moolenaareffed932018-08-14 13:38:17 +02002795 while (*eap->cmd == ' ' || *eap->cmd == '\t' || *eap->cmd == ':')
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002796 {
2797 if (*eap->cmd == ':')
2798 starts_with_colon = TRUE;
Bram Moolenaareffed932018-08-14 13:38:17 +02002799 ++eap->cmd;
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002800 }
Bram Moolenaareffed932018-08-14 13:38:17 +02002801
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002802 // in ex mode, an empty line works like :+
Bram Moolenaareffed932018-08-14 13:38:17 +02002803 if (*eap->cmd == NUL && exmode_active
2804 && (getline_equal(eap->getline, eap->cookie, getexmodeline)
2805 || getline_equal(eap->getline, eap->cookie, getexline))
2806 && curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count)
2807 {
2808 eap->cmd = (char_u *)"+";
Bram Moolenaar33c4dbb2018-08-14 16:06:16 +02002809 if (!skip_only)
2810 ex_pressedreturn = TRUE;
Bram Moolenaareffed932018-08-14 13:38:17 +02002811 }
2812
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002813 // ignore comment and empty lines
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002814 if (comment_start(eap->cmd, starts_with_colon))
Bram Moolenaarec1b0962021-09-06 17:10:59 +02002815 {
2816 // a comment ends at a NL
2817 if (eap->nextcmd == NULL)
2818 {
2819 eap->nextcmd = vim_strchr(eap->cmd, '\n');
2820 if (eap->nextcmd != NULL)
2821 ++eap->nextcmd;
2822 }
Bram Moolenaarbc510062022-02-14 21:19:04 +00002823 if (vim9script && has_cmdmod(cmod, FALSE))
2824 *errormsg = _(e_command_modifier_without_command);
Bram Moolenaareffed932018-08-14 13:38:17 +02002825 return FAIL;
Bram Moolenaarec1b0962021-09-06 17:10:59 +02002826 }
Bram Moolenaareffed932018-08-14 13:38:17 +02002827 if (*eap->cmd == NUL)
2828 {
Bram Moolenaar33c4dbb2018-08-14 16:06:16 +02002829 if (!skip_only)
Bram Moolenaarbc510062022-02-14 21:19:04 +00002830 {
Bram Moolenaar33c4dbb2018-08-14 16:06:16 +02002831 ex_pressedreturn = TRUE;
Bram Moolenaarbc510062022-02-14 21:19:04 +00002832 if (vim9script && has_cmdmod(cmod, FALSE))
2833 *errormsg = _(e_command_modifier_without_command);
2834 }
Bram Moolenaareffed932018-08-14 13:38:17 +02002835 return FAIL;
2836 }
2837
Bram Moolenaar3bd8de42020-09-14 16:37:34 +02002838 p = skip_range(eap->cmd, TRUE, NULL);
Bram Moolenaar17126b12021-01-07 22:03:02 +01002839
2840 // In Vim9 script a variable can shadow a command modifier:
2841 // verbose = 123
2842 // verbose += 123
2843 // silent! verbose = func()
2844 // verbose.member = 2
2845 // verbose[expr] = 2
Bram Moolenaar9e0f8832021-01-09 12:09:22 +01002846 // But not:
2847 // verbose [a, b] = list
Bram Moolenaarbc510062022-02-14 21:19:04 +00002848 if (vim9script)
Bram Moolenaar17126b12021-01-07 22:03:02 +01002849 {
Bram Moolenaar9e0f8832021-01-09 12:09:22 +01002850 char_u *s, *n;
Bram Moolenaar17126b12021-01-07 22:03:02 +01002851
2852 for (s = p; ASCII_ISALPHA(*s); ++s)
2853 ;
Bram Moolenaar9e0f8832021-01-09 12:09:22 +01002854 n = skipwhite(s);
2855 if (vim_strchr((char_u *)".=", *n) != NULL
2856 || *s == '['
2857 || (*n != NUL && n[1] == '='))
Bram Moolenaar17126b12021-01-07 22:03:02 +01002858 break;
2859 }
2860
Bram Moolenaareffed932018-08-14 13:38:17 +02002861 switch (*p)
2862 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002863 // When adding an entry, also modify cmd_exists().
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002864 case 'a': if (!checkforcmd_noparen(&eap->cmd, "aboveleft", 3))
Bram Moolenaareffed932018-08-14 13:38:17 +02002865 break;
Bram Moolenaare1004402020-10-24 20:49:43 +02002866 cmod->cmod_split |= WSP_ABOVE;
Bram Moolenaareffed932018-08-14 13:38:17 +02002867 continue;
2868
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002869 case 'b': if (checkforcmd_noparen(&eap->cmd, "belowright", 3))
Bram Moolenaareffed932018-08-14 13:38:17 +02002870 {
Bram Moolenaare1004402020-10-24 20:49:43 +02002871 cmod->cmod_split |= WSP_BELOW;
Bram Moolenaareffed932018-08-14 13:38:17 +02002872 continue;
2873 }
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002874 if (checkforcmd_opt(&eap->cmd, "browse", 3, TRUE))
Bram Moolenaareffed932018-08-14 13:38:17 +02002875 {
2876#ifdef FEAT_BROWSE_CMD
Bram Moolenaare1004402020-10-24 20:49:43 +02002877 cmod->cmod_flags |= CMOD_BROWSE;
Bram Moolenaareffed932018-08-14 13:38:17 +02002878#endif
2879 continue;
2880 }
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002881 if (!checkforcmd_noparen(&eap->cmd, "botright", 2))
Bram Moolenaareffed932018-08-14 13:38:17 +02002882 break;
Bram Moolenaare1004402020-10-24 20:49:43 +02002883 cmod->cmod_split |= WSP_BOT;
Bram Moolenaareffed932018-08-14 13:38:17 +02002884 continue;
2885
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002886 case 'c': if (!checkforcmd_opt(&eap->cmd, "confirm", 4, TRUE))
Bram Moolenaareffed932018-08-14 13:38:17 +02002887 break;
2888#if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
Bram Moolenaare1004402020-10-24 20:49:43 +02002889 cmod->cmod_flags |= CMOD_CONFIRM;
Bram Moolenaareffed932018-08-14 13:38:17 +02002890#endif
2891 continue;
2892
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002893 case 'k': if (checkforcmd_noparen(&eap->cmd, "keepmarks", 3))
Bram Moolenaareffed932018-08-14 13:38:17 +02002894 {
Bram Moolenaare1004402020-10-24 20:49:43 +02002895 cmod->cmod_flags |= CMOD_KEEPMARKS;
Bram Moolenaareffed932018-08-14 13:38:17 +02002896 continue;
2897 }
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002898 if (checkforcmd_noparen(&eap->cmd, "keepalt", 5))
Bram Moolenaareffed932018-08-14 13:38:17 +02002899 {
Bram Moolenaare1004402020-10-24 20:49:43 +02002900 cmod->cmod_flags |= CMOD_KEEPALT;
Bram Moolenaareffed932018-08-14 13:38:17 +02002901 continue;
2902 }
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002903 if (checkforcmd_noparen(&eap->cmd, "keeppatterns", 5))
Bram Moolenaareffed932018-08-14 13:38:17 +02002904 {
Bram Moolenaare1004402020-10-24 20:49:43 +02002905 cmod->cmod_flags |= CMOD_KEEPPATTERNS;
Bram Moolenaareffed932018-08-14 13:38:17 +02002906 continue;
2907 }
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002908 if (!checkforcmd_noparen(&eap->cmd, "keepjumps", 5))
Bram Moolenaareffed932018-08-14 13:38:17 +02002909 break;
Bram Moolenaare1004402020-10-24 20:49:43 +02002910 cmod->cmod_flags |= CMOD_KEEPJUMPS;
Bram Moolenaareffed932018-08-14 13:38:17 +02002911 continue;
2912
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002913 case 'f': // only accept ":filter {pat} cmd"
Bram Moolenaareffed932018-08-14 13:38:17 +02002914 {
Bram Moolenaare729ce22021-06-06 21:38:09 +02002915 char_u *reg_pat;
2916 char_u *nulp = NULL;
2917 int c = 0;
Bram Moolenaareffed932018-08-14 13:38:17 +02002918
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002919 if (!checkforcmd_noparen(&p, "filter", 4)
Bram Moolenaar06bffe82021-11-28 20:24:17 +00002920 || *p == NUL
2921 || (ends_excmd(*p)
2922#ifdef FEAT_EVAL
2923 // in ":filter #pat# cmd" # does not
2924 // start a comment
Bram Moolenaarbc510062022-02-14 21:19:04 +00002925 && (!vim9script || VIM_ISWHITE(p[1]))
Bram Moolenaar06bffe82021-11-28 20:24:17 +00002926#endif
2927 ))
Bram Moolenaareffed932018-08-14 13:38:17 +02002928 break;
2929 if (*p == '!')
2930 {
Bram Moolenaare1004402020-10-24 20:49:43 +02002931 cmod->cmod_filter_force = TRUE;
Bram Moolenaareffed932018-08-14 13:38:17 +02002932 p = skipwhite(p + 1);
2933 if (*p == NUL || ends_excmd(*p))
2934 break;
2935 }
Bram Moolenaar1e624c92020-07-11 14:08:04 +02002936#ifdef FEAT_EVAL
Bram Moolenaarb074e8b2020-07-11 13:40:45 +02002937 // Avoid that "filter(arg)" is recognized.
Bram Moolenaarbc510062022-02-14 21:19:04 +00002938 if (vim9script && !VIM_ISWHITE(p[-1]))
Bram Moolenaarb074e8b2020-07-11 13:40:45 +02002939 break;
Bram Moolenaar1e624c92020-07-11 14:08:04 +02002940#endif
Bram Moolenaar33c4dbb2018-08-14 16:06:16 +02002941 if (skip_only)
2942 p = skip_vimgrep_pat(p, NULL, NULL);
2943 else
2944 // NOTE: This puts a NUL after the pattern.
Bram Moolenaare729ce22021-06-06 21:38:09 +02002945 p = skip_vimgrep_pat_ext(p, &reg_pat, NULL,
2946 &nulp, &c);
Bram Moolenaareffed932018-08-14 13:38:17 +02002947 if (p == NULL || *p == NUL)
2948 break;
Bram Moolenaar33c4dbb2018-08-14 16:06:16 +02002949 if (!skip_only)
2950 {
Bram Moolenaare1004402020-10-24 20:49:43 +02002951 cmod->cmod_filter_regmatch.regprog =
Bram Moolenaareffed932018-08-14 13:38:17 +02002952 vim_regcomp(reg_pat, RE_MAGIC);
Bram Moolenaare1004402020-10-24 20:49:43 +02002953 if (cmod->cmod_filter_regmatch.regprog == NULL)
Bram Moolenaar33c4dbb2018-08-14 16:06:16 +02002954 break;
Bram Moolenaare729ce22021-06-06 21:38:09 +02002955 // restore the character overwritten by NUL
2956 if (nulp != NULL)
2957 *nulp = c;
Bram Moolenaar33c4dbb2018-08-14 16:06:16 +02002958 }
Bram Moolenaareffed932018-08-14 13:38:17 +02002959 eap->cmd = p;
2960 continue;
2961 }
2962
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002963 // ":hide" and ":hide | cmd" are not modifiers
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002964 case 'h': if (p != eap->cmd || !checkforcmd_noparen(&p, "hide", 3)
Bram Moolenaareffed932018-08-14 13:38:17 +02002965 || *p == NUL || ends_excmd(*p))
2966 break;
2967 eap->cmd = p;
Bram Moolenaare1004402020-10-24 20:49:43 +02002968 cmod->cmod_flags |= CMOD_HIDE;
Bram Moolenaareffed932018-08-14 13:38:17 +02002969 continue;
2970
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002971 case 'l': if (checkforcmd_noparen(&eap->cmd, "lockmarks", 3))
Bram Moolenaareffed932018-08-14 13:38:17 +02002972 {
Bram Moolenaare1004402020-10-24 20:49:43 +02002973 cmod->cmod_flags |= CMOD_LOCKMARKS;
Bram Moolenaareffed932018-08-14 13:38:17 +02002974 continue;
2975 }
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02002976 if (checkforcmd_noparen(&eap->cmd, "legacy", 3))
2977 {
2978 if (ends_excmd2(p, eap->cmd))
2979 {
2980 *errormsg =
Bram Moolenaardd9de502021-08-15 13:49:42 +02002981 _(e_legacy_must_be_followed_by_command);
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02002982 return FAIL;
2983 }
2984 cmod->cmod_flags |= CMOD_LEGACY;
2985 continue;
2986 }
Bram Moolenaareffed932018-08-14 13:38:17 +02002987
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002988 if (!checkforcmd_noparen(&eap->cmd, "leftabove", 5))
Bram Moolenaareffed932018-08-14 13:38:17 +02002989 break;
Bram Moolenaare1004402020-10-24 20:49:43 +02002990 cmod->cmod_split |= WSP_ABOVE;
Bram Moolenaareffed932018-08-14 13:38:17 +02002991 continue;
2992
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002993 case 'n': if (checkforcmd_noparen(&eap->cmd, "noautocmd", 3))
Bram Moolenaareffed932018-08-14 13:38:17 +02002994 {
Bram Moolenaare1004402020-10-24 20:49:43 +02002995 cmod->cmod_flags |= CMOD_NOAUTOCMD;
Bram Moolenaareffed932018-08-14 13:38:17 +02002996 continue;
2997 }
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002998 if (!checkforcmd_noparen(&eap->cmd, "noswapfile", 3))
Bram Moolenaareffed932018-08-14 13:38:17 +02002999 break;
Bram Moolenaare1004402020-10-24 20:49:43 +02003000 cmod->cmod_flags |= CMOD_NOSWAPFILE;
Bram Moolenaareffed932018-08-14 13:38:17 +02003001 continue;
3002
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01003003 case 'r': if (!checkforcmd_noparen(&eap->cmd, "rightbelow", 6))
Bram Moolenaareffed932018-08-14 13:38:17 +02003004 break;
Bram Moolenaare1004402020-10-24 20:49:43 +02003005 cmod->cmod_split |= WSP_BELOW;
Bram Moolenaareffed932018-08-14 13:38:17 +02003006 continue;
3007
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01003008 case 's': if (checkforcmd_noparen(&eap->cmd, "sandbox", 3))
Bram Moolenaareffed932018-08-14 13:38:17 +02003009 {
Bram Moolenaare1004402020-10-24 20:49:43 +02003010 cmod->cmod_flags |= CMOD_SANDBOX;
Bram Moolenaareffed932018-08-14 13:38:17 +02003011 continue;
3012 }
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01003013 if (!checkforcmd_noparen(&eap->cmd, "silent", 3))
Bram Moolenaareffed932018-08-14 13:38:17 +02003014 break;
Bram Moolenaare1004402020-10-24 20:49:43 +02003015 cmod->cmod_flags |= CMOD_SILENT;
Bram Moolenaareffed932018-08-14 13:38:17 +02003016 if (*eap->cmd == '!' && !VIM_ISWHITE(eap->cmd[-1]))
3017 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003018 // ":silent!", but not "silent !cmd"
Bram Moolenaareffed932018-08-14 13:38:17 +02003019 eap->cmd = skipwhite(eap->cmd + 1);
Bram Moolenaare1004402020-10-24 20:49:43 +02003020 cmod->cmod_flags |= CMOD_ERRSILENT;
Bram Moolenaareffed932018-08-14 13:38:17 +02003021 }
3022 continue;
3023
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01003024 case 't': if (checkforcmd_noparen(&p, "tab", 3))
Bram Moolenaareffed932018-08-14 13:38:17 +02003025 {
Bram Moolenaar548e5982018-12-26 21:45:00 +01003026 if (!skip_only)
Bram Moolenaareffed932018-08-14 13:38:17 +02003027 {
Bram Moolenaar548e5982018-12-26 21:45:00 +01003028 long tabnr = get_address(eap, &eap->cmd,
3029 ADDR_TABS, eap->skip,
3030 skip_only, FALSE, 1);
3031 if (tabnr == MAXLNUM)
Bram Moolenaare1004402020-10-24 20:49:43 +02003032 cmod->cmod_tab = tabpage_index(curtab) + 1;
Bram Moolenaar548e5982018-12-26 21:45:00 +01003033 else
Bram Moolenaareffed932018-08-14 13:38:17 +02003034 {
Bram Moolenaar548e5982018-12-26 21:45:00 +01003035 if (tabnr < 0 || tabnr > LAST_TAB_NR)
3036 {
Bram Moolenaar108010a2021-06-27 22:03:33 +02003037 *errormsg = _(e_invalid_range);
Bram Moolenaar548e5982018-12-26 21:45:00 +01003038 return FAIL;
3039 }
Bram Moolenaare1004402020-10-24 20:49:43 +02003040 cmod->cmod_tab = tabnr + 1;
Bram Moolenaareffed932018-08-14 13:38:17 +02003041 }
Bram Moolenaareffed932018-08-14 13:38:17 +02003042 }
3043 eap->cmd = p;
3044 continue;
3045 }
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01003046 if (!checkforcmd_noparen(&eap->cmd, "topleft", 2))
Bram Moolenaareffed932018-08-14 13:38:17 +02003047 break;
Bram Moolenaare1004402020-10-24 20:49:43 +02003048 cmod->cmod_split |= WSP_TOP;
Bram Moolenaareffed932018-08-14 13:38:17 +02003049 continue;
3050
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01003051 case 'u': if (!checkforcmd_noparen(&eap->cmd, "unsilent", 3))
Bram Moolenaareffed932018-08-14 13:38:17 +02003052 break;
Bram Moolenaare1004402020-10-24 20:49:43 +02003053 cmod->cmod_flags |= CMOD_UNSILENT;
Bram Moolenaareffed932018-08-14 13:38:17 +02003054 continue;
3055
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01003056 case 'v': if (checkforcmd_noparen(&eap->cmd, "vertical", 4))
Bram Moolenaareffed932018-08-14 13:38:17 +02003057 {
Bram Moolenaare1004402020-10-24 20:49:43 +02003058 cmod->cmod_split |= WSP_VERT;
Bram Moolenaareffed932018-08-14 13:38:17 +02003059 continue;
3060 }
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01003061 if (checkforcmd_noparen(&eap->cmd, "vim9cmd", 4))
Bram Moolenaar39f3b142021-02-14 12:57:36 +01003062 {
3063 if (ends_excmd2(p, eap->cmd))
3064 {
3065 *errormsg =
3066 _(e_vim9cmd_must_be_followed_by_command);
3067 return FAIL;
3068 }
3069 cmod->cmod_flags |= CMOD_VIM9CMD;
3070 continue;
3071 }
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01003072 if (!checkforcmd_noparen(&p, "verbose", 4))
Bram Moolenaareffed932018-08-14 13:38:17 +02003073 break;
Bram Moolenaar5661ed62020-10-24 17:19:16 +02003074 if (vim_isdigit(*eap->cmd))
Bram Moolenaare1004402020-10-24 20:49:43 +02003075 cmod->cmod_verbose = atoi((char *)eap->cmd);
Bram Moolenaar5661ed62020-10-24 17:19:16 +02003076 else
Bram Moolenaare1004402020-10-24 20:49:43 +02003077 cmod->cmod_verbose = 1;
Bram Moolenaareffed932018-08-14 13:38:17 +02003078 eap->cmd = p;
3079 continue;
3080 }
3081 break;
3082 }
3083
3084 return OK;
3085}
3086
3087/*
Bram Moolenaarfa984412021-03-25 22:15:28 +01003088 * Return TRUE if "cmod" has anything set.
3089 */
3090 int
Bram Moolenaar917c46a2021-08-10 19:53:01 +02003091has_cmdmod(cmdmod_T *cmod, int ignore_silent)
Bram Moolenaarfa984412021-03-25 22:15:28 +01003092{
Bram Moolenaar917c46a2021-08-10 19:53:01 +02003093 return (cmod->cmod_flags != 0 && (!ignore_silent
3094 || (cmod->cmod_flags
3095 & ~(CMOD_SILENT | CMOD_ERRSILENT | CMOD_UNSILENT)) != 0))
Bram Moolenaarfa984412021-03-25 22:15:28 +01003096 || cmod->cmod_split != 0
3097 || cmod->cmod_verbose != 0
3098 || cmod->cmod_tab != 0
3099 || cmod->cmod_filter_regmatch.regprog != NULL;
3100}
3101
Bram Moolenaar8991be22022-02-14 21:51:46 +00003102#if defined(FEAT_EVAL) || defined(PROTO)
Bram Moolenaarfa984412021-03-25 22:15:28 +01003103/*
3104 * If Vim9 script and "cmdmod" has anything set give an error and return TRUE.
3105 */
3106 int
Bram Moolenaar917c46a2021-08-10 19:53:01 +02003107cmdmod_error(int ignore_silent)
Bram Moolenaarfa984412021-03-25 22:15:28 +01003108{
Bram Moolenaar917c46a2021-08-10 19:53:01 +02003109 if (in_vim9script() && has_cmdmod(&cmdmod, ignore_silent))
Bram Moolenaarfa984412021-03-25 22:15:28 +01003110 {
3111 emsg(_(e_misplaced_command_modifier));
3112 return TRUE;
3113 }
3114 return FALSE;
3115}
Dominique Pelle748b3082022-01-08 12:41:16 +00003116#endif
Bram Moolenaarfa984412021-03-25 22:15:28 +01003117
3118/*
Bram Moolenaar5661ed62020-10-24 17:19:16 +02003119 * Apply the command modifiers. Saves current state in "cmdmod", call
3120 * undo_cmdmod() later.
3121 */
3122 void
3123apply_cmdmod(cmdmod_T *cmod)
3124{
3125#ifdef HAVE_SANDBOX
3126 if ((cmod->cmod_flags & CMOD_SANDBOX) && !cmod->cmod_did_sandbox)
3127 {
3128 ++sandbox;
3129 cmod->cmod_did_sandbox = TRUE;
3130 }
3131#endif
3132 if (cmod->cmod_verbose > 0)
3133 {
3134 if (cmod->cmod_verbose_save == 0)
3135 cmod->cmod_verbose_save = p_verbose + 1;
3136 p_verbose = cmod->cmod_verbose;
3137 }
3138
3139 if ((cmod->cmod_flags & (CMOD_SILENT | CMOD_UNSILENT))
3140 && cmod->cmod_save_msg_silent == 0)
Bram Moolenaare1004402020-10-24 20:49:43 +02003141 {
Bram Moolenaar5661ed62020-10-24 17:19:16 +02003142 cmod->cmod_save_msg_silent = msg_silent + 1;
Bram Moolenaare1004402020-10-24 20:49:43 +02003143 cmod->cmod_save_msg_scroll = msg_scroll;
3144 }
Bram Moolenaar5661ed62020-10-24 17:19:16 +02003145 if (cmod->cmod_flags & CMOD_SILENT)
3146 ++msg_silent;
3147 if (cmod->cmod_flags & CMOD_UNSILENT)
3148 msg_silent = 0;
3149
3150 if (cmod->cmod_flags & CMOD_ERRSILENT)
3151 {
3152 ++emsg_silent;
3153 ++cmod->cmod_did_esilent;
3154 }
3155
Bram Moolenaare1004402020-10-24 20:49:43 +02003156 if ((cmod->cmod_flags & CMOD_NOAUTOCMD) && cmod->cmod_save_ei == NULL)
Bram Moolenaar5661ed62020-10-24 17:19:16 +02003157 {
3158 // Set 'eventignore' to "all".
3159 // First save the existing option value for restoring it later.
Bram Moolenaare1004402020-10-24 20:49:43 +02003160 cmod->cmod_save_ei = vim_strsave(p_ei);
Bram Moolenaar5661ed62020-10-24 17:19:16 +02003161 set_string_option_direct((char_u *)"ei", -1,
3162 (char_u *)"all", OPT_FREE, SID_NONE);
3163 }
3164}
3165
3166/*
Bram Moolenaare1004402020-10-24 20:49:43 +02003167 * Undo and free contents of "cmod".
Bram Moolenaar33c4dbb2018-08-14 16:06:16 +02003168 */
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003169 void
Bram Moolenaare1004402020-10-24 20:49:43 +02003170undo_cmdmod(cmdmod_T *cmod)
Bram Moolenaar33c4dbb2018-08-14 16:06:16 +02003171{
Bram Moolenaare1004402020-10-24 20:49:43 +02003172 if (cmod->cmod_verbose_save > 0)
Bram Moolenaar5661ed62020-10-24 17:19:16 +02003173 {
Bram Moolenaare1004402020-10-24 20:49:43 +02003174 p_verbose = cmod->cmod_verbose_save - 1;
3175 cmod->cmod_verbose_save = 0;
Bram Moolenaar5661ed62020-10-24 17:19:16 +02003176 }
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003177
Bram Moolenaar5661ed62020-10-24 17:19:16 +02003178#ifdef HAVE_SANDBOX
Bram Moolenaare1004402020-10-24 20:49:43 +02003179 if (cmod->cmod_did_sandbox)
Bram Moolenaar5661ed62020-10-24 17:19:16 +02003180 {
3181 --sandbox;
Bram Moolenaare1004402020-10-24 20:49:43 +02003182 cmod->cmod_did_sandbox = FALSE;
Bram Moolenaar5661ed62020-10-24 17:19:16 +02003183 }
3184#endif
3185
Bram Moolenaare1004402020-10-24 20:49:43 +02003186 if (cmod->cmod_save_ei != NULL)
Bram Moolenaar33c4dbb2018-08-14 16:06:16 +02003187 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003188 // Restore 'eventignore' to the value before ":noautocmd".
Bram Moolenaare1004402020-10-24 20:49:43 +02003189 set_string_option_direct((char_u *)"ei", -1, cmod->cmod_save_ei,
3190 OPT_FREE, SID_NONE);
3191 free_string_option(cmod->cmod_save_ei);
3192 cmod->cmod_save_ei = NULL;
Bram Moolenaar33c4dbb2018-08-14 16:06:16 +02003193 }
3194
Bram Moolenaarcaf73dc2020-10-26 21:39:13 +01003195 vim_regfree(cmod->cmod_filter_regmatch.regprog);
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003196
Bram Moolenaare1004402020-10-24 20:49:43 +02003197 if (cmod->cmod_save_msg_silent > 0)
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003198 {
3199 // messages could be enabled for a serious error, need to check if the
3200 // counters don't become negative
Bram Moolenaare1004402020-10-24 20:49:43 +02003201 if (!did_emsg || msg_silent > cmod->cmod_save_msg_silent - 1)
3202 msg_silent = cmod->cmod_save_msg_silent - 1;
3203 emsg_silent -= cmod->cmod_did_esilent;
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003204 if (emsg_silent < 0)
3205 emsg_silent = 0;
3206 // Restore msg_scroll, it's set by file I/O commands, even when no
3207 // message is actually displayed.
Bram Moolenaare1004402020-10-24 20:49:43 +02003208 msg_scroll = cmod->cmod_save_msg_scroll;
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003209
3210 // "silent reg" or "silent echo x" inside "redir" leaves msg_col
3211 // somewhere in the line. Put it back in the first column.
3212 if (redirecting())
3213 msg_col = 0;
Bram Moolenaar5661ed62020-10-24 17:19:16 +02003214
Bram Moolenaare1004402020-10-24 20:49:43 +02003215 cmod->cmod_save_msg_silent = 0;
3216 cmod->cmod_did_esilent = 0;
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003217 }
Bram Moolenaar33c4dbb2018-08-14 16:06:16 +02003218}
3219
3220/*
Bram Moolenaaree8415b2018-08-10 23:13:12 +02003221 * Parse the address range, if any, in "eap".
Bram Moolenaar50eb16c2018-09-15 15:42:40 +02003222 * May set the last search pattern, unless "silent" is TRUE.
Bram Moolenaaree8415b2018-08-10 23:13:12 +02003223 * Return FAIL and set "errormsg" or return OK.
3224 */
3225 int
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003226parse_cmd_address(exarg_T *eap, char **errormsg, int silent)
Bram Moolenaaree8415b2018-08-10 23:13:12 +02003227{
3228 int address_count = 1;
3229 linenr_T lnum;
3230
3231 // Repeat for all ',' or ';' separated addresses.
3232 for (;;)
3233 {
3234 eap->line1 = eap->line2;
Bram Moolenaarc2af0af2020-08-23 21:06:02 +02003235 eap->line2 = default_address(eap);
Bram Moolenaaree8415b2018-08-10 23:13:12 +02003236 eap->cmd = skipwhite(eap->cmd);
Bram Moolenaar50eb16c2018-09-15 15:42:40 +02003237 lnum = get_address(eap, &eap->cmd, eap->addr_type, eap->skip, silent,
Bram Moolenaaree8415b2018-08-10 23:13:12 +02003238 eap->addr_count == 0, address_count++);
3239 if (eap->cmd == NULL) // error detected
3240 return FAIL;
3241 if (lnum == MAXLNUM)
3242 {
3243 if (*eap->cmd == '%') // '%' - all lines
3244 {
3245 ++eap->cmd;
3246 switch (eap->addr_type)
3247 {
3248 case ADDR_LINES:
Bram Moolenaarb7316892019-05-01 18:08:42 +02003249 case ADDR_OTHER:
Bram Moolenaaree8415b2018-08-10 23:13:12 +02003250 eap->line1 = 1;
3251 eap->line2 = curbuf->b_ml.ml_line_count;
3252 break;
3253 case ADDR_LOADED_BUFFERS:
3254 {
3255 buf_T *buf = firstbuf;
3256
3257 while (buf->b_next != NULL
3258 && buf->b_ml.ml_mfp == NULL)
3259 buf = buf->b_next;
3260 eap->line1 = buf->b_fnum;
3261 buf = lastbuf;
3262 while (buf->b_prev != NULL
3263 && buf->b_ml.ml_mfp == NULL)
3264 buf = buf->b_prev;
3265 eap->line2 = buf->b_fnum;
3266 break;
3267 }
3268 case ADDR_BUFFERS:
3269 eap->line1 = firstbuf->b_fnum;
3270 eap->line2 = lastbuf->b_fnum;
3271 break;
3272 case ADDR_WINDOWS:
3273 case ADDR_TABS:
3274 if (IS_USER_CMDIDX(eap->cmdidx))
3275 {
3276 eap->line1 = 1;
3277 eap->line2 = eap->addr_type == ADDR_WINDOWS
3278 ? LAST_WIN_NR : LAST_TAB_NR;
3279 }
3280 else
3281 {
3282 // there is no Vim command which uses '%' and
3283 // ADDR_WINDOWS or ADDR_TABS
Bram Moolenaar108010a2021-06-27 22:03:33 +02003284 *errormsg = _(e_invalid_range);
Bram Moolenaaree8415b2018-08-10 23:13:12 +02003285 return FAIL;
3286 }
3287 break;
3288 case ADDR_TABS_RELATIVE:
Bram Moolenaar25190db2019-05-04 15:05:28 +02003289 case ADDR_UNSIGNED:
3290 case ADDR_QUICKFIX:
Bram Moolenaar108010a2021-06-27 22:03:33 +02003291 *errormsg = _(e_invalid_range);
Bram Moolenaaree8415b2018-08-10 23:13:12 +02003292 return FAIL;
3293 case ADDR_ARGUMENTS:
3294 if (ARGCOUNT == 0)
3295 eap->line1 = eap->line2 = 0;
3296 else
3297 {
3298 eap->line1 = 1;
3299 eap->line2 = ARGCOUNT;
3300 }
3301 break;
Bram Moolenaar25190db2019-05-04 15:05:28 +02003302 case ADDR_QUICKFIX_VALID:
Bram Moolenaar26f0cb12019-05-01 21:43:42 +02003303#ifdef FEAT_QUICKFIX
Bram Moolenaaree8415b2018-08-10 23:13:12 +02003304 eap->line1 = 1;
Bram Moolenaar25190db2019-05-04 15:05:28 +02003305 eap->line2 = qf_get_valid_size(eap);
Bram Moolenaaree8415b2018-08-10 23:13:12 +02003306 if (eap->line2 == 0)
3307 eap->line2 = 1;
Bram Moolenaaree8415b2018-08-10 23:13:12 +02003308#endif
Bram Moolenaar26f0cb12019-05-01 21:43:42 +02003309 break;
Bram Moolenaarb7316892019-05-01 18:08:42 +02003310 case ADDR_NONE:
3311 // Will give an error later if a range is found.
3312 break;
Bram Moolenaaree8415b2018-08-10 23:13:12 +02003313 }
3314 ++eap->addr_count;
3315 }
3316 else if (*eap->cmd == '*' && vim_strchr(p_cpo, CPO_STAR) == NULL)
3317 {
3318 pos_T *fp;
3319
3320 // '*' - visual area
3321 if (eap->addr_type != ADDR_LINES)
3322 {
Bram Moolenaar108010a2021-06-27 22:03:33 +02003323 *errormsg = _(e_invalid_range);
Bram Moolenaaree8415b2018-08-10 23:13:12 +02003324 return FAIL;
3325 }
3326
3327 ++eap->cmd;
3328 if (!eap->skip)
3329 {
3330 fp = getmark('<', FALSE);
3331 if (check_mark(fp) == FAIL)
3332 return FAIL;
3333 eap->line1 = fp->lnum;
3334 fp = getmark('>', FALSE);
3335 if (check_mark(fp) == FAIL)
3336 return FAIL;
3337 eap->line2 = fp->lnum;
3338 ++eap->addr_count;
3339 }
3340 }
3341 }
3342 else
3343 eap->line2 = lnum;
3344 eap->addr_count++;
3345
3346 if (*eap->cmd == ';')
3347 {
3348 if (!eap->skip)
3349 {
3350 curwin->w_cursor.lnum = eap->line2;
Bram Moolenaar0e717042020-04-27 19:29:01 +02003351 // Don't leave the cursor on an illegal line or column, but do
3352 // accept zero as address, so 0;/PATTERN/ works correctly.
3353 if (eap->line2 > 0)
3354 check_cursor();
Bram Moolenaaree8415b2018-08-10 23:13:12 +02003355 }
3356 }
3357 else if (*eap->cmd != ',')
3358 break;
3359 ++eap->cmd;
3360 }
3361
3362 // One address given: set start and end lines.
3363 if (eap->addr_count == 1)
3364 {
3365 eap->line1 = eap->line2;
3366 // ... but only implicit: really no address given
3367 if (lnum == MAXLNUM)
3368 eap->addr_count = 0;
3369 }
3370 return OK;
3371}
3372
3373/*
Bram Moolenaara6f4d612011-09-21 19:10:46 +02003374 * Append "cmd" to the error message in IObuff.
3375 * Takes care of limiting the length and handling 0xa0, which would be
3376 * invisible otherwise.
3377 */
3378 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01003379append_command(char_u *cmd)
Bram Moolenaara6f4d612011-09-21 19:10:46 +02003380{
3381 char_u *s = cmd;
3382 char_u *d;
3383
3384 STRCAT(IObuff, ": ");
3385 d = IObuff + STRLEN(IObuff);
3386 while (*s != NUL && d - IObuff < IOSIZE - 7)
3387 {
Bram Moolenaar13505972019-01-24 15:04:48 +01003388 if (enc_utf8 ? (s[0] == 0xc2 && s[1] == 0xa0) : *s == 0xa0)
Bram Moolenaara6f4d612011-09-21 19:10:46 +02003389 {
Bram Moolenaar13505972019-01-24 15:04:48 +01003390 s += enc_utf8 ? 2 : 1;
Bram Moolenaara6f4d612011-09-21 19:10:46 +02003391 STRCPY(d, "<a0>");
3392 d += 4;
3393 }
3394 else
3395 MB_COPY_CHAR(s, d);
3396 }
3397 *d = NUL;
3398}
3399
Dominique Pelle748b3082022-01-08 12:41:16 +00003400#if defined(FEAT_EVAL) || defined(PROTO)
Bram Moolenaara6f4d612011-09-21 19:10:46 +02003401/*
Bram Moolenaar2e800952020-08-23 19:34:48 +02003402 * If "start" points "&opt", "&l:opt", "&g:opt" or "$ENV" return a pointer to
3403 * the name. Otherwise just return "start".
3404 */
3405 char_u *
3406skip_option_env_lead(char_u *start)
3407{
3408 char_u *name = start;
3409
3410 if (*start == '&')
3411 {
3412 if ((start[1] == 'l' || start[1] == 'g') && start[2] == ':')
3413 name += 3;
3414 else
3415 name += 1;
3416 }
3417 else if (*start == '$')
3418 name += 1;
3419 return name;
3420}
Dominique Pelle748b3082022-01-08 12:41:16 +00003421#endif
Bram Moolenaar2e800952020-08-23 19:34:48 +02003422
3423/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00003424 * Find an Ex command by its name, either built-in or user.
Bram Moolenaar52b4b552005-03-07 23:00:57 +00003425 * Start of the name can be found at eap->cmd.
Bram Moolenaar25190db2019-05-04 15:05:28 +02003426 * Sets eap->cmdidx and returns a pointer to char after the command name.
Bram Moolenaar52b4b552005-03-07 23:00:57 +00003427 * "full" is set to TRUE if the whole command name matched.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003428 *
3429 * If "lookup" is not NULL recognize expression without "eval" or "call" and
3430 * assignment without "let". Sets eap->cmdidx to the command while returning
3431 * "eap->cmd".
3432 *
Bram Moolenaar071d4272004-06-13 20:20:40 +00003433 * Returns NULL for an ambiguous user command.
3434 */
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003435 char_u *
3436find_ex_command(
3437 exarg_T *eap,
Bram Moolenaara494f562020-04-18 17:45:38 +02003438 int *full UNUSED,
Bram Moolenaar77b10ff2021-03-14 13:21:35 +01003439 int (*lookup)(char_u *, size_t, int cmd, cctx_T *) UNUSED,
Bram Moolenaara494f562020-04-18 17:45:38 +02003440 cctx_T *cctx UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003441{
3442 int len;
3443 char_u *p;
Bram Moolenaardf177f62005-02-22 08:39:57 +00003444 int i;
Bram Moolenaar7d840e92021-05-26 21:10:11 +02003445#ifndef FEAT_EVAL
3446 int vim9 = FALSE;
3447#else
3448 int vim9 = in_vim9script();
Bram Moolenaar071d4272004-06-13 20:20:40 +00003449
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003450 /*
3451 * Recognize a Vim9 script function/method call and assignment:
3452 * "lvar = value", "lvar(arg)", "[1, 2 3]->Func()"
3453 */
Bram Moolenaar0c6ceaf2020-02-22 18:36:32 +01003454 p = eap->cmd;
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02003455 if (lookup != NULL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003456 {
Bram Moolenaar2e800952020-08-23 19:34:48 +02003457 char_u *pskip = skip_option_env_lead(eap->cmd);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003458
Bram Moolenaar5ca5cc62021-08-24 21:56:03 +02003459 if (vim_strchr((char_u *)"{('[\"@&$", *p) != NULL
Bram Moolenaarc1e6c7b2022-02-20 18:26:46 +00003460 || ((p = to_name_const_end(pskip)) > eap->cmd && *p != NUL)
3461 || (p[0] == '0' && p[1] == 'z'))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003462 {
Bram Moolenaar7cebe8b2021-01-23 14:22:16 +01003463 int oplen;
3464 int heredoc;
Bram Moolenaarbf5f2872021-08-21 20:50:35 +02003465 char_u *swp;
3466
Bram Moolenaar5ca5cc62021-08-24 21:56:03 +02003467 if (*eap->cmd == '&'
3468 || *eap->cmd == '$'
3469 || (eap->cmd[0] == '@'
Bram Moolenaar73170912021-08-22 22:44:11 +02003470 && (valid_yank_reg(eap->cmd[1], FALSE)
3471 || eap->cmd[1] == '@')))
Bram Moolenaarbf5f2872021-08-21 20:50:35 +02003472 {
Bram Moolenaar73170912021-08-22 22:44:11 +02003473 if (*eap->cmd == '&')
3474 {
3475 p = eap->cmd + 1;
3476 if (STRNCMP("l:", p, 2) == 0 || STRNCMP("g:", p, 2) == 0)
3477 p += 2;
3478 p = to_name_end(p, FALSE);
3479 }
Bram Moolenaar5ca5cc62021-08-24 21:56:03 +02003480 else if (*eap->cmd == '$')
3481 p = to_name_end(eap->cmd + 1, FALSE);
Bram Moolenaar73170912021-08-22 22:44:11 +02003482 else
3483 p = eap->cmd + 2;
Bram Moolenaarbf5f2872021-08-21 20:50:35 +02003484 if (ends_excmd(*skipwhite(p)))
3485 {
Bram Moolenaar5ca5cc62021-08-24 21:56:03 +02003486 // "&option <NL>", "$ENV <NL>" and "@r <NL>" are the start
3487 // of an expression.
Bram Moolenaarbf5f2872021-08-21 20:50:35 +02003488 eap->cmdidx = CMD_eval;
3489 return eap->cmd;
3490 }
3491 // "&option" can be followed by "->" or "=", check below
3492 }
3493
3494 swp = skipwhite(p);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003495
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02003496 if (
3497 // "(..." is an expression.
3498 // "funcname(" is always a function call.
3499 *p == '('
3500 || (p == eap->cmd
3501 ? (
Bram Moolenaar9becdf22020-10-10 21:33:48 +02003502 // "{..." is a dict expression or block start.
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02003503 *eap->cmd == '{'
3504 // "'string'->func()" is an expression.
3505 || *eap->cmd == '\''
Bram Moolenaar10409562020-07-29 20:00:38 +02003506 // '"string"->func()' is an expression.
Bram Moolenaarc1e6c7b2022-02-20 18:26:46 +00003507 || (eap->cmd[0] == '0' && eap->cmd[1] == 'z')
3508 // '"string"->func()' is an expression.
Bram Moolenaar10409562020-07-29 20:00:38 +02003509 || *eap->cmd == '"'
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02003510 // "g:varname" is an expression.
3511 || eap->cmd[1] == ':'
3512 )
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02003513 // "varname->func()" is an expression.
Bram Moolenaar7cebe8b2021-01-23 14:22:16 +01003514 : (*swp == '-' && swp[1] == '>')))
Bram Moolenaarb31be3f2020-07-20 22:37:44 +02003515 {
Bram Moolenaar9becdf22020-10-10 21:33:48 +02003516 if (*eap->cmd == '{' && ends_excmd(*skipwhite(eap->cmd + 1)))
3517 {
3518 // "{" by itself is the start of a block.
3519 eap->cmdidx = CMD_block;
3520 return eap->cmd + 1;
3521 }
Bram Moolenaarb31be3f2020-07-20 22:37:44 +02003522 eap->cmdidx = CMD_eval;
3523 return eap->cmd;
3524 }
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02003525
Bram Moolenaar2e17fef2022-03-18 19:44:48 +00003526 if ((p != eap->cmd && (
Bram Moolenaar2b22b112020-09-14 18:35:18 +02003527 // "varname[]" is an expression.
3528 *p == '['
3529 // "varname.key" is an expression.
Bram Moolenaar2e17fef2022-03-18 19:44:48 +00003530 || (*p == '.'
3531 && (ASCII_ISALPHA(p[1]) || p[1] == '_'))))
3532 // g:[key] is an expression
3533 || STRNCMP(eap->cmd, "g:[", 3) == 0)
Bram Moolenaar2b22b112020-09-14 18:35:18 +02003534 {
Bram Moolenaar68452172021-04-12 21:21:02 +02003535 char_u *after = eap->cmd;
Bram Moolenaar2b22b112020-09-14 18:35:18 +02003536
3537 // When followed by "=" or "+=" then it is an assignment.
Bram Moolenaar68452172021-04-12 21:21:02 +02003538 // Skip over the whole thing, it can be:
3539 // name.member = val
3540 // name[a : b] = val
3541 // name[idx] = val
3542 // name[idx].member = val
3543 // etc.
3544 eap->cmdidx = CMD_eval;
Bram Moolenaar2b22b112020-09-14 18:35:18 +02003545 ++emsg_silent;
Bram Moolenaarce2c5442020-11-28 21:21:17 +01003546 if (skip_expr(&after, NULL) == OK)
Bram Moolenaar68452172021-04-12 21:21:02 +02003547 {
Bram Moolenaarce2c5442020-11-28 21:21:17 +01003548 after = skipwhite(after);
Bram Moolenaar68452172021-04-12 21:21:02 +02003549 if (*after == '=' || (*after != NUL && after[1] == '=')
Bram Moolenaarce2c5442020-11-28 21:21:17 +01003550 || (after[0] == '.' && after[1] == '.'
3551 && after[2] == '='))
Bram Moolenaar68452172021-04-12 21:21:02 +02003552 eap->cmdidx = CMD_var;
3553 }
Bram Moolenaar2b22b112020-09-14 18:35:18 +02003554 --emsg_silent;
3555 return eap->cmd;
3556 }
3557
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02003558 // "[...]->Method()" is a list expression, but "[a, b] = Func()" is
3559 // an assignment.
3560 // If there is no line break inside the "[...]" then "p" is
3561 // advanced to after the "]" by to_name_const_end(): check if a "="
3562 // follows.
3563 // If "[...]" has a line break "p" still points at the "[" and it
3564 // can't be an assignment.
3565 if (*eap->cmd == '[')
Bram Moolenaarb31be3f2020-07-20 22:37:44 +02003566 {
Bram Moolenaar035bd1c2021-06-21 19:44:11 +02003567 char_u *eq;
3568
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02003569 p = to_name_const_end(eap->cmd);
Bram Moolenaarda7c20c2020-11-30 21:12:19 +01003570 if (p == eap->cmd && *p == '[')
3571 {
3572 int count = 0;
3573 int semicolon = FALSE;
3574
3575 p = skip_var_list(eap->cmd, TRUE, &count, &semicolon, TRUE);
3576 }
Bram Moolenaar035bd1c2021-06-21 19:44:11 +02003577 eq = p;
3578 if (eq != NULL)
3579 {
3580 eq = skipwhite(eq);
3581 if (vim_strchr((char_u *)"+-*/%", *eq) != NULL)
3582 ++eq;
3583 }
3584 if (p == NULL || p == eap->cmd || *eq != '=')
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02003585 {
3586 eap->cmdidx = CMD_eval;
3587 return eap->cmd;
3588 }
Bram Moolenaar035bd1c2021-06-21 19:44:11 +02003589 if (p > eap->cmd && *eq == '=')
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02003590 {
Bram Moolenaar30fd8202020-09-26 15:09:30 +02003591 eap->cmdidx = CMD_var;
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02003592 return eap->cmd;
3593 }
3594 }
3595
3596 // Recognize an assignment if we recognize the variable name:
3597 // "g:var = expr"
Bram Moolenaarbf5f2872021-08-21 20:50:35 +02003598 // "@r = expr"
3599 // "&opt = expr"
Bram Moolenaaraa1959b2021-04-15 22:13:39 +02003600 // "var = expr" where "var" is a variable name or we are skipping
3601 // (variable declaration might have been skipped).
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02003602 oplen = assignment_len(skipwhite(p), &heredoc);
3603 if (oplen > 0)
3604 {
3605 if (((p - eap->cmd) > 2 && eap->cmd[1] == ':')
3606 || *eap->cmd == '&'
3607 || *eap->cmd == '$'
3608 || *eap->cmd == '@'
Bram Moolenaaraa1959b2021-04-15 22:13:39 +02003609 || eap->skip
Bram Moolenaar77b10ff2021-03-14 13:21:35 +01003610 || lookup(eap->cmd, p - eap->cmd, TRUE, cctx) == OK)
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02003611 {
Bram Moolenaar30fd8202020-09-26 15:09:30 +02003612 eap->cmdidx = CMD_var;
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02003613 return eap->cmd;
3614 }
3615 }
3616
3617 // Recognize using a type for a w:, b:, t: or g: variable:
3618 // "w:varname: number = 123".
3619 if (eap->cmd[1] == ':' && *p == ':')
3620 {
3621 eap->cmdidx = CMD_eval;
Bram Moolenaarb31be3f2020-07-20 22:37:44 +02003622 return eap->cmd;
3623 }
Bram Moolenaard2ef6b32020-07-02 21:11:34 +02003624 }
Bram Moolenaar148be9b2021-02-02 21:33:52 +01003625
Bram Moolenaar7b829262021-10-13 15:04:34 +01003626 // "g:", "s:" and "l:" are always assumed to be a variable, thus start
3627 // an expression. A global/substitute/list command needs to use a
3628 // longer name.
3629 if (vim_strchr((char_u *)"gsl", *p) != NULL && p[1] == ':')
3630 {
3631 eap->cmdidx = CMD_eval;
3632 return eap->cmd;
3633 }
3634
Bram Moolenaar148be9b2021-02-02 21:33:52 +01003635 // If it is an ID it might be a variable with an operator on the next
3636 // line, if the variable exists it can't be an Ex command.
3637 if (p > eap->cmd && ends_excmd(*skipwhite(p))
Bram Moolenaar77b10ff2021-03-14 13:21:35 +01003638 && (lookup(eap->cmd, p - eap->cmd, TRUE, cctx) == OK
Bram Moolenaar148be9b2021-02-02 21:33:52 +01003639 || (ASCII_ISALPHA(eap->cmd[0]) && eap->cmd[1] == ':')))
3640 {
3641 eap->cmdidx = CMD_eval;
3642 return eap->cmd;
3643 }
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02003644
3645 // Check for "++nr" and "--nr".
Bram Moolenaard3a11782022-01-05 16:50:40 +00003646 if (p == eap->cmd && p[0] != NUL && p[0] == p[1]
3647 && (*p == '+' || *p == '-'))
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02003648 {
3649 eap->cmdidx = *p == '+' ? CMD_increment : CMD_decrement;
3650 return eap->cmd + 2;
3651 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003652 }
3653#endif
3654
Bram Moolenaar071d4272004-06-13 20:20:40 +00003655 /*
3656 * Isolate the command and search for it in the command table.
Bram Moolenaar81870892007-11-11 18:17:28 +00003657 * Exceptions:
Bram Moolenaar10b94212021-02-19 21:42:57 +01003658 * - The 'k' command can directly be followed by any character.
3659 * But it is not used in Vim9 script.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003660 * - the 's' command can be followed directly by 'c', 'g', 'i', 'I' or 'r'
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01003661 * but :sre[wind] is another command, as are :scr[iptnames],
Bram Moolenaar071d4272004-06-13 20:20:40 +00003662 * :scs[cope], :sim[alt], :sig[ns] and :sil[ent].
Bram Moolenaardf177f62005-02-22 08:39:57 +00003663 * - the "d" command can directly be followed by 'l' or 'p' flag.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003664 */
3665 p = eap->cmd;
Bram Moolenaar7d840e92021-05-26 21:10:11 +02003666 if (!vim9 && *p == 'k')
Bram Moolenaar071d4272004-06-13 20:20:40 +00003667 {
3668 eap->cmdidx = CMD_k;
3669 ++p;
3670 }
Bram Moolenaar7d840e92021-05-26 21:10:11 +02003671 else if (!vim9
3672 && p[0] == 's'
Bram Moolenaar204b93f2015-08-04 22:02:51 +02003673 && ((p[1] == 'c' && (p[2] == NUL || (p[2] != 's' && p[2] != 'r'
3674 && (p[3] == NUL || (p[3] != 'i' && p[4] != 'p')))))
Bram Moolenaar071d4272004-06-13 20:20:40 +00003675 || p[1] == 'g'
3676 || (p[1] == 'i' && p[2] != 'm' && p[2] != 'l' && p[2] != 'g')
3677 || p[1] == 'I'
3678 || (p[1] == 'r' && p[2] != 'e')))
3679 {
3680 eap->cmdidx = CMD_substitute;
3681 ++p;
3682 }
3683 else
3684 {
3685 while (ASCII_ISALPHA(*p))
3686 ++p;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003687 // for python 3.x support ":py3", ":python3", ":py3file", etc.
Bram Moolenaar55d5c032010-07-17 23:52:29 +02003688 if (eap->cmd[0] == 'p' && eap->cmd[1] == 'y')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003689 {
Bram Moolenaarb6590522010-07-21 16:00:43 +02003690 while (ASCII_ISALNUM(*p))
3691 ++p;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003692 }
3693 else if (*p == '9' && STRNCMP("vim9", eap->cmd, 4) == 0)
3694 {
Bram Moolenaardf749a22021-03-28 15:29:43 +02003695 // include "9" for "vim9*" commands; "vim9cmd" and "vim9script".
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003696 ++p;
3697 while (ASCII_ISALPHA(*p))
3698 ++p;
3699 }
Bram Moolenaarbd5e15f2010-07-17 21:19:38 +02003700
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003701 // check for non-alpha command
Bram Moolenaar9becdf22020-10-10 21:33:48 +02003702 if (p == eap->cmd && vim_strchr((char_u *)"@*!=><&~#}", *p) != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003703 ++p;
3704 len = (int)(p - eap->cmd);
Bram Moolenaar7d840e92021-05-26 21:10:11 +02003705 if (!vim9 && *eap->cmd == 'd' && (p[-1] == 'l' || p[-1] == 'p'))
Bram Moolenaardf177f62005-02-22 08:39:57 +00003706 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003707 // Check for ":dl", ":dell", etc. to ":deletel": that's
3708 // :delete with the 'l' flag. Same for 'p'.
Bram Moolenaardf177f62005-02-22 08:39:57 +00003709 for (i = 0; i < len; ++i)
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00003710 if (eap->cmd[i] != ((char_u *)"delete")[i])
Bram Moolenaardf177f62005-02-22 08:39:57 +00003711 break;
3712 if (i == len - 1)
3713 {
3714 --len;
3715 if (p[-1] == 'l')
3716 eap->flags |= EXFLAG_LIST;
3717 else
3718 eap->flags |= EXFLAG_PRINT;
3719 }
3720 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003721
Bram Moolenaare5e0fbc2017-03-25 14:51:01 +01003722 if (ASCII_ISLOWER(eap->cmd[0]))
3723 {
Bram Moolenaar6c0c1e82017-03-25 15:07:43 +01003724 int c1 = eap->cmd[0];
Bram Moolenaar94f82cb2019-07-24 22:30:27 +02003725 int c2 = len == 1 ? NUL : eap->cmd[1];
Bram Moolenaar6c0c1e82017-03-25 15:07:43 +01003726
Bram Moolenaare5e0fbc2017-03-25 14:51:01 +01003727 if (command_count != (int)CMD_SIZE)
3728 {
Bram Moolenaard82a47d2022-01-05 20:24:39 +00003729 iemsg(_(e_command_table_needs_to_be_updated_run_make_cmdidxs));
Bram Moolenaare5e0fbc2017-03-25 14:51:01 +01003730 getout(1);
3731 }
3732
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003733 // Use a precomputed index for fast look-up in cmdnames[]
3734 // taking into account the first 2 letters of eap->cmd.
Bram Moolenaare5e0fbc2017-03-25 14:51:01 +01003735 eap->cmdidx = cmdidxs1[CharOrdLow(c1)];
3736 if (ASCII_ISLOWER(c2))
3737 eap->cmdidx += cmdidxs2[CharOrdLow(c1)][CharOrdLow(c2)];
3738 }
Bram Moolenaara494f562020-04-18 17:45:38 +02003739 else if (ASCII_ISUPPER(eap->cmd[0]))
3740 eap->cmdidx = CMD_Next;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003741 else
Bram Moolenaare5e0fbc2017-03-25 14:51:01 +01003742 eap->cmdidx = CMD_bang;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003743
3744 for ( ; (int)eap->cmdidx < (int)CMD_SIZE;
3745 eap->cmdidx = (cmdidx_T)((int)eap->cmdidx + 1))
3746 if (STRNCMP(cmdnames[(int)eap->cmdidx].cmd_name, (char *)eap->cmd,
3747 (size_t)len) == 0)
3748 {
3749#ifdef FEAT_EVAL
Bram Moolenaar204852a2022-03-05 12:56:44 +00003750 if (full != NULL && cmdnames[eap->cmdidx].cmd_name[len] == NUL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003751 *full = TRUE;
3752#endif
3753 break;
3754 }
3755
Bram Moolenaar204852a2022-03-05 12:56:44 +00003756 // :Print and :mode are not supported in Vim9 script.
3757 // Some commands cannot be shortened in Vim9 script.
Bram Moolenaar204852a2022-03-05 12:56:44 +00003758 if (vim9 && eap->cmdidx != CMD_SIZE)
3759 {
3760 if (eap->cmdidx == CMD_mode || eap->cmdidx == CMD_Print)
3761 eap->cmdidx = CMD_SIZE;
Bram Moolenaarb2175222022-03-05 20:24:41 +00003762 else if ((cmdnames[eap->cmdidx].cmd_argt & EX_WHOLE)
Bram Moolenaar204852a2022-03-05 12:56:44 +00003763 && len < (int)STRLEN(cmdnames[eap->cmdidx].cmd_name))
Bram Moolenaar204852a2022-03-05 12:56:44 +00003764 {
Bram Moolenaarb2175222022-03-05 20:24:41 +00003765 semsg(_(e_command_cannot_be_shortened_str), eap->cmd);
Bram Moolenaar204852a2022-03-05 12:56:44 +00003766 eap->cmdidx = CMD_SIZE;
3767 }
3768 }
Bram Moolenaar6aca4d32022-03-04 17:10:19 +00003769
Dominique Pelleaf4a61a2021-12-27 17:21:41 +00003770 // Do not recognize ":*" as the star command unless '*' is in
Bram Moolenaar95388e32020-11-20 21:07:00 +01003771 // 'cpoptions'.
3772 if (eap->cmdidx == CMD_star && vim_strchr(p_cpo, CPO_STAR) == NULL)
3773 p = eap->cmd;
3774
Bram Moolenaarac9fb182019-04-27 13:04:13 +02003775 // Look for a user defined command as a last resort. Let ":Print" be
3776 // overruled by a user defined command.
Bram Moolenaara3e7b1f2010-11-10 19:00:01 +01003777 if ((eap->cmdidx == CMD_SIZE || eap->cmdidx == CMD_Print)
3778 && *eap->cmd >= 'A' && *eap->cmd <= 'Z')
Bram Moolenaar071d4272004-06-13 20:20:40 +00003779 {
Bram Moolenaarac9fb182019-04-27 13:04:13 +02003780 // User defined commands may contain digits.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003781 while (ASCII_ISALNUM(*p))
3782 ++p;
Bram Moolenaar52b4b552005-03-07 23:00:57 +00003783 p = find_ucmd(eap, p, full, NULL, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003784 }
Bram Moolenaar1c0aa972020-12-16 21:43:54 +01003785 if (p == NULL || p == eap->cmd)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003786 eap->cmdidx = CMD_SIZE;
3787 }
3788
Bram Moolenaar204852a2022-03-05 12:56:44 +00003789 // ":fina" means ":finally" in legacy script, for backwards compatibility.
3790 if (eap->cmdidx == CMD_final && p - eap->cmd == 4 && !vim9)
Bram Moolenaar373863e2020-09-26 17:20:53 +02003791 eap->cmdidx = CMD_finally;
3792
Bram Moolenaar2a3cd3a2020-12-13 19:22:27 +01003793#ifdef FEAT_EVAL
Bram Moolenaard1510ee2021-01-04 16:15:58 +01003794 if (eap->cmdidx < CMD_SIZE
Bram Moolenaar7d840e92021-05-26 21:10:11 +02003795 && vim9
Bram Moolenaar9fa5dab2021-07-20 19:18:44 +02003796 && !IS_WHITE_OR_NUL(*p) && *p != '\n' && *p != '!' && *p != '|'
Bram Moolenaard1510ee2021-01-04 16:15:58 +01003797 && (eap->cmdidx < 0 ||
3798 (cmdnames[eap->cmdidx].cmd_argt & EX_NONWHITE_OK) == 0))
Bram Moolenaarb5b94802020-12-13 17:50:20 +01003799 {
Bram Moolenaarb98cec22021-04-25 16:35:55 +02003800 char_u *cmd = vim_strnsave(eap->cmd, p - eap->cmd);
3801
3802 semsg(_(e_command_str_not_followed_by_white_space_str), cmd, eap->cmd);
Bram Moolenaarb5b94802020-12-13 17:50:20 +01003803 eap->cmdidx = CMD_SIZE;
Bram Moolenaarb98cec22021-04-25 16:35:55 +02003804 vim_free(cmd);
Bram Moolenaarb5b94802020-12-13 17:50:20 +01003805 }
Bram Moolenaar2a3cd3a2020-12-13 19:22:27 +01003806#endif
Bram Moolenaarb5b94802020-12-13 17:50:20 +01003807
Bram Moolenaar071d4272004-06-13 20:20:40 +00003808 return p;
3809}
3810
3811#if defined(FEAT_EVAL) || defined(PROTO)
Bram Moolenaared53fb92007-11-24 20:50:24 +00003812static struct cmdmod
3813{
3814 char *name;
3815 int minlen;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003816 int has_count; // :123verbose :3tab
Bram Moolenaared53fb92007-11-24 20:50:24 +00003817} cmdmods[] = {
3818 {"aboveleft", 3, FALSE},
3819 {"belowright", 3, FALSE},
3820 {"botright", 2, FALSE},
3821 {"browse", 3, FALSE},
3822 {"confirm", 4, FALSE},
Bram Moolenaar7b668e82016-08-23 23:51:21 +02003823 {"filter", 4, FALSE},
Bram Moolenaared53fb92007-11-24 20:50:24 +00003824 {"hide", 3, FALSE},
3825 {"keepalt", 5, FALSE},
3826 {"keepjumps", 5, FALSE},
3827 {"keepmarks", 3, FALSE},
Bram Moolenaara939e432013-11-09 05:30:26 +01003828 {"keeppatterns", 5, FALSE},
Bram Moolenaared53fb92007-11-24 20:50:24 +00003829 {"leftabove", 5, FALSE},
3830 {"lockmarks", 3, FALSE},
Bram Moolenaarca9f9582008-09-18 10:44:28 +00003831 {"noautocmd", 3, FALSE},
Bram Moolenaar5803ae62014-03-23 16:04:02 +01003832 {"noswapfile", 3, FALSE},
Bram Moolenaared53fb92007-11-24 20:50:24 +00003833 {"rightbelow", 6, FALSE},
3834 {"sandbox", 3, FALSE},
3835 {"silent", 3, FALSE},
3836 {"tab", 3, TRUE},
3837 {"topleft", 2, FALSE},
Bram Moolenaar8e258a42009-07-09 13:55:43 +00003838 {"unsilent", 3, FALSE},
Bram Moolenaared53fb92007-11-24 20:50:24 +00003839 {"verbose", 4, TRUE},
3840 {"vertical", 4, FALSE},
3841};
3842
3843/*
3844 * Return length of a command modifier (including optional count).
3845 * Return zero when it's not a modifier.
3846 */
3847 int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01003848modifier_len(char_u *cmd)
Bram Moolenaared53fb92007-11-24 20:50:24 +00003849{
3850 int i, j;
3851 char_u *p = cmd;
3852
3853 if (VIM_ISDIGIT(*cmd))
Dominique Pelle4781d6f2021-05-18 21:46:31 +02003854 p = skipwhite(skipdigits(cmd + 1));
K.Takataeeec2542021-06-02 13:28:16 +02003855 for (i = 0; i < (int)ARRAY_LENGTH(cmdmods); ++i)
Bram Moolenaared53fb92007-11-24 20:50:24 +00003856 {
3857 for (j = 0; p[j] != NUL; ++j)
3858 if (p[j] != cmdmods[i].name[j])
3859 break;
Bram Moolenaar2d473ab2013-06-12 17:12:24 +02003860 if (!ASCII_ISALPHA(p[j]) && j >= cmdmods[i].minlen
Bram Moolenaared53fb92007-11-24 20:50:24 +00003861 && (p == cmd || cmdmods[i].has_count))
Bram Moolenaarcb4cef22008-03-16 15:04:34 +00003862 return j + (int)(p - cmd);
Bram Moolenaared53fb92007-11-24 20:50:24 +00003863 }
3864 return 0;
3865}
3866
Bram Moolenaar071d4272004-06-13 20:20:40 +00003867/*
3868 * Return > 0 if an Ex command "name" exists.
3869 * Return 2 if there is an exact match.
3870 * Return 3 if there is an ambiguous match.
3871 */
3872 int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01003873cmd_exists(char_u *name)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003874{
3875 exarg_T ea;
3876 int full = FALSE;
3877 int i;
3878 int j;
Bram Moolenaarf3a67882006-05-05 21:09:41 +00003879 char_u *p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003880
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003881 // Check command modifiers.
K.Takataeeec2542021-06-02 13:28:16 +02003882 for (i = 0; i < (int)ARRAY_LENGTH(cmdmods); ++i)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003883 {
3884 for (j = 0; name[j] != NUL; ++j)
3885 if (name[j] != cmdmods[i].name[j])
3886 break;
3887 if (name[j] == NUL && j >= cmdmods[i].minlen)
3888 return (cmdmods[i].name[j] == NUL ? 2 : 1);
3889 }
3890
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003891 // Check built-in commands and user defined commands.
3892 // For ":2match" and ":3match" we need to skip the number.
Bram Moolenaara9587612006-05-04 21:47:50 +00003893 ea.cmd = (*name == '2' || *name == '3') ? name + 1 : name;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003894 ea.cmdidx = (cmdidx_T)0;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003895 p = find_ex_command(&ea, &full, NULL, NULL);
Bram Moolenaarf3a67882006-05-05 21:09:41 +00003896 if (p == NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003897 return 3;
Bram Moolenaara9587612006-05-04 21:47:50 +00003898 if (vim_isdigit(*name) && ea.cmdidx != CMD_match)
3899 return 0;
Bram Moolenaarf3a67882006-05-05 21:09:41 +00003900 if (*skipwhite(p) != NUL)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003901 return 0; // trailing garbage
Bram Moolenaar071d4272004-06-13 20:20:40 +00003902 return (ea.cmdidx == CMD_SIZE ? 0 : (full ? 2 : 1));
3903}
Bram Moolenaar038e09e2021-02-06 12:38:51 +01003904
3905/*
3906 * "fullcommand" function
3907 */
3908 void
3909f_fullcommand(typval_T *argvars, typval_T *rettv)
3910{
3911 exarg_T ea;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02003912 char_u *name;
Bram Moolenaar038e09e2021-02-06 12:38:51 +01003913 char_u *p;
3914
Bram Moolenaar4c8e8c62021-05-26 19:49:09 +02003915 rettv->v_type = VAR_STRING;
3916 rettv->vval.v_string = NULL;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02003917
3918 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
3919 return;
3920
3921 name = argvars[0].vval.v_string;
Bram Moolenaar4c8e8c62021-05-26 19:49:09 +02003922 if (name == NULL)
3923 return;
3924
zeertzjqc024ed92022-01-04 16:22:52 +00003925 while (*name == ':')
Bram Moolenaar038e09e2021-02-06 12:38:51 +01003926 name++;
3927 name = skip_range(name, TRUE, NULL);
3928
Bram Moolenaar038e09e2021-02-06 12:38:51 +01003929 ea.cmd = (*name == '2' || *name == '3') ? name + 1 : name;
3930 ea.cmdidx = (cmdidx_T)0;
Bram Moolenaar7d840e92021-05-26 21:10:11 +02003931 ea.addr_count = 0;
Bram Moolenaar038e09e2021-02-06 12:38:51 +01003932 p = find_ex_command(&ea, NULL, NULL, NULL);
3933 if (p == NULL || ea.cmdidx == CMD_SIZE)
3934 return;
Bram Moolenaar7d840e92021-05-26 21:10:11 +02003935 if (in_vim9script())
3936 {
3937 int res;
3938
3939 ++emsg_silent;
3940 res = not_in_vim9(&ea);
3941 --emsg_silent;
3942
3943 if (res == FAIL)
3944 return;
3945 }
Bram Moolenaar038e09e2021-02-06 12:38:51 +01003946
3947 rettv->vval.v_string = vim_strsave(IS_USER_CMDIDX(ea.cmdidx)
Bram Moolenaar80c88ea2021-09-08 14:29:46 +02003948 ? get_user_command_name(ea.useridx, ea.cmdidx)
3949 : cmdnames[ea.cmdidx].cmd_name);
Bram Moolenaar038e09e2021-02-06 12:38:51 +01003950}
Bram Moolenaar071d4272004-06-13 20:20:40 +00003951#endif
3952
Bram Moolenaard0190392019-08-23 21:17:35 +02003953 cmdidx_T
3954excmd_get_cmdidx(char_u *cmd, int len)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003955{
Bram Moolenaard0190392019-08-23 21:17:35 +02003956 cmdidx_T idx;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003957
Bram Moolenaard0190392019-08-23 21:17:35 +02003958 for (idx = (cmdidx_T)0; (int)idx < (int)CMD_SIZE;
3959 idx = (cmdidx_T)((int)idx + 1))
3960 if (STRNCMP(cmdnames[(int)idx].cmd_name, cmd, (size_t)len) == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003961 break;
3962
Bram Moolenaard0190392019-08-23 21:17:35 +02003963 return idx;
3964}
Bram Moolenaar071d4272004-06-13 20:20:40 +00003965
Bram Moolenaard0190392019-08-23 21:17:35 +02003966 long
3967excmd_get_argt(cmdidx_T idx)
3968{
3969 return (long)cmdnames[(int)idx].cmd_argt;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003970}
3971
3972/*
Bram Moolenaaree8415b2018-08-10 23:13:12 +02003973 * Skip a range specifier of the form: addr [,addr] [;addr] ..
Bram Moolenaar071d4272004-06-13 20:20:40 +00003974 *
3975 * Backslashed delimiters after / or ? will be skipped, and commands will
3976 * not be expanded between /'s and ?'s or after "'".
3977 *
Bram Moolenaardf069ee2020-06-22 23:02:51 +02003978 * Also skip white space and ":" characters after the range.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003979 * Returns the "cmd" pointer advanced to beyond the range.
3980 */
3981 char_u *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01003982skip_range(
Bram Moolenaaraf377e32021-11-29 12:12:43 +00003983 char_u *cmd_start,
Bram Moolenaar3bd8de42020-09-14 16:37:34 +02003984 int skip_star, // skip "*" used for Visual range
3985 int *ctx) // pointer to xp_context or NULL
Bram Moolenaar071d4272004-06-13 20:20:40 +00003986{
Bram Moolenaaraf377e32021-11-29 12:12:43 +00003987 char_u *cmd = cmd_start;
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00003988 unsigned delim;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003989
Bram Moolenaarcbf20fb2017-02-03 21:19:04 +01003990 while (vim_strchr((char_u *)" \t0123456789.$%'/?-+,;\\", *cmd) != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003991 {
Bram Moolenaarcbf20fb2017-02-03 21:19:04 +01003992 if (*cmd == '\\')
3993 {
3994 if (cmd[1] == '?' || cmd[1] == '/' || cmd[1] == '&')
3995 ++cmd;
3996 else
3997 break;
3998 }
3999 else if (*cmd == '\'')
Bram Moolenaar071d4272004-06-13 20:20:40 +00004000 {
Bram Moolenaaraf377e32021-11-29 12:12:43 +00004001 char_u *p = cmd;
4002
4003 // a quote is only valid at the start or after a separator
4004 while (p > cmd_start)
4005 {
4006 --p;
4007 if (!VIM_ISWHITE(*p))
4008 break;
4009 }
4010 if (cmd > cmd_start && !VIM_ISWHITE(*p) && *p != ',' && *p != ';')
4011 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004012 if (*++cmd == NUL && ctx != NULL)
4013 *ctx = EXPAND_NOTHING;
4014 }
4015 else if (*cmd == '/' || *cmd == '?')
4016 {
4017 delim = *cmd++;
4018 while (*cmd != NUL && *cmd != delim)
4019 if (*cmd++ == '\\' && *cmd != NUL)
4020 ++cmd;
4021 if (*cmd == NUL && ctx != NULL)
4022 *ctx = EXPAND_NOTHING;
4023 }
4024 if (*cmd != NUL)
4025 ++cmd;
4026 }
Bram Moolenaardf177f62005-02-22 08:39:57 +00004027
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004028 // Skip ":" and white space.
Bram Moolenaardf177f62005-02-22 08:39:57 +00004029 while (*cmd == ':')
4030 cmd = skipwhite(cmd + 1);
4031
Bram Moolenaar3bd8de42020-09-14 16:37:34 +02004032 // Skip "*" used for Visual range.
4033 if (skip_star && *cmd == '*' && vim_strchr(p_cpo, CPO_STAR) == NULL)
4034 cmd = skipwhite(cmd + 1);
4035
Bram Moolenaar071d4272004-06-13 20:20:40 +00004036 return cmd;
4037}
4038
Bram Moolenaar0acae7a2019-08-06 21:29:29 +02004039 static void
4040addr_error(cmd_addr_T addr_type)
4041{
4042 if (addr_type == ADDR_NONE)
Bram Moolenaar460ae5d2022-01-01 14:19:49 +00004043 emsg(_(e_no_range_allowed));
Bram Moolenaar0acae7a2019-08-06 21:29:29 +02004044 else
Bram Moolenaar108010a2021-06-27 22:03:33 +02004045 emsg(_(e_invalid_range));
Bram Moolenaar0acae7a2019-08-06 21:29:29 +02004046}
4047
Bram Moolenaar071d4272004-06-13 20:20:40 +00004048/*
Bram Moolenaarc2af0af2020-08-23 21:06:02 +02004049 * Return the default address for an address type.
4050 */
4051 static linenr_T
4052default_address(exarg_T *eap)
4053{
4054 linenr_T lnum = 0;
4055
4056 switch (eap->addr_type)
4057 {
4058 case ADDR_LINES:
4059 case ADDR_OTHER:
4060 // Default is the cursor line number. Avoid using an invalid
4061 // line number though.
4062 if (curwin->w_cursor.lnum > curbuf->b_ml.ml_line_count)
4063 lnum = curbuf->b_ml.ml_line_count;
4064 else
4065 lnum = curwin->w_cursor.lnum;
4066 break;
4067 case ADDR_WINDOWS:
4068 lnum = CURRENT_WIN_NR;
4069 break;
4070 case ADDR_ARGUMENTS:
4071 lnum = curwin->w_arg_idx + 1;
4072 if (lnum > ARGCOUNT)
4073 lnum = ARGCOUNT;
4074 break;
4075 case ADDR_LOADED_BUFFERS:
4076 case ADDR_BUFFERS:
4077 lnum = curbuf->b_fnum;
4078 break;
4079 case ADDR_TABS:
4080 lnum = CURRENT_TAB_NR;
4081 break;
4082 case ADDR_TABS_RELATIVE:
4083 case ADDR_UNSIGNED:
4084 lnum = 1;
4085 break;
4086 case ADDR_QUICKFIX:
4087#ifdef FEAT_QUICKFIX
4088 lnum = qf_get_cur_idx(eap);
4089#endif
4090 break;
4091 case ADDR_QUICKFIX_VALID:
4092#ifdef FEAT_QUICKFIX
4093 lnum = qf_get_cur_valid_idx(eap);
4094#endif
4095 break;
4096 case ADDR_NONE:
4097 // Will give an error later if a range is found.
4098 break;
4099 }
4100 return lnum;
4101}
4102
4103/*
Bram Moolenaar198cb662018-09-06 21:44:17 +02004104 * Get a single EX address.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004105 *
4106 * Set ptr to the next character after the part that was interpreted.
4107 * Set ptr to NULL when an error is encountered.
Bram Moolenaar198cb662018-09-06 21:44:17 +02004108 * This may set the last used search pattern.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004109 *
4110 * Return MAXLNUM when no Ex address was found.
4111 */
4112 static linenr_T
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01004113get_address(
4114 exarg_T *eap UNUSED,
4115 char_u **ptr,
Bram Moolenaar1b03a192019-12-08 17:08:29 +01004116 cmd_addr_T addr_type,
Bram Moolenaar50eb16c2018-09-15 15:42:40 +02004117 int skip, // only skip the address, don't use it
4118 int silent, // no errors or side effects
4119 int to_other_file, // flag: may jump to other file
4120 int address_count UNUSED) // 1 for first address, >1 after comma
Bram Moolenaar071d4272004-06-13 20:20:40 +00004121{
4122 int c;
4123 int i;
4124 long n;
4125 char_u *cmd;
4126 pos_T pos;
4127 pos_T *fp;
4128 linenr_T lnum;
Bram Moolenaarf1d6ccf2014-12-08 04:16:44 +01004129 buf_T *buf;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004130
4131 cmd = skipwhite(*ptr);
4132 lnum = MAXLNUM;
4133 do
4134 {
4135 switch (*cmd)
4136 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004137 case '.': // '.' - Cursor position
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004138 ++cmd;
4139 switch (addr_type)
4140 {
4141 case ADDR_LINES:
Bram Moolenaarb7316892019-05-01 18:08:42 +02004142 case ADDR_OTHER:
Bram Moolenaar071d4272004-06-13 20:20:40 +00004143 lnum = curwin->w_cursor.lnum;
4144 break;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004145 case ADDR_WINDOWS:
Bram Moolenaarf240e182014-11-27 18:33:02 +01004146 lnum = CURRENT_WIN_NR;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004147 break;
4148 case ADDR_ARGUMENTS:
4149 lnum = curwin->w_arg_idx + 1;
4150 break;
4151 case ADDR_LOADED_BUFFERS:
Bram Moolenaarf1d6ccf2014-12-08 04:16:44 +01004152 case ADDR_BUFFERS:
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004153 lnum = curbuf->b_fnum;
4154 break;
4155 case ADDR_TABS:
Bram Moolenaarf240e182014-11-27 18:33:02 +01004156 lnum = CURRENT_TAB_NR;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004157 break;
Bram Moolenaarb7316892019-05-01 18:08:42 +02004158 case ADDR_NONE:
Bram Moolenaar0acae7a2019-08-06 21:29:29 +02004159 case ADDR_TABS_RELATIVE:
Bram Moolenaar25190db2019-05-04 15:05:28 +02004160 case ADDR_UNSIGNED:
Bram Moolenaar0acae7a2019-08-06 21:29:29 +02004161 addr_error(addr_type);
Bram Moolenaar2f72c702017-01-29 14:48:10 +01004162 cmd = NULL;
4163 goto error;
4164 break;
Bram Moolenaaraa23b372015-09-08 18:46:31 +02004165 case ADDR_QUICKFIX:
Bram Moolenaar26f0cb12019-05-01 21:43:42 +02004166#ifdef FEAT_QUICKFIX
Bram Moolenaar25190db2019-05-04 15:05:28 +02004167 lnum = qf_get_cur_idx(eap);
4168#endif
4169 break;
4170 case ADDR_QUICKFIX_VALID:
4171#ifdef FEAT_QUICKFIX
Bram Moolenaaraa23b372015-09-08 18:46:31 +02004172 lnum = qf_get_cur_valid_idx(eap);
Bram Moolenaare906c502015-09-09 21:10:39 +02004173#endif
Bram Moolenaar26f0cb12019-05-01 21:43:42 +02004174 break;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004175 }
4176 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004177
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004178 case '$': // '$' - last line
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004179 ++cmd;
4180 switch (addr_type)
4181 {
4182 case ADDR_LINES:
Bram Moolenaarb7316892019-05-01 18:08:42 +02004183 case ADDR_OTHER:
Bram Moolenaar071d4272004-06-13 20:20:40 +00004184 lnum = curbuf->b_ml.ml_line_count;
4185 break;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004186 case ADDR_WINDOWS:
Bram Moolenaarf240e182014-11-27 18:33:02 +01004187 lnum = LAST_WIN_NR;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004188 break;
4189 case ADDR_ARGUMENTS:
4190 lnum = ARGCOUNT;
4191 break;
4192 case ADDR_LOADED_BUFFERS:
Bram Moolenaarf1d6ccf2014-12-08 04:16:44 +01004193 buf = lastbuf;
4194 while (buf->b_ml.ml_mfp == NULL)
4195 {
4196 if (buf->b_prev == NULL)
4197 break;
4198 buf = buf->b_prev;
4199 }
4200 lnum = buf->b_fnum;
4201 break;
4202 case ADDR_BUFFERS:
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004203 lnum = lastbuf->b_fnum;
4204 break;
4205 case ADDR_TABS:
Bram Moolenaarf240e182014-11-27 18:33:02 +01004206 lnum = LAST_TAB_NR;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004207 break;
Bram Moolenaarb7316892019-05-01 18:08:42 +02004208 case ADDR_NONE:
Bram Moolenaar0acae7a2019-08-06 21:29:29 +02004209 case ADDR_TABS_RELATIVE:
Bram Moolenaar25190db2019-05-04 15:05:28 +02004210 case ADDR_UNSIGNED:
Bram Moolenaar0acae7a2019-08-06 21:29:29 +02004211 addr_error(addr_type);
Bram Moolenaar2f72c702017-01-29 14:48:10 +01004212 cmd = NULL;
4213 goto error;
4214 break;
Bram Moolenaaraa23b372015-09-08 18:46:31 +02004215 case ADDR_QUICKFIX:
Bram Moolenaar26f0cb12019-05-01 21:43:42 +02004216#ifdef FEAT_QUICKFIX
Bram Moolenaaraa23b372015-09-08 18:46:31 +02004217 lnum = qf_get_size(eap);
4218 if (lnum == 0)
4219 lnum = 1;
Bram Moolenaare906c502015-09-09 21:10:39 +02004220#endif
Bram Moolenaar26f0cb12019-05-01 21:43:42 +02004221 break;
Bram Moolenaar25190db2019-05-04 15:05:28 +02004222 case ADDR_QUICKFIX_VALID:
4223#ifdef FEAT_QUICKFIX
4224 lnum = qf_get_valid_size(eap);
4225 if (lnum == 0)
4226 lnum = 1;
4227#endif
4228 break;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004229 }
4230 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004231
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004232 case '\'': // ''' - mark
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004233 if (*++cmd == NUL)
4234 {
4235 cmd = NULL;
4236 goto error;
4237 }
4238 if (addr_type != ADDR_LINES)
4239 {
Bram Moolenaar0acae7a2019-08-06 21:29:29 +02004240 addr_error(addr_type);
Bram Moolenaarc0a37b92015-02-03 19:10:53 +01004241 cmd = NULL;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004242 goto error;
4243 }
4244 if (skip)
4245 ++cmd;
4246 else
4247 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004248 // Only accept a mark in another file when it is
4249 // used by itself: ":'M".
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004250 fp = getmark(*cmd, to_other_file && cmd[1] == NUL);
4251 ++cmd;
4252 if (fp == (pos_T *)-1)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004253 // Jumped to another file.
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004254 lnum = curwin->w_cursor.lnum;
4255 else
4256 {
4257 if (check_mark(fp) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004258 {
4259 cmd = NULL;
4260 goto error;
4261 }
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004262 lnum = fp->lnum;
4263 }
4264 }
4265 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004266
4267 case '/':
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004268 case '?': // '/' or '?' - search
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004269 c = *cmd++;
4270 if (addr_type != ADDR_LINES)
4271 {
Bram Moolenaar0acae7a2019-08-06 21:29:29 +02004272 addr_error(addr_type);
Bram Moolenaarc0a37b92015-02-03 19:10:53 +01004273 cmd = NULL;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004274 goto error;
4275 }
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004276 if (skip) // skip "/pat/"
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004277 {
Bram Moolenaarf4e20992020-12-21 19:59:08 +01004278 cmd = skip_regexp(cmd, c, magic_isset());
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004279 if (*cmd == c)
4280 ++cmd;
4281 }
4282 else
4283 {
Bram Moolenaar50eb16c2018-09-15 15:42:40 +02004284 int flags;
4285
4286 pos = curwin->w_cursor; // save curwin->w_cursor
4287
4288 // When '/' or '?' follows another address, start from
4289 // there.
Bram Moolenaar35a319b2021-10-09 13:58:55 +01004290 if (lnum > 0 && lnum != MAXLNUM)
4291 curwin->w_cursor.lnum =
4292 lnum > curbuf->b_ml.ml_line_count
4293 ? curbuf->b_ml.ml_line_count : lnum;
Bram Moolenaar50eb16c2018-09-15 15:42:40 +02004294
4295 // Start a forward search at the end of the line (unless
4296 // before the first line).
4297 // Start a backward search at the start of the line.
4298 // This makes sure we never match in the current
4299 // line, and can match anywhere in the
4300 // next/previous line.
Bram Moolenaar8ada6aa2017-12-19 21:23:21 +01004301 if (c == '/' && curwin->w_cursor.lnum > 0)
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004302 curwin->w_cursor.col = MAXCOL;
4303 else
4304 curwin->w_cursor.col = 0;
4305 searchcmdlen = 0;
Bram Moolenaar50eb16c2018-09-15 15:42:40 +02004306 flags = silent ? 0 : SEARCH_HIS | SEARCH_MSG;
Bram Moolenaarc036e872020-02-21 21:30:52 +01004307 if (!do_search(NULL, c, c, cmd, 1L, flags, NULL))
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004308 {
4309 curwin->w_cursor = pos;
4310 cmd = NULL;
4311 goto error;
4312 }
4313 lnum = curwin->w_cursor.lnum;
4314 curwin->w_cursor = pos;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004315 // adjust command string pointer
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004316 cmd += searchcmdlen;
4317 }
4318 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004319
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004320 case '\\': // "\?", "\/" or "\&", repeat search
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004321 ++cmd;
4322 if (addr_type != ADDR_LINES)
4323 {
Bram Moolenaar0acae7a2019-08-06 21:29:29 +02004324 addr_error(addr_type);
Bram Moolenaarc0a37b92015-02-03 19:10:53 +01004325 cmd = NULL;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004326 goto error;
4327 }
4328 if (*cmd == '&')
4329 i = RE_SUBST;
4330 else if (*cmd == '?' || *cmd == '/')
4331 i = RE_SEARCH;
4332 else
4333 {
Bram Moolenaar108010a2021-06-27 22:03:33 +02004334 emsg(_(e_backslash_should_be_followed_by));
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004335 cmd = NULL;
4336 goto error;
4337 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004338
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004339 if (!skip)
4340 {
4341 /*
4342 * When search follows another address, start from
4343 * there.
4344 */
4345 if (lnum != MAXLNUM)
4346 pos.lnum = lnum;
4347 else
4348 pos.lnum = curwin->w_cursor.lnum;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004349
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004350 /*
4351 * Start the search just like for the above
4352 * do_search().
4353 */
4354 if (*cmd != '?')
4355 pos.col = MAXCOL;
4356 else
4357 pos.col = 0;
Bram Moolenaarbd8539a2015-08-11 18:53:03 +02004358 pos.coladd = 0;
Bram Moolenaar5d24a222018-12-23 19:10:09 +01004359 if (searchit(curwin, curbuf, &pos, NULL,
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004360 *cmd == '?' ? BACKWARD : FORWARD,
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02004361 (char_u *)"", 1L, SEARCH_MSG, i, NULL) != FAIL)
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004362 lnum = pos.lnum;
4363 else
4364 {
4365 cmd = NULL;
4366 goto error;
4367 }
4368 }
4369 ++cmd;
4370 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004371
4372 default:
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004373 if (VIM_ISDIGIT(*cmd)) // absolute line number
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004374 lnum = getdigits(&cmd);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004375 }
4376
4377 for (;;)
4378 {
4379 cmd = skipwhite(cmd);
4380 if (*cmd != '-' && *cmd != '+' && !VIM_ISDIGIT(*cmd))
4381 break;
4382
4383 if (lnum == MAXLNUM)
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004384 {
4385 switch (addr_type)
4386 {
4387 case ADDR_LINES:
Bram Moolenaarb7316892019-05-01 18:08:42 +02004388 case ADDR_OTHER:
4389 // "+1" is same as ".+1"
Bram Moolenaarf240e182014-11-27 18:33:02 +01004390 lnum = curwin->w_cursor.lnum;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004391 break;
4392 case ADDR_WINDOWS:
Bram Moolenaarf240e182014-11-27 18:33:02 +01004393 lnum = CURRENT_WIN_NR;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004394 break;
4395 case ADDR_ARGUMENTS:
4396 lnum = curwin->w_arg_idx + 1;
4397 break;
4398 case ADDR_LOADED_BUFFERS:
Bram Moolenaarf1d6ccf2014-12-08 04:16:44 +01004399 case ADDR_BUFFERS:
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004400 lnum = curbuf->b_fnum;
4401 break;
4402 case ADDR_TABS:
Bram Moolenaarf240e182014-11-27 18:33:02 +01004403 lnum = CURRENT_TAB_NR;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004404 break;
Bram Moolenaar2f72c702017-01-29 14:48:10 +01004405 case ADDR_TABS_RELATIVE:
4406 lnum = 1;
4407 break;
Bram Moolenaaraa23b372015-09-08 18:46:31 +02004408 case ADDR_QUICKFIX:
Bram Moolenaar26f0cb12019-05-01 21:43:42 +02004409#ifdef FEAT_QUICKFIX
Bram Moolenaar25190db2019-05-04 15:05:28 +02004410 lnum = qf_get_cur_idx(eap);
4411#endif
4412 break;
4413 case ADDR_QUICKFIX_VALID:
4414#ifdef FEAT_QUICKFIX
Bram Moolenaaraa23b372015-09-08 18:46:31 +02004415 lnum = qf_get_cur_valid_idx(eap);
Bram Moolenaare906c502015-09-09 21:10:39 +02004416#endif
Bram Moolenaar26f0cb12019-05-01 21:43:42 +02004417 break;
Bram Moolenaarb7316892019-05-01 18:08:42 +02004418 case ADDR_NONE:
Bram Moolenaar25190db2019-05-04 15:05:28 +02004419 case ADDR_UNSIGNED:
4420 lnum = 0;
Bram Moolenaarb7316892019-05-01 18:08:42 +02004421 break;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004422 }
4423 }
4424
Bram Moolenaar071d4272004-06-13 20:20:40 +00004425 if (VIM_ISDIGIT(*cmd))
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004426 i = '+'; // "number" is same as "+number"
Bram Moolenaar071d4272004-06-13 20:20:40 +00004427 else
4428 i = *cmd++;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004429 if (!VIM_ISDIGIT(*cmd)) // '+' is '+1', but '+0' is not '+1'
Bram Moolenaar071d4272004-06-13 20:20:40 +00004430 n = 1;
4431 else
Bram Moolenaar03725c52021-11-24 12:17:53 +00004432 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00004433 n = getdigits(&cmd);
Bram Moolenaar03725c52021-11-24 12:17:53 +00004434 if (n == MAXLNUM)
4435 {
4436 emsg(_(e_line_number_out_of_range));
4437 goto error;
4438 }
4439 }
Bram Moolenaar2f72c702017-01-29 14:48:10 +01004440
4441 if (addr_type == ADDR_TABS_RELATIVE)
4442 {
Bram Moolenaar108010a2021-06-27 22:03:33 +02004443 emsg(_(e_invalid_range));
Bram Moolenaar2f72c702017-01-29 14:48:10 +01004444 cmd = NULL;
4445 goto error;
4446 }
4447 else if (addr_type == ADDR_LOADED_BUFFERS
Bram Moolenaarf1d6ccf2014-12-08 04:16:44 +01004448 || addr_type == ADDR_BUFFERS)
Bram Moolenaarc0a37b92015-02-03 19:10:53 +01004449 lnum = compute_buffer_local_count(
4450 addr_type, lnum, (i == '-') ? -1 * n : n);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004451 else
Bram Moolenaarded27822017-01-02 14:27:34 +01004452 {
4453#ifdef FEAT_FOLDING
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004454 // Relative line addressing, need to adjust for folded lines
4455 // now, but only do it after the first address.
Bram Moolenaarded27822017-01-02 14:27:34 +01004456 if (addr_type == ADDR_LINES && (i == '-' || i == '+')
Bram Moolenaar03725c52021-11-24 12:17:53 +00004457 && address_count >= 2)
Bram Moolenaarded27822017-01-02 14:27:34 +01004458 (void)hasFolding(lnum, NULL, &lnum);
4459#endif
4460 if (i == '-')
4461 lnum -= n;
4462 else
Bram Moolenaar03725c52021-11-24 12:17:53 +00004463 {
4464 if (n >= LONG_MAX - lnum)
4465 {
4466 emsg(_(e_line_number_out_of_range));
4467 goto error;
4468 }
Bram Moolenaarded27822017-01-02 14:27:34 +01004469 lnum += n;
Bram Moolenaar03725c52021-11-24 12:17:53 +00004470 }
Bram Moolenaarded27822017-01-02 14:27:34 +01004471 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004472 }
4473 } while (*cmd == '/' || *cmd == '?');
4474
4475error:
4476 *ptr = cmd;
4477 return lnum;
4478}
4479
4480/*
Bram Moolenaarc2af0af2020-08-23 21:06:02 +02004481 * Set eap->line1 and eap->line2 to the whole range.
4482 * Used for commands with the EX_DFLALL flag and no range given.
4483 */
4484 static void
4485address_default_all(exarg_T *eap)
4486{
4487 eap->line1 = 1;
4488 switch (eap->addr_type)
4489 {
4490 case ADDR_LINES:
4491 case ADDR_OTHER:
4492 eap->line2 = curbuf->b_ml.ml_line_count;
4493 break;
4494 case ADDR_LOADED_BUFFERS:
4495 {
4496 buf_T *buf = firstbuf;
4497
4498 while (buf->b_next != NULL && buf->b_ml.ml_mfp == NULL)
4499 buf = buf->b_next;
4500 eap->line1 = buf->b_fnum;
4501 buf = lastbuf;
4502 while (buf->b_prev != NULL && buf->b_ml.ml_mfp == NULL)
4503 buf = buf->b_prev;
4504 eap->line2 = buf->b_fnum;
4505 }
4506 break;
4507 case ADDR_BUFFERS:
4508 eap->line1 = firstbuf->b_fnum;
4509 eap->line2 = lastbuf->b_fnum;
4510 break;
4511 case ADDR_WINDOWS:
4512 eap->line2 = LAST_WIN_NR;
4513 break;
4514 case ADDR_TABS:
4515 eap->line2 = LAST_TAB_NR;
4516 break;
4517 case ADDR_TABS_RELATIVE:
4518 eap->line2 = 1;
4519 break;
4520 case ADDR_ARGUMENTS:
4521 if (ARGCOUNT == 0)
4522 eap->line1 = eap->line2 = 0;
4523 else
4524 eap->line2 = ARGCOUNT;
4525 break;
4526 case ADDR_QUICKFIX_VALID:
4527#ifdef FEAT_QUICKFIX
4528 eap->line2 = qf_get_valid_size(eap);
4529 if (eap->line2 == 0)
4530 eap->line2 = 1;
4531#endif
4532 break;
4533 case ADDR_NONE:
4534 case ADDR_UNSIGNED:
4535 case ADDR_QUICKFIX:
4536 iemsg(_("INTERNAL: Cannot use EX_DFLALL with ADDR_NONE, ADDR_UNSIGNED or ADDR_QUICKFIX"));
4537 break;
4538 }
4539}
4540
4541
4542/*
Bram Moolenaardf177f62005-02-22 08:39:57 +00004543 * Get flags from an Ex command argument.
4544 */
4545 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01004546get_flags(exarg_T *eap)
Bram Moolenaardf177f62005-02-22 08:39:57 +00004547{
4548 while (vim_strchr((char_u *)"lp#", *eap->arg) != NULL)
4549 {
4550 if (*eap->arg == 'l')
4551 eap->flags |= EXFLAG_LIST;
4552 else if (*eap->arg == 'p')
4553 eap->flags |= EXFLAG_PRINT;
4554 else
4555 eap->flags |= EXFLAG_NR;
4556 eap->arg = skipwhite(eap->arg + 1);
4557 }
4558}
4559
4560/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00004561 * Function called for command which is Not Implemented. NI!
4562 */
4563 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01004564ex_ni(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004565{
4566 if (!eap->skip)
Bram Moolenaar8930caa2020-07-23 16:37:03 +02004567 eap->errmsg =
Bram Moolenaareaaac012022-01-02 17:00:40 +00004568 _(e_sorry_command_is_not_available_in_this_version);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004569}
4570
Bram Moolenaar7bb75552007-07-16 18:39:49 +00004571#ifdef HAVE_EX_SCRIPT_NI
Bram Moolenaar071d4272004-06-13 20:20:40 +00004572/*
4573 * Function called for script command which is Not Implemented. NI!
4574 * Skips over ":perl <<EOF" constructs.
4575 */
4576 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01004577ex_script_ni(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004578{
4579 if (!eap->skip)
4580 ex_ni(eap);
4581 else
4582 vim_free(script_get(eap, eap->arg));
4583}
4584#endif
4585
4586/*
4587 * Check range in Ex command for validity.
4588 * Return NULL when valid, error message when invalid.
4589 */
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004590 static char *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01004591invalid_range(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004592{
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01004593 buf_T *buf;
Bram Moolenaar25190db2019-05-04 15:05:28 +02004594
Bram Moolenaar071d4272004-06-13 20:20:40 +00004595 if ( eap->line1 < 0
4596 || eap->line2 < 0
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01004597 || eap->line1 > eap->line2)
Bram Moolenaar108010a2021-06-27 22:03:33 +02004598 return _(e_invalid_range);
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01004599
Bram Moolenaar8071cb22019-07-12 17:58:01 +02004600 if (eap->argt & EX_RANGE)
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01004601 {
Bram Moolenaarb7316892019-05-01 18:08:42 +02004602 switch (eap->addr_type)
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01004603 {
4604 case ADDR_LINES:
Bram Moolenaarb7316892019-05-01 18:08:42 +02004605 if (eap->line2 > curbuf->b_ml.ml_line_count
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01004606#ifdef FEAT_DIFF
4607 + (eap->cmdidx == CMD_diffget)
4608#endif
4609 )
Bram Moolenaar108010a2021-06-27 22:03:33 +02004610 return _(e_invalid_range);
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01004611 break;
4612 case ADDR_ARGUMENTS:
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004613 // add 1 if ARGCOUNT is 0
Bram Moolenaarc0a37b92015-02-03 19:10:53 +01004614 if (eap->line2 > ARGCOUNT + (!ARGCOUNT))
Bram Moolenaar108010a2021-06-27 22:03:33 +02004615 return _(e_invalid_range);
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01004616 break;
4617 case ADDR_BUFFERS:
Bram Moolenaar00b0d6d2019-08-21 22:25:30 +02004618 // Only a boundary check, not whether the buffers actually
4619 // exist.
4620 if (eap->line1 < 1 || eap->line2 > get_highest_fnum())
Bram Moolenaar108010a2021-06-27 22:03:33 +02004621 return _(e_invalid_range);
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01004622 break;
4623 case ADDR_LOADED_BUFFERS:
4624 buf = firstbuf;
4625 while (buf->b_ml.ml_mfp == NULL)
4626 {
4627 if (buf->b_next == NULL)
Bram Moolenaar108010a2021-06-27 22:03:33 +02004628 return _(e_invalid_range);
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01004629 buf = buf->b_next;
4630 }
4631 if (eap->line1 < buf->b_fnum)
Bram Moolenaar108010a2021-06-27 22:03:33 +02004632 return _(e_invalid_range);
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01004633 buf = lastbuf;
4634 while (buf->b_ml.ml_mfp == NULL)
4635 {
4636 if (buf->b_prev == NULL)
Bram Moolenaar108010a2021-06-27 22:03:33 +02004637 return _(e_invalid_range);
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01004638 buf = buf->b_prev;
4639 }
4640 if (eap->line2 > buf->b_fnum)
Bram Moolenaar108010a2021-06-27 22:03:33 +02004641 return _(e_invalid_range);
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01004642 break;
4643 case ADDR_WINDOWS:
Bram Moolenaar8be63882015-01-14 11:25:05 +01004644 if (eap->line2 > LAST_WIN_NR)
Bram Moolenaar108010a2021-06-27 22:03:33 +02004645 return _(e_invalid_range);
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01004646 break;
4647 case ADDR_TABS:
4648 if (eap->line2 > LAST_TAB_NR)
Bram Moolenaar108010a2021-06-27 22:03:33 +02004649 return _(e_invalid_range);
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01004650 break;
Bram Moolenaar2f72c702017-01-29 14:48:10 +01004651 case ADDR_TABS_RELATIVE:
Bram Moolenaarb7316892019-05-01 18:08:42 +02004652 case ADDR_OTHER:
4653 // Any range is OK.
Bram Moolenaar2f72c702017-01-29 14:48:10 +01004654 break;
Bram Moolenaaraa23b372015-09-08 18:46:31 +02004655 case ADDR_QUICKFIX:
Bram Moolenaar26f0cb12019-05-01 21:43:42 +02004656#ifdef FEAT_QUICKFIX
Bram Moolenaar25190db2019-05-04 15:05:28 +02004657 // No error for value that is too big, will use the last entry.
4658 if (eap->line2 <= 0)
Bram Moolenaara5d78d12021-12-15 12:28:22 +00004659 {
4660 if (eap->addr_count == 0)
4661 return _(e_no_errors);
Bram Moolenaar108010a2021-06-27 22:03:33 +02004662 return _(e_invalid_range);
Bram Moolenaara5d78d12021-12-15 12:28:22 +00004663 }
Bram Moolenaare906c502015-09-09 21:10:39 +02004664#endif
Bram Moolenaar26f0cb12019-05-01 21:43:42 +02004665 break;
Bram Moolenaar25190db2019-05-04 15:05:28 +02004666 case ADDR_QUICKFIX_VALID:
4667#ifdef FEAT_QUICKFIX
4668 if ((eap->line2 != 1 && eap->line2 > qf_get_valid_size(eap))
4669 || eap->line2 < 0)
Bram Moolenaar108010a2021-06-27 22:03:33 +02004670 return _(e_invalid_range);
Bram Moolenaar25190db2019-05-04 15:05:28 +02004671#endif
4672 break;
4673 case ADDR_UNSIGNED:
Bram Moolenaarb7316892019-05-01 18:08:42 +02004674 case ADDR_NONE:
4675 // Will give an error elsewhere.
4676 break;
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01004677 }
4678 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004679 return NULL;
4680}
4681
4682/*
4683 * Correct the range for zero line number, if required.
4684 */
4685 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01004686correct_range(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004687{
Bram Moolenaar8071cb22019-07-12 17:58:01 +02004688 if (!(eap->argt & EX_ZEROR)) // zero in range not allowed
Bram Moolenaar071d4272004-06-13 20:20:40 +00004689 {
4690 if (eap->line1 == 0)
4691 eap->line1 = 1;
4692 if (eap->line2 == 0)
4693 eap->line2 = 1;
4694 }
4695}
4696
Bram Moolenaar748bf032005-02-02 23:04:36 +00004697#ifdef FEAT_QUICKFIX
Bram Moolenaar748bf032005-02-02 23:04:36 +00004698/*
4699 * For a ":vimgrep" or ":vimgrepadd" command return a pointer past the
4700 * pattern. Otherwise return eap->arg.
4701 */
4702 static char_u *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01004703skip_grep_pat(exarg_T *eap)
Bram Moolenaar748bf032005-02-02 23:04:36 +00004704{
4705 char_u *p = eap->arg;
4706
Bram Moolenaara37420f2006-02-04 22:37:47 +00004707 if (*p != NUL && (eap->cmdidx == CMD_vimgrep || eap->cmdidx == CMD_lvimgrep
4708 || eap->cmdidx == CMD_vimgrepadd
4709 || eap->cmdidx == CMD_lvimgrepadd
4710 || grep_internal(eap->cmdidx)))
Bram Moolenaar748bf032005-02-02 23:04:36 +00004711 {
Bram Moolenaar05159a02005-02-26 23:04:13 +00004712 p = skip_vimgrep_pat(p, NULL, NULL);
Bram Moolenaar748bf032005-02-02 23:04:36 +00004713 if (p == NULL)
4714 p = eap->arg;
Bram Moolenaar748bf032005-02-02 23:04:36 +00004715 }
4716 return p;
4717}
Bram Moolenaard857f0e2005-06-21 22:37:39 +00004718
4719/*
4720 * For the ":make" and ":grep" commands insert the 'makeprg'/'grepprg' option
4721 * in the command line, so that things like % get expanded.
4722 */
4723 static char_u *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01004724replace_makeprg(exarg_T *eap, char_u *p, char_u **cmdlinep)
Bram Moolenaard857f0e2005-06-21 22:37:39 +00004725{
4726 char_u *new_cmdline;
4727 char_u *program;
4728 char_u *pos;
4729 char_u *ptr;
4730 int len;
4731 int i;
4732
4733 /*
4734 * Don't do it when ":vimgrep" is used for ":grep".
4735 */
Bram Moolenaara37420f2006-02-04 22:37:47 +00004736 if ((eap->cmdidx == CMD_make || eap->cmdidx == CMD_lmake
4737 || eap->cmdidx == CMD_grep || eap->cmdidx == CMD_lgrep
4738 || eap->cmdidx == CMD_grepadd
4739 || eap->cmdidx == CMD_lgrepadd)
Bram Moolenaard857f0e2005-06-21 22:37:39 +00004740 && !grep_internal(eap->cmdidx))
4741 {
Bram Moolenaara37420f2006-02-04 22:37:47 +00004742 if (eap->cmdidx == CMD_grep || eap->cmdidx == CMD_lgrep
4743 || eap->cmdidx == CMD_grepadd || eap->cmdidx == CMD_lgrepadd)
Bram Moolenaard857f0e2005-06-21 22:37:39 +00004744 {
4745 if (*curbuf->b_p_gp == NUL)
4746 program = p_gp;
4747 else
4748 program = curbuf->b_p_gp;
4749 }
4750 else
4751 {
4752 if (*curbuf->b_p_mp == NUL)
4753 program = p_mp;
4754 else
4755 program = curbuf->b_p_mp;
4756 }
4757
4758 p = skipwhite(p);
4759
4760 if ((pos = (char_u *)strstr((char *)program, "$*")) != NULL)
4761 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004762 // replace $* by given arguments
Bram Moolenaard857f0e2005-06-21 22:37:39 +00004763 i = 1;
4764 while ((pos = (char_u *)strstr((char *)pos + 2, "$*")) != NULL)
4765 ++i;
4766 len = (int)STRLEN(p);
=?UTF-8?q?Dundar=20G=C3=B6c?=d5cec1f2022-01-29 15:19:23 +00004767 new_cmdline = alloc(STRLEN(program) + (size_t)i * (len - 2) + 1);
Bram Moolenaard857f0e2005-06-21 22:37:39 +00004768 if (new_cmdline == NULL)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004769 return NULL; // out of memory
Bram Moolenaard857f0e2005-06-21 22:37:39 +00004770 ptr = new_cmdline;
4771 while ((pos = (char_u *)strstr((char *)program, "$*")) != NULL)
4772 {
4773 i = (int)(pos - program);
4774 STRNCPY(ptr, program, i);
4775 STRCPY(ptr += i, p);
4776 ptr += len;
4777 program = pos + 2;
4778 }
4779 STRCPY(ptr, program);
4780 }
4781 else
4782 {
Bram Moolenaar51e14382019-05-25 20:21:28 +02004783 new_cmdline = alloc(STRLEN(program) + STRLEN(p) + 2);
Bram Moolenaard857f0e2005-06-21 22:37:39 +00004784 if (new_cmdline == NULL)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004785 return NULL; // out of memory
Bram Moolenaard857f0e2005-06-21 22:37:39 +00004786 STRCPY(new_cmdline, program);
4787 STRCAT(new_cmdline, " ");
4788 STRCAT(new_cmdline, p);
4789 }
4790 msg_make(p);
4791
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004792 // 'eap->cmd' is not set here, because it is not used at CMD_make
Bram Moolenaard857f0e2005-06-21 22:37:39 +00004793 vim_free(*cmdlinep);
4794 *cmdlinep = new_cmdline;
4795 p = new_cmdline;
4796 }
4797 return p;
4798}
Bram Moolenaar748bf032005-02-02 23:04:36 +00004799#endif
4800
Bram Moolenaar071d4272004-06-13 20:20:40 +00004801/*
4802 * Expand file name in Ex command argument.
Bram Moolenaar0abb4272019-06-15 16:06:00 +02004803 * When an error is detected, "errormsgp" is set to a non-NULL pointer.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004804 * Return FAIL for failure, OK otherwise.
4805 */
4806 int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01004807expand_filename(
4808 exarg_T *eap,
4809 char_u **cmdlinep,
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004810 char **errormsgp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004811{
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004812 int has_wildcards; // need to expand wildcards
Bram Moolenaar071d4272004-06-13 20:20:40 +00004813 char_u *repl;
4814 int srclen;
4815 char_u *p;
4816 int n;
Bram Moolenaar63b92542007-03-27 14:57:09 +00004817 int escaped;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004818
Bram Moolenaar748bf032005-02-02 23:04:36 +00004819#ifdef FEAT_QUICKFIX
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004820 // Skip a regexp pattern for ":vimgrep[add] pat file..."
Bram Moolenaar748bf032005-02-02 23:04:36 +00004821 p = skip_grep_pat(eap);
4822#else
4823 p = eap->arg;
4824#endif
4825
Bram Moolenaar071d4272004-06-13 20:20:40 +00004826 /*
4827 * Decide to expand wildcards *before* replacing '%', '#', etc. If
4828 * the file name contains a wildcard it should not cause expanding.
4829 * (it will be expanded anyway if there is a wildcard before replacing).
4830 */
Bram Moolenaar748bf032005-02-02 23:04:36 +00004831 has_wildcards = mch_has_wildcard(p);
4832 while (*p != NUL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004833 {
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004834#ifdef FEAT_EVAL
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004835 // Skip over `=expr`, wildcards in it are not expanded.
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004836 if (p[0] == '`' && p[1] == '=')
4837 {
4838 p += 2;
Bram Moolenaar683581e2020-10-22 21:22:58 +02004839 (void)skip_expr(&p, NULL);
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004840 if (*p == '`')
4841 ++p;
4842 continue;
4843 }
4844#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004845 /*
4846 * Quick check if this cannot be the start of a special string.
4847 * Also removes backslash before '%', '#' and '<'.
4848 */
4849 if (vim_strchr((char_u *)"%#<", *p) == NULL)
4850 {
4851 ++p;
4852 continue;
4853 }
4854
4855 /*
4856 * Try to find a match at this position.
4857 */
Bram Moolenaar63b92542007-03-27 14:57:09 +00004858 repl = eval_vars(p, eap->arg, &srclen, &(eap->do_ecmd_lnum),
4859 errormsgp, &escaped);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004860 if (*errormsgp != NULL) // error detected
Bram Moolenaar071d4272004-06-13 20:20:40 +00004861 return FAIL;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004862 if (repl == NULL) // no match found
Bram Moolenaar071d4272004-06-13 20:20:40 +00004863 {
4864 p += srclen;
4865 continue;
4866 }
4867
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004868 // Wildcards won't be expanded below, the replacement is taken
4869 // literally. But do expand "~/file", "~user/file" and "$HOME/file".
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00004870 if (vim_strchr(repl, '$') != NULL || vim_strchr(repl, '~') != NULL)
4871 {
4872 char_u *l = repl;
4873
4874 repl = expand_env_save(repl);
4875 vim_free(l);
4876 }
4877
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004878 // Need to escape white space et al. with a backslash.
4879 // Don't do this for:
4880 // - replacement that already has been escaped: "##"
4881 // - shell commands (may have to use quotes instead).
4882 // - non-unix systems when there is a single argument (spaces don't
4883 // separate arguments then).
Bram Moolenaar071d4272004-06-13 20:20:40 +00004884 if (!eap->usefilter
Bram Moolenaar63b92542007-03-27 14:57:09 +00004885 && !escaped
Bram Moolenaar071d4272004-06-13 20:20:40 +00004886 && eap->cmdidx != CMD_bang
Bram Moolenaar071d4272004-06-13 20:20:40 +00004887 && eap->cmdidx != CMD_grep
4888 && eap->cmdidx != CMD_grepadd
Bram Moolenaarbf15b8d2017-06-04 20:43:48 +02004889 && eap->cmdidx != CMD_hardcopy
Bram Moolenaar67883b42017-07-27 22:57:00 +02004890 && eap->cmdidx != CMD_lgrep
4891 && eap->cmdidx != CMD_lgrepadd
4892 && eap->cmdidx != CMD_lmake
4893 && eap->cmdidx != CMD_make
4894 && eap->cmdidx != CMD_terminal
Bram Moolenaar071d4272004-06-13 20:20:40 +00004895#ifndef UNIX
Bram Moolenaar8071cb22019-07-12 17:58:01 +02004896 && !(eap->argt & EX_NOSPC)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004897#endif
4898 )
4899 {
4900 char_u *l;
4901#ifdef BACKSLASH_IN_FILENAME
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004902 // Don't escape a backslash here, because rem_backslash() doesn't
4903 // remove it later.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004904 static char_u *nobslash = (char_u *)" \t\"|";
4905# define ESCAPE_CHARS nobslash
4906#else
4907# define ESCAPE_CHARS escape_chars
4908#endif
4909
4910 for (l = repl; *l; ++l)
4911 if (vim_strchr(ESCAPE_CHARS, *l) != NULL)
4912 {
4913 l = vim_strsave_escaped(repl, ESCAPE_CHARS);
4914 if (l != NULL)
4915 {
4916 vim_free(repl);
4917 repl = l;
4918 }
4919 break;
4920 }
4921 }
4922
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004923 // For a shell command a '!' must be escaped.
Bram Moolenaar67883b42017-07-27 22:57:00 +02004924 if ((eap->usefilter || eap->cmdidx == CMD_bang
4925 || eap->cmdidx == CMD_terminal)
Bram Moolenaar31b7d382014-04-01 18:54:48 +02004926 && vim_strpbrk(repl, (char_u *)"!") != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004927 {
4928 char_u *l;
4929
Bram Moolenaar31b7d382014-04-01 18:54:48 +02004930 l = vim_strsave_escaped(repl, (char_u *)"!");
Bram Moolenaar071d4272004-06-13 20:20:40 +00004931 if (l != NULL)
4932 {
4933 vim_free(repl);
4934 repl = l;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004935 }
4936 }
4937
4938 p = repl_cmdline(eap, p, srclen, repl, cmdlinep);
4939 vim_free(repl);
4940 if (p == NULL)
4941 return FAIL;
4942 }
4943
4944 /*
4945 * One file argument: Expand wildcards.
4946 * Don't do this with ":r !command" or ":w !command".
4947 */
Bram Moolenaar8071cb22019-07-12 17:58:01 +02004948 if ((eap->argt & EX_NOSPC) && !eap->usefilter)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004949 {
4950 /*
4951 * May do this twice:
4952 * 1. Replace environment variables.
4953 * 2. Replace any other wildcards, remove backslashes.
4954 */
4955 for (n = 1; n <= 2; ++n)
4956 {
4957 if (n == 2)
4958 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00004959 /*
4960 * Halve the number of backslashes (this is Vi compatible).
4961 * For Unix and OS/2, when wildcards are expanded, this is
4962 * done by ExpandOne() below.
4963 */
Bram Moolenaare7fedb62015-12-31 19:07:19 +01004964#if defined(UNIX)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004965 if (!has_wildcards)
4966#endif
4967 backslash_halve(eap->arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004968 }
4969
4970 if (has_wildcards)
4971 {
4972 if (n == 1)
4973 {
4974 /*
4975 * First loop: May expand environment variables. This
4976 * can be done much faster with expand_env() than with
4977 * something else (e.g., calling a shell).
4978 * After expanding environment variables, check again
4979 * if there are still wildcards present.
4980 */
4981 if (vim_strchr(eap->arg, '$') != NULL
4982 || vim_strchr(eap->arg, '~') != NULL)
4983 {
Bram Moolenaara1ba8112005-06-28 23:23:32 +00004984 expand_env_esc(eap->arg, NameBuff, MAXPATHL,
Bram Moolenaar9f0545d2007-09-26 20:36:32 +00004985 TRUE, TRUE, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004986 has_wildcards = mch_has_wildcard(NameBuff);
4987 p = NameBuff;
4988 }
4989 else
4990 p = NULL;
4991 }
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004992 else // n == 2
Bram Moolenaar071d4272004-06-13 20:20:40 +00004993 {
4994 expand_T xpc;
Bram Moolenaarb40c2572019-10-19 21:01:05 +02004995 int options = WILD_LIST_NOTFOUND
4996 | WILD_NOERROR | WILD_ADD_SLASH;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004997
4998 ExpandInit(&xpc);
4999 xpc.xp_context = EXPAND_FILES;
Bram Moolenaar94950a92010-12-02 16:01:29 +01005000 if (p_wic)
5001 options += WILD_ICASE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005002 p = ExpandOne(&xpc, eap->arg, NULL,
Bram Moolenaar94950a92010-12-02 16:01:29 +01005003 options, WILD_EXPAND_FREE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005004 if (p == NULL)
5005 return FAIL;
5006 }
5007 if (p != NULL)
5008 {
5009 (void)repl_cmdline(eap, eap->arg, (int)STRLEN(eap->arg),
5010 p, cmdlinep);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005011 if (n == 2) // p came from ExpandOne()
Bram Moolenaar071d4272004-06-13 20:20:40 +00005012 vim_free(p);
5013 }
5014 }
5015 }
5016 }
5017 return OK;
5018}
5019
5020/*
5021 * Replace part of the command line, keeping eap->cmd, eap->arg and
5022 * eap->nextcmd correct.
5023 * "src" points to the part that is to be replaced, of length "srclen".
5024 * "repl" is the replacement string.
5025 * Returns a pointer to the character after the replaced string.
5026 * Returns NULL for failure.
5027 */
5028 static char_u *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005029repl_cmdline(
5030 exarg_T *eap,
5031 char_u *src,
5032 int srclen,
5033 char_u *repl,
5034 char_u **cmdlinep)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005035{
5036 int len;
5037 int i;
5038 char_u *new_cmdline;
5039
5040 /*
5041 * The new command line is build in new_cmdline[].
5042 * First allocate it.
5043 * Careful: a "+cmd" argument may have been NUL terminated.
5044 */
5045 len = (int)STRLEN(repl);
5046 i = (int)(src - *cmdlinep) + (int)STRLEN(src + srclen) + len + 3;
Bram Moolenaare1438bb2006-03-01 22:01:55 +00005047 if (eap->nextcmd != NULL)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005048 i += (int)STRLEN(eap->nextcmd);// add space for next command
Bram Moolenaar964b3742019-05-24 18:54:09 +02005049 if ((new_cmdline = alloc(i)) == NULL)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005050 return NULL; // out of memory!
Bram Moolenaar071d4272004-06-13 20:20:40 +00005051
5052 /*
5053 * Copy the stuff before the expanded part.
5054 * Copy the expanded stuff.
5055 * Copy what came after the expanded part.
5056 * Copy the next commands, if there are any.
5057 */
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005058 i = (int)(src - *cmdlinep); // length of part before match
Bram Moolenaar071d4272004-06-13 20:20:40 +00005059 mch_memmove(new_cmdline, *cmdlinep, (size_t)i);
Bram Moolenaara3ffd9c2005-07-21 21:03:15 +00005060
Bram Moolenaar071d4272004-06-13 20:20:40 +00005061 mch_memmove(new_cmdline + i, repl, (size_t)len);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005062 i += len; // remember the end of the string
Bram Moolenaar071d4272004-06-13 20:20:40 +00005063 STRCPY(new_cmdline + i, src + srclen);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005064 src = new_cmdline + i; // remember where to continue
Bram Moolenaar071d4272004-06-13 20:20:40 +00005065
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005066 if (eap->nextcmd != NULL) // append next command
Bram Moolenaar071d4272004-06-13 20:20:40 +00005067 {
5068 i = (int)STRLEN(new_cmdline) + 1;
5069 STRCPY(new_cmdline + i, eap->nextcmd);
5070 eap->nextcmd = new_cmdline + i;
5071 }
5072 eap->cmd = new_cmdline + (eap->cmd - *cmdlinep);
5073 eap->arg = new_cmdline + (eap->arg - *cmdlinep);
5074 if (eap->do_ecmd_cmd != NULL && eap->do_ecmd_cmd != dollar_command)
5075 eap->do_ecmd_cmd = new_cmdline + (eap->do_ecmd_cmd - *cmdlinep);
5076 vim_free(*cmdlinep);
5077 *cmdlinep = new_cmdline;
5078
5079 return src;
5080}
5081
5082/*
5083 * Check for '|' to separate commands and '"' to start comments.
Bram Moolenaarac485062022-03-23 19:45:01 +00005084 * If "keep_backslash" is TRUE do not remove any backslash.
Bram Moolenaar071d4272004-06-13 20:20:40 +00005085 */
5086 void
Bram Moolenaarac485062022-03-23 19:45:01 +00005087separate_nextcmd(exarg_T *eap, int keep_backslash)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005088{
5089 char_u *p;
5090
Bram Moolenaar86b68352004-12-27 21:59:20 +00005091#ifdef FEAT_QUICKFIX
Bram Moolenaar748bf032005-02-02 23:04:36 +00005092 p = skip_grep_pat(eap);
5093#else
5094 p = eap->arg;
Bram Moolenaar86b68352004-12-27 21:59:20 +00005095#endif
5096
Bram Moolenaar91acfff2017-03-12 19:22:36 +01005097 for ( ; *p; MB_PTR_ADV(p))
Bram Moolenaar071d4272004-06-13 20:20:40 +00005098 {
5099 if (*p == Ctrl_V)
5100 {
Bram Moolenaarac485062022-03-23 19:45:01 +00005101 if ((eap->argt & (EX_CTRLV | EX_XFILE)) || keep_backslash)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005102 ++p; // skip CTRL-V and next char
Bram Moolenaar071d4272004-06-13 20:20:40 +00005103 else
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005104 // remove CTRL-V and skip next char
Bram Moolenaara7241f52008-06-24 20:39:31 +00005105 STRMOVE(p, p + 1);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005106 if (*p == NUL) // stop at NUL after CTRL-V
Bram Moolenaar071d4272004-06-13 20:20:40 +00005107 break;
5108 }
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005109
5110#ifdef FEAT_EVAL
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005111 // Skip over `=expr` when wildcards are expanded.
Bram Moolenaar8071cb22019-07-12 17:58:01 +02005112 else if (p[0] == '`' && p[1] == '=' && (eap->argt & EX_XFILE))
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005113 {
5114 p += 2;
Bram Moolenaar683581e2020-10-22 21:22:58 +02005115 (void)skip_expr(&p, NULL);
Bram Moolenaarcaf73dc2020-10-26 21:39:13 +01005116 if (*p == NUL) // stop at NUL after CTRL-V
5117 break;
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005118 }
5119#endif
5120
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005121 // Check for '"': start of comment or '|': next command
5122 // :@" and :*" do not start a comment!
5123 // :redir @" doesn't either.
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02005124 else if ((*p == '"'
Bram Moolenaara26b9702020-04-18 19:53:28 +02005125#ifdef FEAT_EVAL
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02005126 && !in_vim9script()
5127#endif
5128 && !(eap->argt & EX_NOTRLCOM)
5129 && ((eap->cmdidx != CMD_at && eap->cmdidx != CMD_star)
5130 || p != eap->arg)
5131 && (eap->cmdidx != CMD_redir
5132 || p != eap->arg + 1 || p[-1] != '@'))
5133#ifdef FEAT_EVAL
5134 || (*p == '#'
5135 && in_vim9script()
Bram Moolenaarb8a92962020-08-20 18:02:47 +02005136 && !(eap->argt & EX_NOTRLCOM)
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02005137 && p > eap->cmd && VIM_ISWHITE(p[-1]))
Bram Moolenaara26b9702020-04-18 19:53:28 +02005138#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005139 || *p == '|' || *p == '\n')
5140 {
5141 /*
Bram Moolenaar8071cb22019-07-12 17:58:01 +02005142 * We remove the '\' before the '|', unless EX_CTRLV is used
Bram Moolenaar071d4272004-06-13 20:20:40 +00005143 * AND 'b' is present in 'cpoptions'.
5144 */
5145 if ((vim_strchr(p_cpo, CPO_BAR) == NULL
Bram Moolenaar8071cb22019-07-12 17:58:01 +02005146 || !(eap->argt & EX_CTRLV)) && *(p - 1) == '\\')
Bram Moolenaar071d4272004-06-13 20:20:40 +00005147 {
Bram Moolenaarac485062022-03-23 19:45:01 +00005148 if (!keep_backslash)
5149 {
5150 STRMOVE(p - 1, p); // remove the '\'
5151 --p;
5152 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00005153 }
5154 else
5155 {
5156 eap->nextcmd = check_nextcmd(p);
5157 *p = NUL;
5158 break;
5159 }
5160 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00005161 }
Bram Moolenaar86b68352004-12-27 21:59:20 +00005162
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005163 if (!(eap->argt & EX_NOTRLCOM)) // remove trailing spaces
Bram Moolenaar071d4272004-06-13 20:20:40 +00005164 del_trailing_spaces(eap->arg);
5165}
5166
5167/*
5168 * get + command from ex argument
5169 */
5170 static char_u *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005171getargcmd(char_u **argp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005172{
5173 char_u *arg = *argp;
5174 char_u *command = NULL;
5175
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005176 if (*arg == '+') // +[command]
Bram Moolenaar071d4272004-06-13 20:20:40 +00005177 {
5178 ++arg;
Bram Moolenaar3e451592014-04-02 14:22:05 +02005179 if (vim_isspace(*arg) || *arg == NUL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005180 command = dollar_command;
5181 else
5182 {
5183 command = arg;
5184 arg = skip_cmd_arg(command, TRUE);
5185 if (*arg != NUL)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005186 *arg++ = NUL; // terminate command with NUL
Bram Moolenaar071d4272004-06-13 20:20:40 +00005187 }
5188
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005189 arg = skipwhite(arg); // skip over spaces
Bram Moolenaar071d4272004-06-13 20:20:40 +00005190 *argp = arg;
5191 }
5192 return command;
5193}
5194
5195/*
5196 * Find end of "+command" argument. Skip over "\ " and "\\".
5197 */
Bram Moolenaard0190392019-08-23 21:17:35 +02005198 char_u *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005199skip_cmd_arg(
5200 char_u *p,
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005201 int rembs) // TRUE to halve the number of backslashes
Bram Moolenaar071d4272004-06-13 20:20:40 +00005202{
5203 while (*p && !vim_isspace(*p))
5204 {
5205 if (*p == '\\' && p[1] != NUL)
5206 {
5207 if (rembs)
Bram Moolenaara7241f52008-06-24 20:39:31 +00005208 STRMOVE(p, p + 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005209 else
5210 ++p;
5211 }
Bram Moolenaar91acfff2017-03-12 19:22:36 +01005212 MB_PTR_ADV(p);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005213 }
5214 return p;
5215}
5216
Bram Moolenaar333b80a2018-04-04 22:57:29 +02005217 int
5218get_bad_opt(char_u *p, exarg_T *eap)
5219{
5220 if (STRICMP(p, "keep") == 0)
5221 eap->bad_char = BAD_KEEP;
5222 else if (STRICMP(p, "drop") == 0)
5223 eap->bad_char = BAD_DROP;
5224 else if (MB_BYTE2LEN(*p) == 1 && p[1] == NUL)
5225 eap->bad_char = *p;
Bram Moolenaar75808492018-06-12 12:39:41 +02005226 else
5227 return FAIL;
5228 return OK;
Bram Moolenaar333b80a2018-04-04 22:57:29 +02005229}
5230
Bram Moolenaar071d4272004-06-13 20:20:40 +00005231/*
5232 * Get "++opt=arg" argument.
5233 * Return FAIL or OK.
5234 */
5235 static int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005236getargopt(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005237{
5238 char_u *arg = eap->arg + 2;
5239 int *pp = NULL;
Bram Moolenaar34b4daf2010-05-16 13:26:25 +02005240 int bad_char_idx;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005241 char_u *p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005242
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005243 // ":edit ++[no]bin[ary] file"
Bram Moolenaar071d4272004-06-13 20:20:40 +00005244 if (STRNCMP(arg, "bin", 3) == 0 || STRNCMP(arg, "nobin", 5) == 0)
5245 {
5246 if (*arg == 'n')
5247 {
5248 arg += 2;
5249 eap->force_bin = FORCE_NOBIN;
5250 }
5251 else
5252 eap->force_bin = FORCE_BIN;
5253 if (!checkforcmd(&arg, "binary", 3))
5254 return FAIL;
5255 eap->arg = skipwhite(arg);
5256 return OK;
5257 }
5258
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005259 // ":read ++edit file"
Bram Moolenaar910f66f2006-04-05 20:41:53 +00005260 if (STRNCMP(arg, "edit", 4) == 0)
5261 {
5262 eap->read_edit = TRUE;
5263 eap->arg = skipwhite(arg + 4);
5264 return OK;
5265 }
5266
Bram Moolenaar071d4272004-06-13 20:20:40 +00005267 if (STRNCMP(arg, "ff", 2) == 0)
5268 {
5269 arg += 2;
5270 pp = &eap->force_ff;
5271 }
5272 else if (STRNCMP(arg, "fileformat", 10) == 0)
5273 {
5274 arg += 10;
5275 pp = &eap->force_ff;
5276 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00005277 else if (STRNCMP(arg, "enc", 3) == 0)
5278 {
Bram Moolenaarb38e9ab2011-12-14 14:49:45 +01005279 if (STRNCMP(arg, "encoding", 8) == 0)
5280 arg += 8;
5281 else
5282 arg += 3;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005283 pp = &eap->force_enc;
5284 }
Bram Moolenaarb0bf8582005-12-13 20:02:15 +00005285 else if (STRNCMP(arg, "bad", 3) == 0)
5286 {
5287 arg += 3;
Bram Moolenaar34b4daf2010-05-16 13:26:25 +02005288 pp = &bad_char_idx;
Bram Moolenaarb0bf8582005-12-13 20:02:15 +00005289 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00005290
5291 if (pp == NULL || *arg != '=')
5292 return FAIL;
5293
5294 ++arg;
5295 *pp = (int)(arg - eap->cmd);
5296 arg = skip_cmd_arg(arg, FALSE);
5297 eap->arg = skipwhite(arg);
5298 *arg = NUL;
5299
Bram Moolenaar071d4272004-06-13 20:20:40 +00005300 if (pp == &eap->force_ff)
5301 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00005302 if (check_ff_value(eap->cmd + eap->force_ff) == FAIL)
5303 return FAIL;
Bram Moolenaar333b80a2018-04-04 22:57:29 +02005304 eap->force_ff = eap->cmd[eap->force_ff];
Bram Moolenaar071d4272004-06-13 20:20:40 +00005305 }
Bram Moolenaarb0bf8582005-12-13 20:02:15 +00005306 else if (pp == &eap->force_enc)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005307 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005308 // Make 'fileencoding' lower case.
Bram Moolenaar071d4272004-06-13 20:20:40 +00005309 for (p = eap->cmd + eap->force_enc; *p != NUL; ++p)
5310 *p = TOLOWER_ASC(*p);
5311 }
Bram Moolenaarb0bf8582005-12-13 20:02:15 +00005312 else
5313 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005314 // Check ++bad= argument. Must be a single-byte character, "keep" or
5315 // "drop".
Bram Moolenaar333b80a2018-04-04 22:57:29 +02005316 if (get_bad_opt(eap->cmd + bad_char_idx, eap) == FAIL)
Bram Moolenaarb0bf8582005-12-13 20:02:15 +00005317 return FAIL;
5318 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00005319
5320 return OK;
5321}
5322
Bram Moolenaar071d4272004-06-13 20:20:40 +00005323 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005324ex_autocmd(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005325{
5326 /*
Bram Moolenaar26d4b892018-07-04 22:26:28 +02005327 * Disallow autocommands from .exrc and .vimrc in current
Bram Moolenaar071d4272004-06-13 20:20:40 +00005328 * directory for security reasons.
5329 */
5330 if (secure)
5331 {
5332 secure = 2;
Bram Moolenaar108010a2021-06-27 22:03:33 +02005333 eap->errmsg =
5334 _(e_command_not_allowed_from_vimrc_in_current_dir_or_tag_search);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005335 }
5336 else if (eap->cmdidx == CMD_autocmd)
Bram Moolenaar73b8b0a2021-08-01 14:52:32 +02005337 do_autocmd(eap, eap->arg, eap->forceit);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005338 else
5339 do_augroup(eap->arg, eap->forceit);
5340}
5341
5342/*
5343 * ":doautocmd": Apply the automatic commands to the current buffer.
5344 */
5345 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005346ex_doautocmd(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005347{
Bram Moolenaar60542ac2012-02-12 20:14:01 +01005348 char_u *arg = eap->arg;
5349 int call_do_modelines = check_nomodeline(&arg);
Bram Moolenaar1610d052016-06-09 22:53:01 +02005350 int did_aucmd;
Bram Moolenaar60542ac2012-02-12 20:14:01 +01005351
Bram Moolenaar1610d052016-06-09 22:53:01 +02005352 (void)do_doautocmd(arg, TRUE, &did_aucmd);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005353 // Only when there is no <nomodeline>.
Bram Moolenaar1610d052016-06-09 22:53:01 +02005354 if (call_do_modelines && did_aucmd)
Bram Moolenaar60542ac2012-02-12 20:14:01 +01005355 do_modelines(0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005356}
Bram Moolenaar071d4272004-06-13 20:20:40 +00005357
Bram Moolenaar071d4272004-06-13 20:20:40 +00005358/*
5359 * :[N]bunload[!] [N] [bufname] unload buffer
5360 * :[N]bdelete[!] [N] [bufname] delete buffer from buffer list
5361 * :[N]bwipeout[!] [N] [bufname] delete buffer really
5362 */
5363 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005364ex_bunload(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005365{
Bram Moolenaar3c01c4a2020-02-01 23:04:24 +01005366 if (ERROR_IF_ANY_POPUP_WINDOW)
Bram Moolenaar815b76b2019-06-01 14:15:52 +02005367 return;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005368 eap->errmsg = do_bufdel(
5369 eap->cmdidx == CMD_bdelete ? DOBUF_DEL
5370 : eap->cmdidx == CMD_bwipeout ? DOBUF_WIPE
5371 : DOBUF_UNLOAD, eap->arg,
5372 eap->addr_count, (int)eap->line1, (int)eap->line2, eap->forceit);
5373}
5374
5375/*
5376 * :[N]buffer [N] to buffer N
5377 * :[N]sbuffer [N] to buffer N
5378 */
5379 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005380ex_buffer(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005381{
Bram Moolenaar3c01c4a2020-02-01 23:04:24 +01005382 if (ERROR_IF_ANY_POPUP_WINDOW)
Bram Moolenaar815b76b2019-06-01 14:15:52 +02005383 return;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005384 if (*eap->arg)
Bram Moolenaar74409f62022-01-01 15:58:22 +00005385 eap->errmsg = ex_errmsg(e_trailing_characters_str, eap->arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005386 else
5387 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005388 if (eap->addr_count == 0) // default is current buffer
Bram Moolenaar071d4272004-06-13 20:20:40 +00005389 goto_buffer(eap, DOBUF_CURRENT, FORWARD, 0);
5390 else
5391 goto_buffer(eap, DOBUF_FIRST, FORWARD, (int)eap->line2);
Bram Moolenaar9c8d9e12014-09-19 20:07:26 +02005392 if (eap->do_ecmd_cmd != NULL)
Bram Moolenaar47a2abf2020-11-25 20:12:11 +01005393 do_cmd_argument(eap->do_ecmd_cmd);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005394 }
5395}
5396
5397/*
5398 * :[N]bmodified [N] to next mod. buffer
5399 * :[N]sbmodified [N] to next mod. buffer
5400 */
5401 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005402ex_bmodified(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005403{
5404 goto_buffer(eap, DOBUF_MOD, FORWARD, (int)eap->line2);
Bram Moolenaar9c8d9e12014-09-19 20:07:26 +02005405 if (eap->do_ecmd_cmd != NULL)
Bram Moolenaar47a2abf2020-11-25 20:12:11 +01005406 do_cmd_argument(eap->do_ecmd_cmd);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005407}
5408
5409/*
5410 * :[N]bnext [N] to next buffer
5411 * :[N]sbnext [N] split and to next buffer
5412 */
5413 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005414ex_bnext(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005415{
Bram Moolenaar3c01c4a2020-02-01 23:04:24 +01005416 if (ERROR_IF_ANY_POPUP_WINDOW)
Bram Moolenaar3029bcc2020-01-18 15:06:19 +01005417 return;
5418
Bram Moolenaar071d4272004-06-13 20:20:40 +00005419 goto_buffer(eap, DOBUF_CURRENT, FORWARD, (int)eap->line2);
Bram Moolenaar9c8d9e12014-09-19 20:07:26 +02005420 if (eap->do_ecmd_cmd != NULL)
Bram Moolenaar47a2abf2020-11-25 20:12:11 +01005421 do_cmd_argument(eap->do_ecmd_cmd);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005422}
5423
5424/*
5425 * :[N]bNext [N] to previous buffer
5426 * :[N]bprevious [N] to previous buffer
5427 * :[N]sbNext [N] split and to previous buffer
5428 * :[N]sbprevious [N] split and to previous buffer
5429 */
5430 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005431ex_bprevious(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005432{
Bram Moolenaar3c01c4a2020-02-01 23:04:24 +01005433 if (ERROR_IF_ANY_POPUP_WINDOW)
Bram Moolenaar3029bcc2020-01-18 15:06:19 +01005434 return;
5435
Bram Moolenaar071d4272004-06-13 20:20:40 +00005436 goto_buffer(eap, DOBUF_CURRENT, BACKWARD, (int)eap->line2);
Bram Moolenaar9c8d9e12014-09-19 20:07:26 +02005437 if (eap->do_ecmd_cmd != NULL)
Bram Moolenaar47a2abf2020-11-25 20:12:11 +01005438 do_cmd_argument(eap->do_ecmd_cmd);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005439}
5440
5441/*
5442 * :brewind to first buffer
5443 * :bfirst to first buffer
5444 * :sbrewind split and to first buffer
5445 * :sbfirst split and to first buffer
5446 */
5447 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005448ex_brewind(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005449{
Bram Moolenaar3c01c4a2020-02-01 23:04:24 +01005450 if (ERROR_IF_ANY_POPUP_WINDOW)
Bram Moolenaar3029bcc2020-01-18 15:06:19 +01005451 return;
5452
Bram Moolenaar071d4272004-06-13 20:20:40 +00005453 goto_buffer(eap, DOBUF_FIRST, FORWARD, 0);
Bram Moolenaar9c8d9e12014-09-19 20:07:26 +02005454 if (eap->do_ecmd_cmd != NULL)
Bram Moolenaar47a2abf2020-11-25 20:12:11 +01005455 do_cmd_argument(eap->do_ecmd_cmd);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005456}
5457
5458/*
5459 * :blast to last buffer
5460 * :sblast split and to last buffer
5461 */
5462 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005463ex_blast(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005464{
Bram Moolenaar3c01c4a2020-02-01 23:04:24 +01005465 if (ERROR_IF_ANY_POPUP_WINDOW)
Bram Moolenaar3029bcc2020-01-18 15:06:19 +01005466 return;
5467
Bram Moolenaar071d4272004-06-13 20:20:40 +00005468 goto_buffer(eap, DOBUF_LAST, BACKWARD, 0);
Bram Moolenaar9c8d9e12014-09-19 20:07:26 +02005469 if (eap->do_ecmd_cmd != NULL)
Bram Moolenaar47a2abf2020-11-25 20:12:11 +01005470 do_cmd_argument(eap->do_ecmd_cmd);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005471}
Bram Moolenaar071d4272004-06-13 20:20:40 +00005472
Bram Moolenaar7a092242020-04-16 22:10:49 +02005473/*
5474 * Check if "c" ends an Ex command.
Bram Moolenaarb5b94802020-12-13 17:50:20 +01005475 * In Vim9 script does not check for white space before #.
Bram Moolenaar7a092242020-04-16 22:10:49 +02005476 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005477 int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005478ends_excmd(int c)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005479{
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02005480 int comment_char = '"';
5481
Bram Moolenaarfbda69b2020-04-13 15:06:53 +02005482#ifdef FEAT_EVAL
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02005483 if (in_vim9script())
5484 comment_char = '#';
Bram Moolenaar7a092242020-04-16 22:10:49 +02005485#endif
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02005486 return (c == NUL || c == '|' || c == comment_char || c == '\n');
Bram Moolenaar7a092242020-04-16 22:10:49 +02005487}
5488
5489/*
5490 * Like ends_excmd() but checks that a # in Vim9 script either has "cmd" equal
5491 * to "cmd_start" or has a white space character before it.
5492 */
5493 int
Bram Moolenaar21cfe502020-04-16 23:01:50 +02005494ends_excmd2(char_u *cmd_start UNUSED, char_u *cmd)
Bram Moolenaar7a092242020-04-16 22:10:49 +02005495{
5496 int c = *cmd;
5497
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02005498 if (c == NUL || c == '|' || c == '\n')
5499 return TRUE;
Bram Moolenaar7a092242020-04-16 22:10:49 +02005500#ifdef FEAT_EVAL
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02005501 if (in_vim9script())
Bram Moolenaara0399ef2021-03-20 15:00:01 +01005502 // # starts a comment, #{ might be a mistake, #{{ can start a fold
5503 return c == '#' && (cmd[1] != '{' || cmd[2] == '{')
Bram Moolenaar5c7a2992021-03-20 13:29:38 +01005504 && (cmd == cmd_start || VIM_ISWHITE(cmd[-1]));
Bram Moolenaarfbda69b2020-04-13 15:06:53 +02005505#endif
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02005506 return c == '"';
Bram Moolenaar071d4272004-06-13 20:20:40 +00005507}
5508
5509#if defined(FEAT_SYN_HL) || defined(FEAT_SEARCH_EXTRA) || defined(FEAT_EVAL) \
5510 || defined(PROTO)
5511/*
5512 * Return the next command, after the first '|' or '\n'.
5513 * Return NULL if not found.
5514 */
5515 char_u *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005516find_nextcmd(char_u *p)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005517{
5518 while (*p != '|' && *p != '\n')
5519 {
5520 if (*p == NUL)
5521 return NULL;
5522 ++p;
5523 }
5524 return (p + 1);
5525}
5526#endif
5527
5528/*
Bram Moolenaar2256c992016-11-15 21:17:07 +01005529 * Check if *p is a separator between Ex commands, skipping over white space.
5530 * Return NULL if it isn't, the following character if it is.
Bram Moolenaar071d4272004-06-13 20:20:40 +00005531 */
5532 char_u *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005533check_nextcmd(char_u *p)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005534{
Bram Moolenaar2256c992016-11-15 21:17:07 +01005535 char_u *s = skipwhite(p);
5536
5537 if (*s == '|' || *s == '\n')
5538 return (s + 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005539 else
5540 return NULL;
5541}
5542
5543/*
Bram Moolenaar63b91732021-08-05 20:40:03 +02005544 * If "eap->nextcmd" is not set, check for a next command at "p".
5545 */
5546 void
5547set_nextcmd(exarg_T *eap, char_u *arg)
5548{
5549 char_u *p = check_nextcmd(arg);
5550
5551 if (eap->nextcmd == NULL)
5552 eap->nextcmd = p;
5553 else if (p != NULL)
5554 // cannot use "| command" inside a {} block
5555 semsg(_(e_cannot_use_bar_to_separate_commands_here_str), arg);
5556}
5557
5558/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00005559 * - if there are more files to edit
5560 * - and this is the last window
5561 * - and forceit not used
5562 * - and not repeated twice on a row
5563 * return FAIL and give error message if 'message' TRUE
5564 * return OK otherwise
5565 */
5566 static int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005567check_more(
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005568 int message, // when FALSE check only, no messages
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005569 int forceit)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005570{
5571 int n = ARGCOUNT - curwin->w_arg_idx - 1;
5572
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00005573 if (!forceit && only_one_window()
Bram Moolenaar7b221172020-08-17 19:34:10 +02005574 && ARGCOUNT > 1 && !arg_had_last && n > 0 && quitmore == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005575 {
5576 if (message)
5577 {
5578#if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
Bram Moolenaare1004402020-10-24 20:49:43 +02005579 if ((p_confirm || (cmdmod.cmod_flags & CMOD_CONFIRM))
5580 && curbuf->b_fname != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005581 {
Bram Moolenaard9462e32011-04-11 21:35:11 +02005582 char_u buff[DIALOG_MSG_SIZE];
Bram Moolenaar071d4272004-06-13 20:20:40 +00005583
Bram Moolenaarda6e8912018-08-21 15:12:14 +02005584 vim_snprintf((char *)buff, DIALOG_MSG_SIZE,
5585 NGETTEXT("%d more file to edit. Quit anyway?",
5586 "%d more files to edit. Quit anyway?", n), n);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005587 if (vim_dialog_yesno(VIM_QUESTION, NULL, buff, 1) == VIM_YES)
5588 return OK;
5589 return FAIL;
5590 }
5591#endif
Bram Moolenaar1a992222021-12-31 17:25:48 +00005592 semsg(NGETTEXT(e_nr_more_file_to_edit,
5593 e_nr_more_files_to_edit , n), n);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005594 quitmore = 2; // next try to quit is allowed
Bram Moolenaar071d4272004-06-13 20:20:40 +00005595 }
5596 return FAIL;
5597 }
5598 return OK;
5599}
5600
Bram Moolenaar071d4272004-06-13 20:20:40 +00005601/*
5602 * Function given to ExpandGeneric() to obtain the list of command names.
5603 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005604 char_u *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005605get_command_name(expand_T *xp UNUSED, int idx)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005606{
5607 if (idx >= (int)CMD_SIZE)
Bram Moolenaar80c88ea2021-09-08 14:29:46 +02005608 return expand_user_command_name(idx);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005609 return cmdnames[idx].cmd_name;
5610}
Bram Moolenaar071d4272004-06-13 20:20:40 +00005611
Bram Moolenaar071d4272004-06-13 20:20:40 +00005612 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005613ex_colorscheme(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005614{
Bram Moolenaare6850792010-05-14 15:28:44 +02005615 if (*eap->arg == NUL)
5616 {
5617#ifdef FEAT_EVAL
5618 char_u *expr = vim_strsave((char_u *)"g:colors_name");
5619 char_u *p = NULL;
5620
5621 if (expr != NULL)
5622 {
5623 ++emsg_off;
Bram Moolenaarb171fb12020-06-24 20:34:03 +02005624 p = eval_to_string(expr, FALSE);
Bram Moolenaare6850792010-05-14 15:28:44 +02005625 --emsg_off;
5626 vim_free(expr);
5627 }
5628 if (p != NULL)
5629 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01005630 msg((char *)p);
Bram Moolenaare6850792010-05-14 15:28:44 +02005631 vim_free(p);
5632 }
5633 else
Bram Moolenaar32526b32019-01-19 17:43:09 +01005634 msg("default");
Bram Moolenaare6850792010-05-14 15:28:44 +02005635#else
Bram Moolenaar32526b32019-01-19 17:43:09 +01005636 msg(_("unknown"));
Bram Moolenaare6850792010-05-14 15:28:44 +02005637#endif
5638 }
5639 else if (load_colors(eap->arg) == FAIL)
Bram Moolenaar1a992222021-12-31 17:25:48 +00005640 semsg(_(e_cannot_find_color_scheme_str), eap->arg);
Bram Moolenaarf58d81a2019-01-28 20:19:05 +01005641
5642#ifdef FEAT_VTP
5643 else if (has_vtp_working())
5644 {
5645 // background color change requires clear + redraw
5646 update_screen(CLEAR);
5647 redrawcmd();
5648 }
5649#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005650}
5651
5652 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005653ex_highlight(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005654{
5655 if (*eap->arg == NUL && eap->cmd[2] == '!')
Bram Moolenaar32526b32019-01-19 17:43:09 +01005656 msg(_("Greetings, Vim user!"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00005657 do_highlight(eap->arg, eap->forceit, FALSE);
5658}
5659
5660
5661/*
5662 * Call this function if we thought we were going to exit, but we won't
5663 * (because of an error). May need to restore the terminal mode.
5664 */
5665 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005666not_exiting(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005667{
5668 exiting = FALSE;
5669 settmode(TMODE_RAW);
5670}
5671
Bram Moolenaar3552e742021-05-29 12:21:58 +02005672 int
Bram Moolenaar12a96de2018-03-11 14:44:18 +01005673before_quit_autocmds(win_T *wp, int quit_all, int forceit)
5674{
5675 apply_autocmds(EVENT_QUITPRE, NULL, NULL, FALSE, wp->w_buffer);
5676
Bram Moolenaar34ba06b2019-10-20 22:27:10 +02005677 // Bail out when autocommands closed the window.
5678 // Refuse to quit when the buffer in the last window is being closed (can
5679 // only happen in autocommands).
Bram Moolenaar12a96de2018-03-11 14:44:18 +01005680 if (!win_valid(wp)
5681 || curbuf_locked()
5682 || (wp->w_buffer->b_nwindows == 1 && wp->w_buffer->b_locked > 0))
5683 return TRUE;
5684
5685 if (quit_all || (check_more(FALSE, forceit) == OK && only_one_window()))
5686 {
5687 apply_autocmds(EVENT_EXITPRE, NULL, NULL, FALSE, curbuf);
Bram Moolenaar34ba06b2019-10-20 22:27:10 +02005688 // Refuse to quit when locked or when the window was closed or the
5689 // buffer in the last window is being closed (can only happen in
5690 // autocommands).
5691 if (!win_valid(wp) || curbuf_locked()
Bram Moolenaar12a96de2018-03-11 14:44:18 +01005692 || (curbuf->b_nwindows == 1 && curbuf->b_locked > 0))
5693 return TRUE;
5694 }
5695
5696 return FALSE;
5697}
5698
Bram Moolenaar071d4272004-06-13 20:20:40 +00005699/*
Bram Moolenaarf240e182014-11-27 18:33:02 +01005700 * ":quit": quit current window, quit Vim if the last window is closed.
Bram Moolenaar12a96de2018-03-11 14:44:18 +01005701 * ":{nr}quit": quit window {nr}
Bram Moolenaar4d14bac2019-10-20 21:15:15 +02005702 * Also used when closing a terminal window that's the last one.
Bram Moolenaar071d4272004-06-13 20:20:40 +00005703 */
Bram Moolenaar4d14bac2019-10-20 21:15:15 +02005704 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005705ex_quit(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005706{
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01005707 win_T *wp;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01005708
Bram Moolenaar071d4272004-06-13 20:20:40 +00005709#ifdef FEAT_CMDWIN
5710 if (cmdwin_type != 0)
5711 {
5712 cmdwin_result = Ctrl_C;
5713 return;
5714 }
5715#endif
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005716 // Don't quit while editing the command line.
Bram Moolenaar2d3f4892006-01-20 23:02:51 +00005717 if (text_locked())
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00005718 {
Bram Moolenaar2d3f4892006-01-20 23:02:51 +00005719 text_locked_msg();
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00005720 return;
5721 }
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01005722 if (eap->addr_count > 0)
5723 {
Bram Moolenaarf240e182014-11-27 18:33:02 +01005724 int wnr = eap->line2;
5725
5726 for (wp = firstwin; wp->w_next != NULL; wp = wp->w_next)
5727 if (--wnr <= 0)
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01005728 break;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01005729 }
5730 else
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01005731 wp = curwin;
Bram Moolenaarf240e182014-11-27 18:33:02 +01005732
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005733 // Refuse to quit when locked.
Bram Moolenaar87ffb5c2017-10-19 12:37:42 +02005734 if (curbuf_locked())
5735 return;
Bram Moolenaar12a96de2018-03-11 14:44:18 +01005736
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005737 // Trigger QuitPre and maybe ExitPre
Bram Moolenaar12a96de2018-03-11 14:44:18 +01005738 if (before_quit_autocmds(wp, FALSE, eap->forceit))
Bram Moolenaar910f66f2006-04-05 20:41:53 +00005739 return;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005740
5741#ifdef FEAT_NETBEANS_INTG
5742 netbeansForcedQuit = eap->forceit;
5743#endif
5744
5745 /*
Bram Moolenaar3552e742021-05-29 12:21:58 +02005746 * If there is only one relevant window we will exit.
Bram Moolenaar071d4272004-06-13 20:20:40 +00005747 */
5748 if (check_more(FALSE, eap->forceit) == OK && only_one_window())
5749 exiting = TRUE;
Bram Moolenaarff930ca2017-10-19 17:12:10 +02005750 if ((!buf_hide(wp->w_buffer)
5751 && check_changed(wp->w_buffer, (p_awa ? CCGD_AW : 0)
Bram Moolenaar45d3b142013-11-09 03:31:51 +01005752 | (eap->forceit ? CCGD_FORCEIT : 0)
5753 | CCGD_EXCMD))
Bram Moolenaar071d4272004-06-13 20:20:40 +00005754 || check_more(TRUE, eap->forceit) == FAIL
Bram Moolenaar027387f2016-01-02 22:25:52 +01005755 || (only_one_window() && check_changed_any(eap->forceit, TRUE)))
Bram Moolenaar071d4272004-06-13 20:20:40 +00005756 {
5757 not_exiting();
5758 }
5759 else
5760 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005761 // quit last window
5762 // Note: only_one_window() returns true, even so a help window is
5763 // still open. In that case only quit, if no address has been
5764 // specified. Example:
5765 // :h|wincmd w|1q - don't quit
5766 // :h|wincmd w|q - quit
Bram Moolenaara1f4cb92016-11-06 15:25:42 +01005767 if (only_one_window() && (ONE_WINDOW || eap->addr_count == 0))
Bram Moolenaar071d4272004-06-13 20:20:40 +00005768 getout(0);
Bram Moolenaar2c33d7b2017-10-14 16:06:20 +02005769 not_exiting();
Bram Moolenaar4033c552017-09-16 20:54:51 +02005770#ifdef FEAT_GUI
Bram Moolenaar071d4272004-06-13 20:20:40 +00005771 need_mouse_correct = TRUE;
Bram Moolenaar4033c552017-09-16 20:54:51 +02005772#endif
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005773 // close window; may free buffer
Bram Moolenaareb44a682017-08-03 22:44:55 +02005774 win_close(wp, !buf_hide(wp->w_buffer) || eap->forceit);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005775 }
5776}
5777
5778/*
5779 * ":cquit".
5780 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005781 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005782ex_cquit(exarg_T *eap UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005783{
Bram Moolenaar1860bde2020-01-06 21:47:21 +01005784 // this does not always pass on the exit code to the Manx compiler. why?
5785 getout(eap->addr_count > 0 ? (int)eap->line2 : EXIT_FAILURE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005786}
5787
5788/*
5789 * ":qall": try to quit all windows
5790 */
5791 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005792ex_quit_all(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005793{
5794# ifdef FEAT_CMDWIN
5795 if (cmdwin_type != 0)
5796 {
5797 if (eap->forceit)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005798 cmdwin_result = K_XF1; // ex_window() takes care of this
Bram Moolenaar071d4272004-06-13 20:20:40 +00005799 else
5800 cmdwin_result = K_XF2;
5801 return;
5802 }
5803# endif
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00005804
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005805 // Don't quit while editing the command line.
Bram Moolenaar2d3f4892006-01-20 23:02:51 +00005806 if (text_locked())
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00005807 {
Bram Moolenaar2d3f4892006-01-20 23:02:51 +00005808 text_locked_msg();
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00005809 return;
5810 }
Bram Moolenaar12a96de2018-03-11 14:44:18 +01005811
5812 if (before_quit_autocmds(curwin, TRUE, eap->forceit))
Bram Moolenaar910f66f2006-04-05 20:41:53 +00005813 return;
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00005814
Bram Moolenaar071d4272004-06-13 20:20:40 +00005815 exiting = TRUE;
Bram Moolenaar027387f2016-01-02 22:25:52 +01005816 if (eap->forceit || !check_changed_any(FALSE, FALSE))
Bram Moolenaar071d4272004-06-13 20:20:40 +00005817 getout(0);
5818 not_exiting();
5819}
5820
Bram Moolenaar071d4272004-06-13 20:20:40 +00005821/*
5822 * ":close": close current window, unless it is the last one
5823 */
5824 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005825ex_close(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005826{
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01005827 win_T *win;
5828 int winnr = 0;
Bram Moolenaar4033c552017-09-16 20:54:51 +02005829#ifdef FEAT_CMDWIN
Bram Moolenaar071d4272004-06-13 20:20:40 +00005830 if (cmdwin_type != 0)
Bram Moolenaar9bd1a7e2011-05-19 14:50:54 +02005831 cmdwin_result = Ctrl_C;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005832 else
Bram Moolenaar4033c552017-09-16 20:54:51 +02005833#endif
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01005834 if (!text_locked() && !curbuf_locked())
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01005835 {
5836 if (eap->addr_count == 0)
5837 ex_win_close(eap->forceit, curwin, NULL);
Bram Moolenaar6d41c782018-06-06 09:11:12 +02005838 else
5839 {
Bram Moolenaar29323592016-07-24 22:04:11 +02005840 FOR_ALL_WINDOWS(win)
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01005841 {
5842 winnr++;
5843 if (winnr == eap->line2)
5844 break;
5845 }
5846 if (win == NULL)
5847 win = lastwin;
5848 ex_win_close(eap->forceit, win, NULL);
5849 }
5850 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00005851}
5852
Bram Moolenaar4033c552017-09-16 20:54:51 +02005853#ifdef FEAT_QUICKFIX
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00005854/*
5855 * ":pclose": Close any preview window.
5856 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005857 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005858ex_pclose(exarg_T *eap)
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00005859{
5860 win_T *win;
5861
Bram Moolenaar79648732019-07-18 21:43:07 +02005862 // First close any normal window.
Bram Moolenaar29323592016-07-24 22:04:11 +02005863 FOR_ALL_WINDOWS(win)
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00005864 if (win->w_p_pvw)
5865 {
Bram Moolenaarf740b292006-02-16 22:11:02 +00005866 ex_win_close(eap->forceit, win, NULL);
Bram Moolenaar79648732019-07-18 21:43:07 +02005867 return;
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00005868 }
Bram Moolenaar05ad5ff2019-11-30 22:48:27 +01005869# ifdef FEAT_PROP_POPUP
Bram Moolenaar79648732019-07-18 21:43:07 +02005870 // Also when 'previewpopup' is empty, it might have been cleared.
Bram Moolenaarc7c5f102019-08-21 18:31:03 +02005871 popup_close_preview();
Bram Moolenaar79648732019-07-18 21:43:07 +02005872# endif
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00005873}
Bram Moolenaar4033c552017-09-16 20:54:51 +02005874#endif
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00005875
Bram Moolenaarf740b292006-02-16 22:11:02 +00005876/*
5877 * Close window "win" and take care of handling closing the last window for a
5878 * modified buffer.
5879 */
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00005880 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005881ex_win_close(
5882 int forceit,
5883 win_T *win,
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005884 tabpage_T *tp) // NULL or the tab page "win" is in
Bram Moolenaar071d4272004-06-13 20:20:40 +00005885{
5886 int need_hide;
5887 buf_T *buf = win->w_buffer;
5888
Bram Moolenaarcf844172020-06-26 19:44:06 +02005889 // Never close the autocommand window.
5890 if (win == aucmd_win)
5891 {
Bram Moolenaar74409f62022-01-01 15:58:22 +00005892 emsg(_(e_cannot_close_autocmd_or_popup_window));
Bram Moolenaarcf844172020-06-26 19:44:06 +02005893 return;
5894 }
5895
Bram Moolenaar071d4272004-06-13 20:20:40 +00005896 need_hide = (bufIsChanged(buf) && buf->b_nwindows <= 1);
Bram Moolenaareb44a682017-08-03 22:44:55 +02005897 if (need_hide && !buf_hide(buf) && !forceit)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005898 {
Bram Moolenaar4033c552017-09-16 20:54:51 +02005899#if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
Bram Moolenaare1004402020-10-24 20:49:43 +02005900 if ((p_confirm || (cmdmod.cmod_flags & CMOD_CONFIRM)) && p_write)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005901 {
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02005902 bufref_T bufref;
5903
5904 set_bufref(&bufref, buf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005905 dialog_changed(buf, FALSE);
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02005906 if (bufref_valid(&bufref) && bufIsChanged(buf))
Bram Moolenaar071d4272004-06-13 20:20:40 +00005907 return;
5908 need_hide = FALSE;
5909 }
5910 else
Bram Moolenaar4033c552017-09-16 20:54:51 +02005911#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005912 {
Bram Moolenaarf5be7cd2017-08-17 16:55:13 +02005913 no_write_message();
Bram Moolenaar071d4272004-06-13 20:20:40 +00005914 return;
5915 }
5916 }
5917
Bram Moolenaar4033c552017-09-16 20:54:51 +02005918#ifdef FEAT_GUI
Bram Moolenaar071d4272004-06-13 20:20:40 +00005919 need_mouse_correct = TRUE;
Bram Moolenaar4033c552017-09-16 20:54:51 +02005920#endif
Bram Moolenaarf740b292006-02-16 22:11:02 +00005921
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005922 // free buffer when not hiding it or when it's a scratch buffer
Bram Moolenaarf740b292006-02-16 22:11:02 +00005923 if (tp == NULL)
Bram Moolenaareb44a682017-08-03 22:44:55 +02005924 win_close(win, !need_hide && !buf_hide(buf));
Bram Moolenaarf740b292006-02-16 22:11:02 +00005925 else
Bram Moolenaareb44a682017-08-03 22:44:55 +02005926 win_close_othertab(win, !need_hide && !buf_hide(buf), tp);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005927}
5928
Bram Moolenaar071d4272004-06-13 20:20:40 +00005929/*
Bram Moolenaardea25702017-01-29 15:18:10 +01005930 * Handle the argument for a tabpage related ex command.
5931 * Returns a tabpage number.
5932 * When an error is encountered then eap->errmsg is set.
5933 */
5934 static int
5935get_tabpage_arg(exarg_T *eap)
5936{
5937 int tab_number;
5938 int unaccept_arg0 = (eap->cmdidx == CMD_tabmove) ? 0 : 1;
5939
5940 if (eap->arg && *eap->arg != NUL)
5941 {
5942 char_u *p = eap->arg;
5943 char_u *p_save;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005944 int relative = 0; // argument +N/-N means: go to N places to the
5945 // right/left relative to the current position.
Bram Moolenaardea25702017-01-29 15:18:10 +01005946
5947 if (*p == '-')
5948 {
5949 relative = -1;
5950 p++;
5951 }
5952 else if (*p == '+')
5953 {
5954 relative = 1;
5955 p++;
5956 }
5957
5958 p_save = p;
5959 tab_number = getdigits(&p);
5960
5961 if (relative == 0)
5962 {
5963 if (STRCMP(p, "$") == 0)
5964 tab_number = LAST_TAB_NR;
Bram Moolenaar94f4ffa2020-08-10 19:21:15 +02005965 else if (STRCMP(p, "#") == 0)
5966 if (valid_tabpage(lastused_tabpage))
5967 tab_number = tabpage_index(lastused_tabpage);
5968 else
5969 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00005970 eap->errmsg = ex_errmsg(e_invalid_value_for_argument_str, eap->arg);
Bram Moolenaar94f4ffa2020-08-10 19:21:15 +02005971 tab_number = 0;
5972 goto theend;
5973 }
Bram Moolenaardea25702017-01-29 15:18:10 +01005974 else if (p == p_save || *p_save == '-' || *p != NUL
5975 || tab_number > LAST_TAB_NR)
5976 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005977 // No numbers as argument.
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00005978 eap->errmsg = ex_errmsg(e_invalid_argument_str, eap->arg);
Bram Moolenaardea25702017-01-29 15:18:10 +01005979 goto theend;
5980 }
5981 }
5982 else
5983 {
5984 if (*p_save == NUL)
5985 tab_number = 1;
5986 else if (p == p_save || *p_save == '-' || *p != NUL
5987 || tab_number == 0)
5988 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005989 // No numbers as argument.
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00005990 eap->errmsg = ex_errmsg(e_invalid_argument_str, eap->arg);
Bram Moolenaardea25702017-01-29 15:18:10 +01005991 goto theend;
5992 }
5993 tab_number = tab_number * relative + tabpage_index(curtab);
5994 if (!unaccept_arg0 && relative == -1)
5995 --tab_number;
5996 }
5997 if (tab_number < unaccept_arg0 || tab_number > LAST_TAB_NR)
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00005998 eap->errmsg = ex_errmsg(e_invalid_argument_str, eap->arg);
Bram Moolenaardea25702017-01-29 15:18:10 +01005999 }
6000 else if (eap->addr_count > 0)
6001 {
6002 if (unaccept_arg0 && eap->line2 == 0)
Bram Moolenaarc6251552017-01-29 21:42:20 +01006003 {
Bram Moolenaar108010a2021-06-27 22:03:33 +02006004 eap->errmsg = _(e_invalid_range);
Bram Moolenaarc6251552017-01-29 21:42:20 +01006005 tab_number = 0;
6006 }
Bram Moolenaardea25702017-01-29 15:18:10 +01006007 else
6008 {
6009 tab_number = eap->line2;
Bram Moolenaar82a12462019-01-22 22:41:42 +01006010 if (!unaccept_arg0 && *skipwhite(*eap->cmdlinep) == '-')
Bram Moolenaardea25702017-01-29 15:18:10 +01006011 {
6012 --tab_number;
6013 if (tab_number < unaccept_arg0)
Bram Moolenaar108010a2021-06-27 22:03:33 +02006014 eap->errmsg = _(e_invalid_range);
Bram Moolenaardea25702017-01-29 15:18:10 +01006015 }
6016 }
6017 }
6018 else
6019 {
6020 switch (eap->cmdidx)
6021 {
6022 case CMD_tabnext:
6023 tab_number = tabpage_index(curtab) + 1;
6024 if (tab_number > LAST_TAB_NR)
6025 tab_number = 1;
6026 break;
6027 case CMD_tabmove:
6028 tab_number = LAST_TAB_NR;
6029 break;
6030 default:
6031 tab_number = tabpage_index(curtab);
6032 }
6033 }
6034
6035theend:
6036 return tab_number;
6037}
6038
6039/*
Bram Moolenaarf740b292006-02-16 22:11:02 +00006040 * ":tabclose": close current tab page, unless it is the last one.
6041 * ":tabclose N": close tab page N.
Bram Moolenaar071d4272004-06-13 20:20:40 +00006042 */
6043 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006044ex_tabclose(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006045{
Bram Moolenaarf740b292006-02-16 22:11:02 +00006046 tabpage_T *tp;
Bram Moolenaar2f72c702017-01-29 14:48:10 +01006047 int tab_number;
Bram Moolenaarf740b292006-02-16 22:11:02 +00006048
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006049# ifdef FEAT_CMDWIN
6050 if (cmdwin_type != 0)
6051 cmdwin_result = K_IGNORE;
6052 else
6053# endif
Bram Moolenaarf740b292006-02-16 22:11:02 +00006054 if (first_tabpage->tp_next == NULL)
Bram Moolenaar677658a2022-01-05 16:09:06 +00006055 emsg(_(e_cannot_close_last_tab_page));
Bram Moolenaarf740b292006-02-16 22:11:02 +00006056 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00006057 {
Bram Moolenaar2f72c702017-01-29 14:48:10 +01006058 tab_number = get_tabpage_arg(eap);
6059 if (eap->errmsg == NULL)
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006060 {
Bram Moolenaar2f72c702017-01-29 14:48:10 +01006061 tp = find_tabpage(tab_number);
Bram Moolenaarf740b292006-02-16 22:11:02 +00006062 if (tp == NULL)
6063 {
6064 beep_flush();
6065 return;
6066 }
Bram Moolenaar7e8fd632006-02-18 22:14:51 +00006067 if (tp != curtab)
Bram Moolenaarf740b292006-02-16 22:11:02 +00006068 {
6069 tabpage_close_other(tp, eap->forceit);
6070 return;
6071 }
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01006072 else if (!text_locked() && !curbuf_locked())
Bram Moolenaar2f72c702017-01-29 14:48:10 +01006073 tabpage_close(eap->forceit);
6074 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00006075 }
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00006076}
6077
6078/*
6079 * ":tabonly": close all tab pages except the current one
6080 */
6081 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006082ex_tabonly(exarg_T *eap)
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00006083{
6084 tabpage_T *tp;
6085 int done;
Bram Moolenaar2f72c702017-01-29 14:48:10 +01006086 int tab_number;
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00006087
6088# ifdef FEAT_CMDWIN
6089 if (cmdwin_type != 0)
6090 cmdwin_result = K_IGNORE;
6091 else
6092# endif
6093 if (first_tabpage->tp_next == NULL)
Bram Moolenaar32526b32019-01-19 17:43:09 +01006094 msg(_("Already only one tab page"));
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00006095 else
6096 {
Bram Moolenaar2f72c702017-01-29 14:48:10 +01006097 tab_number = get_tabpage_arg(eap);
6098 if (eap->errmsg == NULL)
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00006099 {
Bram Moolenaar2f72c702017-01-29 14:48:10 +01006100 goto_tabpage(tab_number);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006101 // Repeat this up to a 1000 times, because autocommands may
6102 // mess up the lists.
Bram Moolenaar2f72c702017-01-29 14:48:10 +01006103 for (done = 0; done < 1000; ++done)
6104 {
6105 FOR_ALL_TABPAGES(tp)
6106 if (tp->tp_topframe != topframe)
6107 {
6108 tabpage_close_other(tp, eap->forceit);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006109 // if we failed to close it quit
Bram Moolenaar2f72c702017-01-29 14:48:10 +01006110 if (valid_tabpage(tp))
6111 done = 1000;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006112 // start over, "tp" is now invalid
Bram Moolenaar2f72c702017-01-29 14:48:10 +01006113 break;
6114 }
6115 if (first_tabpage->tp_next == NULL)
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00006116 break;
Bram Moolenaar2f72c702017-01-29 14:48:10 +01006117 }
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00006118 }
6119 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00006120}
Bram Moolenaar071d4272004-06-13 20:20:40 +00006121
6122/*
Bram Moolenaarf740b292006-02-16 22:11:02 +00006123 * Close the current tab page.
6124 */
6125 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006126tabpage_close(int forceit)
Bram Moolenaarf740b292006-02-16 22:11:02 +00006127{
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006128 // First close all the windows but the current one. If that worked then
6129 // close the last window in this tab, that will close it.
Bram Moolenaar459ca562016-11-10 18:16:33 +01006130 if (!ONE_WINDOW)
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00006131 close_others(TRUE, forceit);
Bram Moolenaar459ca562016-11-10 18:16:33 +01006132 if (ONE_WINDOW)
Bram Moolenaarf740b292006-02-16 22:11:02 +00006133 ex_win_close(forceit, curwin, NULL);
6134# ifdef FEAT_GUI
6135 need_mouse_correct = TRUE;
6136# endif
6137}
6138
6139/*
6140 * Close tab page "tp", which is not the current tab page.
6141 * Note that autocommands may make "tp" invalid.
Bram Moolenaar7875acc2006-09-10 13:51:17 +00006142 * Also takes care of the tab pages line disappearing when closing the
6143 * last-but-one tab page.
Bram Moolenaarf740b292006-02-16 22:11:02 +00006144 */
6145 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006146tabpage_close_other(tabpage_T *tp, int forceit)
Bram Moolenaarf740b292006-02-16 22:11:02 +00006147{
6148 int done = 0;
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00006149 win_T *wp;
Bram Moolenaar7875acc2006-09-10 13:51:17 +00006150 int h = tabline_height();
Bram Moolenaarf740b292006-02-16 22:11:02 +00006151
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006152 // Limit to 1000 windows, autocommands may add a window while we close
6153 // one. OK, so I'm paranoid...
Bram Moolenaarf740b292006-02-16 22:11:02 +00006154 while (++done < 1000)
6155 {
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00006156 wp = tp->tp_firstwin;
6157 ex_win_close(forceit, wp, tp);
Bram Moolenaarf740b292006-02-16 22:11:02 +00006158
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006159 // Autocommands may delete the tab page under our fingers and we may
6160 // fail to close a window with a modified buffer.
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00006161 if (!valid_tabpage(tp) || tp->tp_firstwin == wp)
Bram Moolenaarf740b292006-02-16 22:11:02 +00006162 break;
6163 }
Bram Moolenaar7875acc2006-09-10 13:51:17 +00006164
Bram Moolenaar29323592016-07-24 22:04:11 +02006165 apply_autocmds(EVENT_TABCLOSED, NULL, NULL, FALSE, curbuf);
Bram Moolenaar29323592016-07-24 22:04:11 +02006166
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00006167 redraw_tabline = TRUE;
Bram Moolenaar7875acc2006-09-10 13:51:17 +00006168 if (h != tabline_height())
6169 shell_new_rows();
Bram Moolenaarf740b292006-02-16 22:11:02 +00006170}
6171
6172/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00006173 * ":only".
6174 */
6175 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006176ex_only(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006177{
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01006178 win_T *wp;
6179 int wnr;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006180# ifdef FEAT_GUI
6181 need_mouse_correct = TRUE;
6182# endif
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01006183 if (eap->addr_count > 0)
6184 {
6185 wnr = eap->line2;
6186 for (wp = firstwin; --wnr > 0; )
6187 {
6188 if (wp->w_next == NULL)
6189 break;
6190 else
6191 wp = wp->w_next;
6192 }
6193 win_goto(wp);
6194 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00006195 close_others(TRUE, eap->forceit);
6196}
6197
Bram Moolenaar071d4272004-06-13 20:20:40 +00006198 static void
Bram Moolenaar5e1e6d22017-01-02 17:26:00 +01006199ex_hide(exarg_T *eap UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006200{
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006201 // ":hide" or ":hide | cmd": hide current window
Bram Moolenaar2256c992016-11-15 21:17:07 +01006202 if (!eap->skip)
6203 {
Bram Moolenaar4033c552017-09-16 20:54:51 +02006204#ifdef FEAT_GUI
Bram Moolenaar2256c992016-11-15 21:17:07 +01006205 need_mouse_correct = TRUE;
Bram Moolenaar4033c552017-09-16 20:54:51 +02006206#endif
Bram Moolenaar2256c992016-11-15 21:17:07 +01006207 if (eap->addr_count == 0)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006208 win_close(curwin, FALSE); // don't free buffer
Bram Moolenaar2256c992016-11-15 21:17:07 +01006209 else
6210 {
6211 int winnr = 0;
6212 win_T *win;
Bram Moolenaarf240e182014-11-27 18:33:02 +01006213
Bram Moolenaar2256c992016-11-15 21:17:07 +01006214 FOR_ALL_WINDOWS(win)
6215 {
6216 winnr++;
6217 if (winnr == eap->line2)
6218 break;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01006219 }
Bram Moolenaar2256c992016-11-15 21:17:07 +01006220 if (win == NULL)
6221 win = lastwin;
6222 win_close(win, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006223 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00006224 }
6225}
6226
6227/*
6228 * ":stop" and ":suspend": Suspend Vim.
6229 */
dbivolaruab16ad32021-12-29 19:41:47 +00006230 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006231ex_stop(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006232{
6233 /*
6234 * Disallow suspending for "rvim".
6235 */
Bram Moolenaarcea912a2016-10-12 14:20:24 +02006236 if (!check_restricted())
Bram Moolenaar071d4272004-06-13 20:20:40 +00006237 {
6238 if (!eap->forceit)
6239 autowrite_all();
Bram Moolenaar100118c2020-12-11 19:30:34 +01006240 apply_autocmds(EVENT_VIMSUSPEND, NULL, NULL, FALSE, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006241 windgoto((int)Rows - 1, 0);
6242 out_char('\n');
6243 out_flush();
6244 stoptermcap();
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006245 out_flush(); // needed for SUN to restore xterm buffer
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006246 mch_restore_title(SAVE_RESTORE_BOTH); // restore window titles
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006247 ui_suspend(); // call machine specific function
Bram Moolenaar071d4272004-06-13 20:20:40 +00006248 maketitle();
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006249 resettitle(); // force updating the title
Bram Moolenaar071d4272004-06-13 20:20:40 +00006250 starttermcap();
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006251 scroll_start(); // scroll screen before redrawing
Bram Moolenaar071d4272004-06-13 20:20:40 +00006252 redraw_later_clear();
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006253 shell_resized(); // may have resized window
Bram Moolenaar100118c2020-12-11 19:30:34 +01006254 apply_autocmds(EVENT_VIMRESUME, NULL, NULL, FALSE, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006255 }
6256}
6257
6258/*
Bram Moolenaar1174b012021-05-29 14:30:43 +02006259 * ":exit", ":xit" and ":wq": Write file and quit the current window.
Bram Moolenaar071d4272004-06-13 20:20:40 +00006260 */
6261 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006262ex_exit(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006263{
Bram Moolenaar461f2122020-07-28 20:25:47 +02006264#ifdef FEAT_EVAL
Bram Moolenaarae616492020-07-28 20:07:27 +02006265 if (not_in_vim9(eap) == FAIL)
6266 return;
Bram Moolenaar461f2122020-07-28 20:25:47 +02006267#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00006268#ifdef FEAT_CMDWIN
6269 if (cmdwin_type != 0)
6270 {
6271 cmdwin_result = Ctrl_C;
6272 return;
6273 }
6274#endif
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006275 // Don't quit while editing the command line.
Bram Moolenaar2d3f4892006-01-20 23:02:51 +00006276 if (text_locked())
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00006277 {
Bram Moolenaar2d3f4892006-01-20 23:02:51 +00006278 text_locked_msg();
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00006279 return;
6280 }
Bram Moolenaar12a96de2018-03-11 14:44:18 +01006281
Bram Moolenaar071d4272004-06-13 20:20:40 +00006282 /*
Bram Moolenaar1174b012021-05-29 14:30:43 +02006283 * we plan to exit if there is only one relevant window
Bram Moolenaar071d4272004-06-13 20:20:40 +00006284 */
6285 if (check_more(FALSE, eap->forceit) == OK && only_one_window())
6286 exiting = TRUE;
Bram Moolenaar1174b012021-05-29 14:30:43 +02006287
6288 // Write the buffer for ":wq" or when it was changed.
6289 // Trigger QuitPre and ExitPre.
6290 // Check if we can exit now, after autocommands have changed things.
6291 if (((eap->cmdidx == CMD_wq || curbufIsChanged()) && do_write(eap) == FAIL)
6292 || before_quit_autocmds(curwin, FALSE, eap->forceit)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006293 || check_more(TRUE, eap->forceit) == FAIL
Bram Moolenaar027387f2016-01-02 22:25:52 +01006294 || (only_one_window() && check_changed_any(eap->forceit, FALSE)))
Bram Moolenaar071d4272004-06-13 20:20:40 +00006295 {
6296 not_exiting();
6297 }
6298 else
6299 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006300 if (only_one_window()) // quit last window, exit Vim
Bram Moolenaar071d4272004-06-13 20:20:40 +00006301 getout(0);
Bram Moolenaar2c33d7b2017-10-14 16:06:20 +02006302 not_exiting();
Bram Moolenaar071d4272004-06-13 20:20:40 +00006303# ifdef FEAT_GUI
6304 need_mouse_correct = TRUE;
6305# endif
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006306 // Quit current window, may free the buffer.
Bram Moolenaareb44a682017-08-03 22:44:55 +02006307 win_close(curwin, !buf_hide(curwin->w_buffer));
Bram Moolenaar071d4272004-06-13 20:20:40 +00006308 }
6309}
6310
6311/*
6312 * ":print", ":list", ":number".
6313 */
6314 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006315ex_print(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006316{
Bram Moolenaardf177f62005-02-22 08:39:57 +00006317 if (curbuf->b_ml.ml_flags & ML_EMPTY)
Bram Moolenaar74409f62022-01-01 15:58:22 +00006318 emsg(_(e_empty_buffer));
Bram Moolenaardf177f62005-02-22 08:39:57 +00006319 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00006320 {
Bram Moolenaardf177f62005-02-22 08:39:57 +00006321 for ( ;!got_int; ui_breakcheck())
6322 {
6323 print_line(eap->line1,
6324 (eap->cmdidx == CMD_number || eap->cmdidx == CMD_pound
6325 || (eap->flags & EXFLAG_NR)),
6326 eap->cmdidx == CMD_list || (eap->flags & EXFLAG_LIST));
6327 if (++eap->line1 > eap->line2)
6328 break;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006329 out_flush(); // show one line at a time
Bram Moolenaardf177f62005-02-22 08:39:57 +00006330 }
6331 setpcmark();
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006332 // put cursor at last line
Bram Moolenaardf177f62005-02-22 08:39:57 +00006333 curwin->w_cursor.lnum = eap->line2;
6334 beginline(BL_SOL | BL_FIX);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006335 }
6336
Bram Moolenaar071d4272004-06-13 20:20:40 +00006337 ex_no_reprint = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006338}
6339
6340#ifdef FEAT_BYTEOFF
6341 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006342ex_goto(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006343{
6344 goto_byte(eap->line2);
6345}
6346#endif
6347
6348/*
6349 * ":shell".
6350 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00006351 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006352ex_shell(exarg_T *eap UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006353{
6354 do_shell(NULL, 0);
6355}
6356
Bram Moolenaar92d147b2018-07-29 17:35:23 +02006357#if defined(HAVE_DROP_FILE) || defined(PROTO)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006358
Bram Moolenaar92d147b2018-07-29 17:35:23 +02006359static int drop_busy = FALSE;
6360static int drop_filec;
6361static char_u **drop_filev = NULL;
6362static int drop_split;
6363static void (*drop_callback)(void *);
6364static void *drop_cookie;
6365
6366 static void
6367handle_drop_internal(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006368{
6369 exarg_T ea;
6370 int save_msg_scroll = msg_scroll;
6371
Bram Moolenaar92d147b2018-07-29 17:35:23 +02006372 // Setting the argument list may cause screen updates and being called
6373 // recursively. Avoid that by setting drop_busy.
6374 drop_busy = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006375
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006376 // Check whether the current buffer is changed. If so, we will need
6377 // to split the current window or data could be lost.
6378 // We don't need to check if the 'hidden' option is set, as in this
6379 // case the buffer won't be lost.
Bram Moolenaar92d147b2018-07-29 17:35:23 +02006380 if (!buf_hide(curbuf) && !drop_split)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006381 {
6382 ++emsg_off;
Bram Moolenaar92d147b2018-07-29 17:35:23 +02006383 drop_split = check_changed(curbuf, CCGD_AW);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006384 --emsg_off;
6385 }
Bram Moolenaar92d147b2018-07-29 17:35:23 +02006386 if (drop_split)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006387 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00006388 if (win_split(0, 0) == FAIL)
6389 return;
Bram Moolenaar3368ea22010-09-21 16:56:35 +02006390 RESET_BINDING(curwin);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006391
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006392 // When splitting the window, create a new alist. Otherwise the
6393 // existing one is overwritten.
Bram Moolenaar071d4272004-06-13 20:20:40 +00006394 alist_unlink(curwin->w_alist);
6395 alist_new();
Bram Moolenaar071d4272004-06-13 20:20:40 +00006396 }
6397
6398 /*
6399 * Set up the new argument list.
6400 */
Bram Moolenaar92d147b2018-07-29 17:35:23 +02006401 alist_set(ALIST(curwin), drop_filec, drop_filev, FALSE, NULL, 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006402
6403 /*
6404 * Move to the first file.
6405 */
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006406 // Fake up a minimal "next" command for do_argfile()
Bram Moolenaara80faa82020-04-12 19:37:17 +02006407 CLEAR_FIELD(ea);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006408 ea.cmd = (char_u *)"next";
6409 do_argfile(&ea, 0);
6410
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006411 // do_ecmd() may set need_start_insertmode, but since we never left Insert
6412 // mode that is not needed here.
Bram Moolenaar071d4272004-06-13 20:20:40 +00006413 need_start_insertmode = FALSE;
6414
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006415 // Restore msg_scroll, otherwise a following command may cause scrolling
6416 // unexpectedly. The screen will be redrawn by the caller, thus
6417 // msg_scroll being set by displaying a message is irrelevant.
Bram Moolenaar071d4272004-06-13 20:20:40 +00006418 msg_scroll = save_msg_scroll;
Bram Moolenaar92d147b2018-07-29 17:35:23 +02006419
6420 if (drop_callback != NULL)
6421 drop_callback(drop_cookie);
6422
6423 drop_filev = NULL;
6424 drop_busy = FALSE;
6425}
6426
6427/*
6428 * Handle a file drop. The code is here because a drop is *nearly* like an
6429 * :args command, but not quite (we have a list of exact filenames, so we
Bram Moolenaarb5443cc2019-01-15 20:19:40 +01006430 * don't want to (a) parse a command line, or (b) expand wildcards). So the
Bram Moolenaar92d147b2018-07-29 17:35:23 +02006431 * code is very similar to :args and hence needs access to a lot of the static
6432 * functions in this file.
6433 *
6434 * The "filev" list must have been allocated using alloc(), as should each item
6435 * in the list. This function takes over responsibility for freeing the "filev"
6436 * list.
6437 */
6438 void
6439handle_drop(
6440 int filec, // the number of files dropped
6441 char_u **filev, // the list of files dropped
6442 int split, // force splitting the window
6443 void (*callback)(void *), // to be called after setting the argument
6444 // list
6445 void *cookie) // argument for "callback" (allocated)
6446{
6447 // Cannot handle recursive drops, finish the pending one.
6448 if (drop_busy)
6449 {
6450 FreeWild(filec, filev);
6451 vim_free(cookie);
6452 return;
6453 }
6454
6455 // When calling handle_drop() more than once in a row we only use the last
6456 // one.
6457 if (drop_filev != NULL)
6458 {
6459 FreeWild(drop_filec, drop_filev);
6460 vim_free(drop_cookie);
6461 }
6462
6463 drop_filec = filec;
6464 drop_filev = filev;
6465 drop_split = split;
6466 drop_callback = callback;
6467 drop_cookie = cookie;
6468
6469 // Postpone this when:
6470 // - editing the command line
6471 // - not possible to change the current buffer
6472 // - updating the screen
6473 // As it may change buffers and window structures that are in use and cause
6474 // freed memory to be used.
6475 if (text_locked() || curbuf_locked() || updating_screen)
6476 return;
6477
6478 handle_drop_internal();
6479}
6480
6481/*
6482 * To be called when text is unlocked, curbuf is unlocked or updating_screen is
6483 * reset: Handle a postponed drop.
6484 */
6485 void
6486handle_any_postponed_drop(void)
6487{
6488 if (!drop_busy && drop_filev != NULL
Bram Moolenaar6adb9ea2020-04-30 22:31:18 +02006489 && !text_locked() && !curbuf_locked() && !updating_screen)
Bram Moolenaar92d147b2018-07-29 17:35:23 +02006490 handle_drop_internal();
Bram Moolenaar071d4272004-06-13 20:20:40 +00006491}
6492#endif
6493
Bram Moolenaar071d4272004-06-13 20:20:40 +00006494/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00006495 * ":preserve".
6496 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00006497 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006498ex_preserve(exarg_T *eap UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006499{
Bram Moolenaar4399ef42005-02-12 14:29:27 +00006500 curbuf->b_flags |= BF_PRESERVED;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006501 ml_preserve(curbuf, TRUE);
6502}
6503
6504/*
6505 * ":recover".
6506 */
6507 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006508ex_recover(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006509{
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006510 // Set recoverymode right away to avoid the ATTENTION prompt.
Bram Moolenaar071d4272004-06-13 20:20:40 +00006511 recoverymode = TRUE;
Bram Moolenaar45d3b142013-11-09 03:31:51 +01006512 if (!check_changed(curbuf, (p_awa ? CCGD_AW : 0)
6513 | CCGD_MULTWIN
6514 | (eap->forceit ? CCGD_FORCEIT : 0)
6515 | CCGD_EXCMD)
6516
Bram Moolenaar071d4272004-06-13 20:20:40 +00006517 && (*eap->arg == NUL
6518 || setfname(curbuf, eap->arg, NULL, TRUE) == OK))
Bram Moolenaar99499b12019-05-23 21:35:48 +02006519 ml_recover(TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006520 recoverymode = FALSE;
6521}
6522
6523/*
6524 * Command modifier used in a wrong way.
6525 */
6526 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006527ex_wrongmodifier(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006528{
Bram Moolenaar451c2e32020-08-15 16:33:28 +02006529 eap->errmsg = _(e_invalid_command);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006530}
6531
Bram Moolenaar071d4272004-06-13 20:20:40 +00006532/*
6533 * :sview [+command] file split window with new file, read-only
6534 * :split [[+command] file] split window with current or new file
6535 * :vsplit [[+command] file] split window vertically with current or new file
6536 * :new [[+command] file] split window with no or new file
6537 * :vnew [[+command] file] split vertically window with no or new file
6538 * :sfind [+command] file split window with file in 'path'
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00006539 *
6540 * :tabedit open new Tab page with empty window
6541 * :tabedit [+command] file open new Tab page and edit "file"
6542 * :tabnew [[+command] file] just like :tabedit
6543 * :tabfind [+command] file open new Tab page and find "file"
Bram Moolenaar071d4272004-06-13 20:20:40 +00006544 */
6545 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006546ex_splitview(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006547{
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00006548 win_T *old_curwin = curwin;
Bram Moolenaar4033c552017-09-16 20:54:51 +02006549#if defined(FEAT_SEARCHPATH) || defined(FEAT_BROWSE)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006550 char_u *fname = NULL;
Bram Moolenaar4033c552017-09-16 20:54:51 +02006551#endif
6552#ifdef FEAT_BROWSE
Bram Moolenaar21cbe172020-10-13 19:08:24 +02006553 char_u dot_path[] = ".";
Bram Moolenaare1004402020-10-24 20:49:43 +02006554 int save_cmod_flags = cmdmod.cmod_flags;
Bram Moolenaar4033c552017-09-16 20:54:51 +02006555#endif
Bram Moolenaar39902a02018-06-21 22:10:08 +02006556 int use_tab = eap->cmdidx == CMD_tabedit
6557 || eap->cmdidx == CMD_tabfind
6558 || eap->cmdidx == CMD_tabnew;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006559
Bram Moolenaar3c01c4a2020-02-01 23:04:24 +01006560 if (ERROR_IF_ANY_POPUP_WINDOW)
Bram Moolenaar815b76b2019-06-01 14:15:52 +02006561 return;
6562
Bram Moolenaar4033c552017-09-16 20:54:51 +02006563#ifdef FEAT_GUI
Bram Moolenaar071d4272004-06-13 20:20:40 +00006564 need_mouse_correct = TRUE;
Bram Moolenaar4033c552017-09-16 20:54:51 +02006565#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00006566
Bram Moolenaar4033c552017-09-16 20:54:51 +02006567#ifdef FEAT_QUICKFIX
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006568 // A ":split" in the quickfix window works like ":new". Don't want two
6569 // quickfix windows. But it's OK when doing ":tab split".
Bram Moolenaare1004402020-10-24 20:49:43 +02006570 if (bt_quickfix(curbuf) && cmdmod.cmod_tab == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006571 {
6572 if (eap->cmdidx == CMD_split)
6573 eap->cmdidx = CMD_new;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006574 if (eap->cmdidx == CMD_vsplit)
6575 eap->cmdidx = CMD_vnew;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006576 }
Bram Moolenaar4033c552017-09-16 20:54:51 +02006577#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00006578
Bram Moolenaar4033c552017-09-16 20:54:51 +02006579#ifdef FEAT_SEARCHPATH
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00006580 if (eap->cmdidx == CMD_sfind || eap->cmdidx == CMD_tabfind)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006581 {
6582 fname = find_file_in_path(eap->arg, (int)STRLEN(eap->arg),
6583 FNAME_MESS, TRUE, curbuf->b_ffname);
6584 if (fname == NULL)
6585 goto theend;
6586 eap->arg = fname;
6587 }
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006588# ifdef FEAT_BROWSE
Bram Moolenaar4033c552017-09-16 20:54:51 +02006589 else
6590# endif
6591#endif
6592#ifdef FEAT_BROWSE
Bram Moolenaare1004402020-10-24 20:49:43 +02006593 if ((cmdmod.cmod_flags & CMOD_BROWSE)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006594 && eap->cmdidx != CMD_vnew
Bram Moolenaar071d4272004-06-13 20:20:40 +00006595 && eap->cmdidx != CMD_new)
6596 {
Bram Moolenaar1d94f9b2005-08-04 21:29:45 +00006597 if (
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01006598# ifdef FEAT_GUI
Bram Moolenaar1d94f9b2005-08-04 21:29:45 +00006599 !gui.in_use &&
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01006600# endif
Bram Moolenaar1d94f9b2005-08-04 21:29:45 +00006601 au_has_group((char_u *)"FileExplorer"))
6602 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006603 // No browsing supported but we do have the file explorer:
6604 // Edit the directory.
Bram Moolenaar1d94f9b2005-08-04 21:29:45 +00006605 if (*eap->arg == NUL || !mch_isdir(eap->arg))
Bram Moolenaar21cbe172020-10-13 19:08:24 +02006606 eap->arg = dot_path;
Bram Moolenaar1d94f9b2005-08-04 21:29:45 +00006607 }
6608 else
6609 {
Bram Moolenaar39902a02018-06-21 22:10:08 +02006610 fname = do_browse(0, (char_u *)(use_tab
6611 ? _("Edit File in new tab page")
6612 : _("Edit File in new window")),
Bram Moolenaar071d4272004-06-13 20:20:40 +00006613 eap->arg, NULL, NULL, NULL, curbuf);
Bram Moolenaar1d94f9b2005-08-04 21:29:45 +00006614 if (fname == NULL)
6615 goto theend;
6616 eap->arg = fname;
6617 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00006618 }
Bram Moolenaare1004402020-10-24 20:49:43 +02006619 cmdmod.cmod_flags &= ~CMOD_BROWSE; // Don't browse again in do_ecmd().
Bram Moolenaar4033c552017-09-16 20:54:51 +02006620#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00006621
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00006622 /*
6623 * Either open new tab page or split the window.
6624 */
Bram Moolenaar39902a02018-06-21 22:10:08 +02006625 if (use_tab)
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00006626 {
Bram Moolenaare1004402020-10-24 20:49:43 +02006627 if (win_new_tabpage(cmdmod.cmod_tab != 0 ? cmdmod.cmod_tab
Bram Moolenaar8dff8182006-04-06 20:18:50 +00006628 : eap->addr_count == 0 ? 0
6629 : (int)eap->line2 + 1) != FAIL)
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00006630 {
Bram Moolenaard2b66012008-01-09 19:30:36 +00006631 do_exedit(eap, old_curwin);
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00006632
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006633 // set the alternate buffer for the window we came from
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00006634 if (curwin != old_curwin
6635 && win_valid(old_curwin)
6636 && old_curwin->w_buffer != curbuf
Bram Moolenaare1004402020-10-24 20:49:43 +02006637 && (cmdmod.cmod_flags & CMOD_KEEPALT) == 0)
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00006638 old_curwin->w_alt_fnum = curbuf->b_fnum;
6639 }
6640 }
6641 else if (win_split(eap->addr_count > 0 ? (int)eap->line2 : 0,
Bram Moolenaar071d4272004-06-13 20:20:40 +00006642 *eap->cmd == 'v' ? WSP_VERT : 0) != FAIL)
6643 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006644 // Reset 'scrollbind' when editing another file, but keep it when
6645 // doing ":split" without arguments.
Bram Moolenaare1004402020-10-24 20:49:43 +02006646 if (*eap->arg != NUL)
Bram Moolenaar3368ea22010-09-21 16:56:35 +02006647 RESET_BINDING(curwin);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006648 else
6649 do_check_scrollbind(FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006650 do_exedit(eap, old_curwin);
6651 }
6652
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006653# ifdef FEAT_BROWSE
Bram Moolenaare1004402020-10-24 20:49:43 +02006654 cmdmod.cmod_flags = save_cmod_flags;
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006655# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00006656
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006657# if defined(FEAT_SEARCHPATH) || defined(FEAT_BROWSE)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006658theend:
6659 vim_free(fname);
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006660# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00006661}
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006662
6663/*
Bram Moolenaar80a94a52006-02-23 21:26:58 +00006664 * Open a new tab page.
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006665 */
6666 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006667tabpage_new(void)
Bram Moolenaar80a94a52006-02-23 21:26:58 +00006668{
6669 exarg_T ea;
6670
Bram Moolenaara80faa82020-04-12 19:37:17 +02006671 CLEAR_FIELD(ea);
Bram Moolenaar80a94a52006-02-23 21:26:58 +00006672 ea.cmdidx = CMD_tabnew;
6673 ea.cmd = (char_u *)"tabn";
6674 ea.arg = (char_u *)"";
6675 ex_splitview(&ea);
6676}
6677
6678/*
6679 * :tabnext command
6680 */
6681 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006682ex_tabnext(exarg_T *eap)
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006683{
Bram Moolenaar2f72c702017-01-29 14:48:10 +01006684 int tab_number;
6685
Bram Moolenaar8cdbd5b2019-06-16 15:50:45 +02006686 if (ERROR_IF_POPUP_WINDOW)
Bram Moolenaar815b76b2019-06-01 14:15:52 +02006687 return;
Bram Moolenaar32466aa2006-02-24 23:53:04 +00006688 switch (eap->cmdidx)
6689 {
6690 case CMD_tabfirst:
6691 case CMD_tabrewind:
6692 goto_tabpage(1);
6693 break;
6694 case CMD_tablast:
6695 goto_tabpage(9999);
6696 break;
6697 case CMD_tabprevious:
6698 case CMD_tabNext:
Bram Moolenaar2f72c702017-01-29 14:48:10 +01006699 if (eap->arg && *eap->arg != NUL)
6700 {
6701 char_u *p = eap->arg;
6702 char_u *p_save = p;
6703
6704 tab_number = getdigits(&p);
6705 if (p == p_save || *p_save == '-' || *p != NUL
6706 || tab_number == 0)
6707 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006708 // No numbers as argument.
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00006709 eap->errmsg = ex_errmsg(e_invalid_argument_str, eap->arg);
Bram Moolenaar2f72c702017-01-29 14:48:10 +01006710 return;
6711 }
6712 }
6713 else
6714 {
6715 if (eap->addr_count == 0)
6716 tab_number = 1;
6717 else
6718 {
6719 tab_number = eap->line2;
6720 if (tab_number < 1)
6721 {
Bram Moolenaar108010a2021-06-27 22:03:33 +02006722 eap->errmsg = _(e_invalid_range);
Bram Moolenaar2f72c702017-01-29 14:48:10 +01006723 return;
6724 }
6725 }
6726 }
6727 goto_tabpage(-tab_number);
Bram Moolenaar32466aa2006-02-24 23:53:04 +00006728 break;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006729 default: // CMD_tabnext
Bram Moolenaar2f72c702017-01-29 14:48:10 +01006730 tab_number = get_tabpage_arg(eap);
6731 if (eap->errmsg == NULL)
6732 goto_tabpage(tab_number);
Bram Moolenaar32466aa2006-02-24 23:53:04 +00006733 break;
6734 }
Bram Moolenaar80a94a52006-02-23 21:26:58 +00006735}
6736
6737/*
6738 * :tabmove command
6739 */
6740 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006741ex_tabmove(exarg_T *eap)
Bram Moolenaar80a94a52006-02-23 21:26:58 +00006742{
Bram Moolenaar40ce3a42015-04-21 18:08:39 +02006743 int tab_number;
Bram Moolenaar8cb8dca2012-07-06 18:27:39 +02006744
Bram Moolenaar2f72c702017-01-29 14:48:10 +01006745 tab_number = get_tabpage_arg(eap);
6746 if (eap->errmsg == NULL)
6747 tabpage_move(tab_number);
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006748}
6749
6750/*
6751 * :tabs command: List tabs and their contents.
6752 */
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006753 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006754ex_tabs(exarg_T *eap UNUSED)
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006755{
6756 tabpage_T *tp;
6757 win_T *wp;
6758 int tabcount = 1;
6759
6760 msg_start();
6761 msg_scroll = TRUE;
6762 for (tp = first_tabpage; tp != NULL && !got_int; tp = tp->tp_next)
6763 {
6764 msg_putchar('\n');
6765 vim_snprintf((char *)IObuff, IOSIZE, _("Tab page %d"), tabcount++);
Bram Moolenaar8820b482017-03-16 17:23:31 +01006766 msg_outtrans_attr(IObuff, HL_ATTR(HLF_T));
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006767 out_flush(); // output one line at a time
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006768 ui_breakcheck();
6769
Bram Moolenaar030f0df2006-02-21 22:02:53 +00006770 if (tp == curtab)
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006771 wp = firstwin;
6772 else
6773 wp = tp->tp_firstwin;
6774 for ( ; wp != NULL && !got_int; wp = wp->w_next)
6775 {
Bram Moolenaar80a94a52006-02-23 21:26:58 +00006776 msg_putchar('\n');
6777 msg_putchar(wp == curwin ? '>' : ' ');
6778 msg_putchar(' ');
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00006779 msg_putchar(bufIsChanged(wp->w_buffer) ? '+' : ' ');
6780 msg_putchar(' ');
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006781 if (buf_spname(wp->w_buffer) != NULL)
Bram Moolenaare1704ba2012-10-03 18:25:00 +02006782 vim_strncpy(IObuff, buf_spname(wp->w_buffer), IOSIZE - 1);
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006783 else
6784 home_replace(wp->w_buffer, wp->w_buffer->b_fname,
6785 IObuff, IOSIZE, TRUE);
6786 msg_outtrans(IObuff);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006787 out_flush(); // output one line at a time
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006788 ui_breakcheck();
6789 }
6790 }
6791}
6792
Bram Moolenaar071d4272004-06-13 20:20:40 +00006793/*
6794 * ":mode": Set screen mode.
6795 * If no argument given, just get the screen size and redraw.
6796 */
6797 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006798ex_mode(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006799{
6800 if (*eap->arg == NUL)
6801 shell_resized();
6802 else
Bram Moolenaar74409f62022-01-01 15:58:22 +00006803 emsg(_(e_screen_mode_setting_not_supported));
Bram Moolenaar071d4272004-06-13 20:20:40 +00006804}
6805
Bram Moolenaar071d4272004-06-13 20:20:40 +00006806/*
6807 * ":resize".
6808 * set, increment or decrement current window height
6809 */
6810 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006811ex_resize(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006812{
6813 int n;
6814 win_T *wp = curwin;
6815
6816 if (eap->addr_count > 0)
6817 {
6818 n = eap->line2;
6819 for (wp = firstwin; wp->w_next != NULL && --n > 0; wp = wp->w_next)
6820 ;
6821 }
6822
Bram Moolenaar44a2f922016-03-19 22:11:51 +01006823# ifdef FEAT_GUI
Bram Moolenaar071d4272004-06-13 20:20:40 +00006824 need_mouse_correct = TRUE;
Bram Moolenaar44a2f922016-03-19 22:11:51 +01006825# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00006826 n = atol((char *)eap->arg);
Bram Moolenaare1004402020-10-24 20:49:43 +02006827 if (cmdmod.cmod_split & WSP_VERT)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006828 {
6829 if (*eap->arg == '-' || *eap->arg == '+')
Bram Moolenaar9668cc52020-10-17 17:39:55 +02006830 n += wp->w_width;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006831 else if (n == 0 && eap->arg[0] == NUL) // default is very wide
Bram Moolenaar071d4272004-06-13 20:20:40 +00006832 n = 9999;
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +00006833 win_setwidth_win(n, wp);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006834 }
6835 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00006836 {
6837 if (*eap->arg == '-' || *eap->arg == '+')
Bram Moolenaar9668cc52020-10-17 17:39:55 +02006838 n += wp->w_height;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006839 else if (n == 0 && eap->arg[0] == NUL) // default is very high
Bram Moolenaar071d4272004-06-13 20:20:40 +00006840 n = 9999;
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +00006841 win_setheight_win(n, wp);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006842 }
6843}
Bram Moolenaar071d4272004-06-13 20:20:40 +00006844
6845/*
6846 * ":find [+command] <file>" command.
6847 */
6848 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006849ex_find(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006850{
6851#ifdef FEAT_SEARCHPATH
6852 char_u *fname;
6853 int count;
6854
6855 fname = find_file_in_path(eap->arg, (int)STRLEN(eap->arg), FNAME_MESS,
6856 TRUE, curbuf->b_ffname);
6857 if (eap->addr_count > 0)
6858 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006859 // Repeat finding the file "count" times. This matters when it
6860 // appears several times in the path.
Bram Moolenaar071d4272004-06-13 20:20:40 +00006861 count = eap->line2;
6862 while (fname != NULL && --count > 0)
6863 {
6864 vim_free(fname);
6865 fname = find_file_in_path(NULL, 0, FNAME_MESS,
6866 FALSE, curbuf->b_ffname);
6867 }
6868 }
6869
6870 if (fname != NULL)
6871 {
6872 eap->arg = fname;
6873#endif
6874 do_exedit(eap, NULL);
6875#ifdef FEAT_SEARCHPATH
6876 vim_free(fname);
6877 }
6878#endif
6879}
6880
6881/*
Bram Moolenaardf177f62005-02-22 08:39:57 +00006882 * ":open" simulation: for now just work like ":visual".
6883 */
6884 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006885ex_open(exarg_T *eap)
Bram Moolenaardf177f62005-02-22 08:39:57 +00006886{
6887 regmatch_T regmatch;
6888 char_u *p;
6889
Bram Moolenaar65088802021-03-13 21:07:21 +01006890#ifdef FEAT_EVAL
6891 if (not_in_vim9(eap) == FAIL)
6892 return;
6893#endif
Bram Moolenaardf177f62005-02-22 08:39:57 +00006894 curwin->w_cursor.lnum = eap->line2;
6895 beginline(BL_SOL | BL_FIX);
6896 if (*eap->arg == '/')
6897 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006898 // ":open /pattern/": put cursor in column found with pattern
Bram Moolenaardf177f62005-02-22 08:39:57 +00006899 ++eap->arg;
Bram Moolenaarf4e20992020-12-21 19:59:08 +01006900 p = skip_regexp(eap->arg, '/', magic_isset());
Bram Moolenaardf177f62005-02-22 08:39:57 +00006901 *p = NUL;
Bram Moolenaarf4e20992020-12-21 19:59:08 +01006902 regmatch.regprog = vim_regcomp(eap->arg, magic_isset() ? RE_MAGIC : 0);
Bram Moolenaardf177f62005-02-22 08:39:57 +00006903 if (regmatch.regprog != NULL)
6904 {
Bram Moolenaare031fe92021-12-05 12:06:24 +00006905 // make a copy of the line, when searching for a mark it might be
6906 // flushed
6907 char_u *line = vim_strsave(ml_get_curline());
6908
Bram Moolenaardf177f62005-02-22 08:39:57 +00006909 regmatch.rm_ic = p_ic;
Bram Moolenaare031fe92021-12-05 12:06:24 +00006910 if (vim_regexec(&regmatch, line, (colnr_T)0))
6911 curwin->w_cursor.col = (colnr_T)(regmatch.startp[0] - line);
Bram Moolenaardf177f62005-02-22 08:39:57 +00006912 else
Bram Moolenaar460ae5d2022-01-01 14:19:49 +00006913 emsg(_(e_no_match));
Bram Moolenaar473de612013-06-08 18:19:48 +02006914 vim_regfree(regmatch.regprog);
Bram Moolenaare031fe92021-12-05 12:06:24 +00006915 vim_free(line);
Bram Moolenaardf177f62005-02-22 08:39:57 +00006916 }
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006917 // Move to the NUL, ignore any other arguments.
Bram Moolenaardf177f62005-02-22 08:39:57 +00006918 eap->arg += STRLEN(eap->arg);
6919 }
6920 check_cursor();
6921
6922 eap->cmdidx = CMD_visual;
6923 do_exedit(eap, NULL);
6924}
6925
6926/*
Bram Moolenaar59d8e562020-11-07 18:41:10 +01006927 * ":edit", ":badd", ":balt", ":visual".
Bram Moolenaar071d4272004-06-13 20:20:40 +00006928 */
6929 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006930ex_edit(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006931{
6932 do_exedit(eap, NULL);
6933}
6934
6935/*
Bram Moolenaar4b96df52020-01-26 22:00:26 +01006936 * ":edit <file>" command and alike.
Bram Moolenaar071d4272004-06-13 20:20:40 +00006937 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00006938 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006939do_exedit(
6940 exarg_T *eap,
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006941 win_T *old_curwin) // curwin before doing a split or NULL
Bram Moolenaar071d4272004-06-13 20:20:40 +00006942{
6943 int n;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006944 int need_hide;
Bram Moolenaardf177f62005-02-22 08:39:57 +00006945 int exmode_was = exmode_active;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006946
Bram Moolenaar3c01c4a2020-02-01 23:04:24 +01006947 if ((eap->cmdidx != CMD_pedit && ERROR_IF_POPUP_WINDOW)
6948 || ERROR_IF_TERM_POPUP_WINDOW)
Bram Moolenaar815b76b2019-06-01 14:15:52 +02006949 return;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006950 /*
6951 * ":vi" command ends Ex mode.
6952 */
6953 if (exmode_active && (eap->cmdidx == CMD_visual
6954 || eap->cmdidx == CMD_view))
6955 {
6956 exmode_active = FALSE;
Bram Moolenaar158ea172020-06-18 17:28:39 +02006957 ex_pressedreturn = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006958 if (*eap->arg == NUL)
Bram Moolenaardf177f62005-02-22 08:39:57 +00006959 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006960 // Special case: ":global/pat/visual\NLvi-commands"
Bram Moolenaardf177f62005-02-22 08:39:57 +00006961 if (global_busy)
6962 {
6963 int rd = RedrawingDisabled;
6964 int nwr = no_wait_return;
6965 int ms = msg_scroll;
6966#ifdef FEAT_GUI
6967 int he = hold_gui_events;
6968#endif
6969
6970 if (eap->nextcmd != NULL)
6971 {
6972 stuffReadbuff(eap->nextcmd);
6973 eap->nextcmd = NULL;
6974 }
6975
6976 if (exmode_was != EXMODE_VIM)
6977 settmode(TMODE_RAW);
6978 RedrawingDisabled = 0;
6979 no_wait_return = 0;
6980 need_wait_return = FALSE;
6981 msg_scroll = 0;
6982#ifdef FEAT_GUI
6983 hold_gui_events = 0;
6984#endif
6985 must_redraw = CLEAR;
Bram Moolenaar9e2bcb52020-02-18 21:33:00 +01006986 pending_exmode_active = TRUE;
Bram Moolenaardf177f62005-02-22 08:39:57 +00006987
6988 main_loop(FALSE, TRUE);
6989
Bram Moolenaar9e2bcb52020-02-18 21:33:00 +01006990 pending_exmode_active = FALSE;
Bram Moolenaardf177f62005-02-22 08:39:57 +00006991 RedrawingDisabled = rd;
6992 no_wait_return = nwr;
6993 msg_scroll = ms;
6994#ifdef FEAT_GUI
6995 hold_gui_events = he;
6996#endif
6997 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00006998 return;
Bram Moolenaardf177f62005-02-22 08:39:57 +00006999 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00007000 }
7001
7002 if ((eap->cmdidx == CMD_new
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00007003 || eap->cmdidx == CMD_tabnew
7004 || eap->cmdidx == CMD_tabedit
Bram Moolenaar4033c552017-09-16 20:54:51 +02007005 || eap->cmdidx == CMD_vnew) && *eap->arg == NUL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007006 {
Dominique Pelleaf4a61a2021-12-27 17:21:41 +00007007 // ":new" or ":tabnew" without argument: edit a new empty buffer
Bram Moolenaar071d4272004-06-13 20:20:40 +00007008 setpcmark();
7009 (void)do_ecmd(0, NULL, NULL, eap, ECMD_ONE,
Bram Moolenaar701f7af2008-11-15 13:12:07 +00007010 ECMD_HIDE + (eap->forceit ? ECMD_FORCEIT : 0),
7011 old_curwin == NULL ? curwin : NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007012 }
Bram Moolenaar4033c552017-09-16 20:54:51 +02007013 else if ((eap->cmdidx != CMD_split && eap->cmdidx != CMD_vsplit)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007014 || *eap->arg != NUL
7015#ifdef FEAT_BROWSE
Bram Moolenaare1004402020-10-24 20:49:43 +02007016 || (cmdmod.cmod_flags & CMOD_BROWSE)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007017#endif
7018 )
7019 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007020 // Can't edit another file when "curbuf_lock" is set. Only ":edit"
7021 // can bring us here, others are stopped earlier.
Bram Moolenaar5555acc2006-04-07 21:33:12 +00007022 if (*eap->arg != NUL && curbuf_locked())
7023 return;
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01007024
Bram Moolenaar071d4272004-06-13 20:20:40 +00007025 n = readonlymode;
7026 if (eap->cmdidx == CMD_view || eap->cmdidx == CMD_sview)
7027 readonlymode = TRUE;
7028 else if (eap->cmdidx == CMD_enew)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007029 readonlymode = FALSE; // 'readonly' doesn't make sense in an
7030 // empty buffer
Bram Moolenaar3482be62020-11-27 11:00:38 +01007031 if (eap->cmdidx != CMD_balt && eap->cmdidx != CMD_badd)
7032 setpcmark();
Bram Moolenaar071d4272004-06-13 20:20:40 +00007033 if (do_ecmd(0, (eap->cmdidx == CMD_enew ? NULL : eap->arg),
7034 NULL, eap,
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007035 // ":edit" goes to first line if Vi compatible
Bram Moolenaar071d4272004-06-13 20:20:40 +00007036 (*eap->arg == NUL && eap->do_ecmd_lnum == 0
7037 && vim_strchr(p_cpo, CPO_GOTO1) != NULL)
7038 ? ECMD_ONE : eap->do_ecmd_lnum,
Bram Moolenaareb44a682017-08-03 22:44:55 +02007039 (buf_hide(curbuf) ? ECMD_HIDE : 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007040 + (eap->forceit ? ECMD_FORCEIT : 0)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007041 // after a split we can use an existing buffer
Bram Moolenaar7b449342014-03-25 13:03:48 +01007042 + (old_curwin != NULL ? ECMD_OLDBUF : 0)
Bram Moolenaar59d8e562020-11-07 18:41:10 +01007043 + (eap->cmdidx == CMD_badd ? ECMD_ADDBUF : 0)
7044 + (eap->cmdidx == CMD_balt ? ECMD_ALTBUF : 0)
Bram Moolenaar701f7af2008-11-15 13:12:07 +00007045 , old_curwin == NULL ? curwin : NULL) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007046 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007047 // Editing the file failed. If the window was split, close it.
Bram Moolenaar071d4272004-06-13 20:20:40 +00007048 if (old_curwin != NULL)
7049 {
7050 need_hide = (curbufIsChanged() && curbuf->b_nwindows <= 1);
Bram Moolenaareb44a682017-08-03 22:44:55 +02007051 if (!need_hide || buf_hide(curbuf))
Bram Moolenaar071d4272004-06-13 20:20:40 +00007052 {
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01007053#if defined(FEAT_EVAL)
Bram Moolenaarc0197e22004-09-13 20:26:32 +00007054 cleanup_T cs;
7055
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007056 // Reset the error/interrupt/exception state here so that
7057 // aborting() returns FALSE when closing a window.
Bram Moolenaarc0197e22004-09-13 20:26:32 +00007058 enter_cleanup(&cs);
Bram Moolenaar4033c552017-09-16 20:54:51 +02007059#endif
7060#ifdef FEAT_GUI
Bram Moolenaar071d4272004-06-13 20:20:40 +00007061 need_mouse_correct = TRUE;
Bram Moolenaar4033c552017-09-16 20:54:51 +02007062#endif
Bram Moolenaareb44a682017-08-03 22:44:55 +02007063 win_close(curwin, !need_hide && !buf_hide(curbuf));
Bram Moolenaarc0197e22004-09-13 20:26:32 +00007064
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01007065#if defined(FEAT_EVAL)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007066 // Restore the error/interrupt/exception state if not
7067 // discarded by a new aborting error, interrupt, or
7068 // uncaught exception.
Bram Moolenaarc0197e22004-09-13 20:26:32 +00007069 leave_cleanup(&cs);
Bram Moolenaar4033c552017-09-16 20:54:51 +02007070#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00007071 }
7072 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00007073 }
7074 else if (readonlymode && curbuf->b_nwindows == 1)
7075 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007076 // When editing an already visited buffer, 'readonly' won't be set
7077 // but the previous value is kept. With ":view" and ":sview" we
7078 // want the file to be readonly, except when another window is
7079 // editing the same buffer.
Bram Moolenaar071d4272004-06-13 20:20:40 +00007080 curbuf->b_p_ro = TRUE;
7081 }
7082 readonlymode = n;
7083 }
7084 else
7085 {
7086 if (eap->do_ecmd_cmd != NULL)
Bram Moolenaar47a2abf2020-11-25 20:12:11 +01007087 do_cmd_argument(eap->do_ecmd_cmd);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007088 n = curwin->w_arg_idx_invalid;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007089 check_arg_idx(curwin);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007090 if (n != curwin->w_arg_idx_invalid)
7091 maketitle();
Bram Moolenaar071d4272004-06-13 20:20:40 +00007092 }
7093
Bram Moolenaar071d4272004-06-13 20:20:40 +00007094 /*
7095 * if ":split file" worked, set alternate file name in old window to new
7096 * file
7097 */
7098 if (old_curwin != NULL
7099 && *eap->arg != NUL
7100 && curwin != old_curwin
7101 && win_valid(old_curwin)
Bram Moolenaard4755bb2004-09-02 19:12:26 +00007102 && old_curwin->w_buffer != curbuf
Bram Moolenaare1004402020-10-24 20:49:43 +02007103 && (cmdmod.cmod_flags & CMOD_KEEPALT) == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007104 old_curwin->w_alt_fnum = curbuf->b_fnum;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007105
7106 ex_no_reprint = TRUE;
7107}
7108
7109#ifndef FEAT_GUI
7110/*
7111 * ":gui" and ":gvim" when there is no GUI.
7112 */
7113 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007114ex_nogui(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007115{
Bram Moolenaare29a27f2021-07-20 21:07:36 +02007116 eap->errmsg = _(e_gui_cannot_be_used_not_enabled_at_compile_time);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007117}
7118#endif
7119
Bram Moolenaar4f974752019-02-17 17:44:42 +01007120#if defined(FEAT_GUI_MSWIN) && defined(FEAT_MENU) && defined(FEAT_TEAROFF)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007121 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007122ex_tearoff(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007123{
7124 gui_make_tearoff(eap->arg);
7125}
7126#endif
7127
Bram Moolenaar29a2c082018-03-05 21:06:23 +01007128#if (defined(FEAT_GUI_MSWIN) || defined(FEAT_GUI_GTK) \
7129 || defined(FEAT_TERM_POPUP_MENU)) && defined(FEAT_MENU)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007130 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007131ex_popup(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007132{
Bram Moolenaar29a2c082018-03-05 21:06:23 +01007133# if defined(FEAT_GUI_MSWIN) || defined(FEAT_GUI_GTK)
7134 if (gui.in_use)
7135 gui_make_popup(eap->arg, eap->forceit);
7136# ifdef FEAT_TERM_POPUP_MENU
7137 else
7138# endif
7139# endif
7140# ifdef FEAT_TERM_POPUP_MENU
7141 pum_make_popup(eap->arg, eap->forceit);
7142# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00007143}
7144#endif
7145
Bram Moolenaar071d4272004-06-13 20:20:40 +00007146 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007147ex_swapname(exarg_T *eap UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007148{
7149 if (curbuf->b_ml.ml_mfp == NULL || curbuf->b_ml.ml_mfp->mf_fname == NULL)
Bram Moolenaar32526b32019-01-19 17:43:09 +01007150 msg(_("No swap file"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00007151 else
Bram Moolenaar32526b32019-01-19 17:43:09 +01007152 msg((char *)curbuf->b_ml.ml_mfp->mf_fname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007153}
7154
7155/*
7156 * ":syncbind" forces all 'scrollbind' windows to have the same relative
7157 * offset.
7158 * (1998-11-02 16:21:01 R. Edward Ralston <eralston@computer.org>)
7159 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00007160 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007161ex_syncbind(exarg_T *eap UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007162{
Bram Moolenaar071d4272004-06-13 20:20:40 +00007163 win_T *wp;
Bram Moolenaardedd1b02013-12-14 13:06:17 +01007164 win_T *save_curwin = curwin;
7165 buf_T *save_curbuf = curbuf;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007166 long topline;
7167 long y;
7168 linenr_T old_linenr = curwin->w_cursor.lnum;
7169
7170 setpcmark();
7171
7172 /*
7173 * determine max topline
7174 */
7175 if (curwin->w_p_scb)
7176 {
7177 topline = curwin->w_topline;
Bram Moolenaar29323592016-07-24 22:04:11 +02007178 FOR_ALL_WINDOWS(wp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007179 {
7180 if (wp->w_p_scb && wp->w_buffer)
7181 {
Bram Moolenaar375e3392019-01-31 18:26:10 +01007182 y = wp->w_buffer->b_ml.ml_line_count - get_scrolloff_value();
Bram Moolenaar071d4272004-06-13 20:20:40 +00007183 if (topline > y)
7184 topline = y;
7185 }
7186 }
7187 if (topline < 1)
7188 topline = 1;
7189 }
7190 else
7191 {
7192 topline = 1;
7193 }
7194
7195
7196 /*
Bram Moolenaardedd1b02013-12-14 13:06:17 +01007197 * Set all scrollbind windows to the same topline.
Bram Moolenaar071d4272004-06-13 20:20:40 +00007198 */
Bram Moolenaar29323592016-07-24 22:04:11 +02007199 FOR_ALL_WINDOWS(curwin)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007200 {
7201 if (curwin->w_p_scb)
7202 {
Bram Moolenaardedd1b02013-12-14 13:06:17 +01007203 curbuf = curwin->w_buffer;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007204 y = topline - curwin->w_topline;
7205 if (y > 0)
7206 scrollup(y, TRUE);
7207 else
7208 scrolldown(-y, TRUE);
7209 curwin->w_scbind_pos = topline;
7210 redraw_later(VALID);
7211 cursor_correct();
Bram Moolenaar071d4272004-06-13 20:20:40 +00007212 curwin->w_redr_status = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007213 }
7214 }
Bram Moolenaardedd1b02013-12-14 13:06:17 +01007215 curwin = save_curwin;
7216 curbuf = save_curbuf;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007217 if (curwin->w_p_scb)
7218 {
7219 did_syncbind = TRUE;
7220 checkpcmark();
7221 if (old_linenr != curwin->w_cursor.lnum)
7222 {
7223 char_u ctrl_o[2];
7224
7225 ctrl_o[0] = Ctrl_O;
7226 ctrl_o[1] = 0;
7227 ins_typebuf(ctrl_o, REMAP_NONE, 0, TRUE, FALSE);
7228 }
7229 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00007230}
7231
7232
7233 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007234ex_read(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007235{
Bram Moolenaardf177f62005-02-22 08:39:57 +00007236 int i;
7237 int empty = (curbuf->b_ml.ml_flags & ML_EMPTY);
7238 linenr_T lnum;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007239
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007240 if (eap->usefilter) // :r!cmd
Bram Moolenaar071d4272004-06-13 20:20:40 +00007241 do_bang(1, eap, FALSE, FALSE, TRUE);
7242 else
7243 {
7244 if (u_save(eap->line2, (linenr_T)(eap->line2 + 1)) == FAIL)
7245 return;
7246
7247#ifdef FEAT_BROWSE
Bram Moolenaare1004402020-10-24 20:49:43 +02007248 if (cmdmod.cmod_flags & CMOD_BROWSE)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007249 {
7250 char_u *browseFile;
7251
Bram Moolenaar7171abe2004-10-11 10:06:20 +00007252 browseFile = do_browse(0, (char_u *)_("Append File"), eap->arg,
Bram Moolenaar071d4272004-06-13 20:20:40 +00007253 NULL, NULL, NULL, curbuf);
7254 if (browseFile != NULL)
7255 {
7256 i = readfile(browseFile, NULL,
7257 eap->line2, (linenr_T)0, (linenr_T)MAXLNUM, eap, 0);
7258 vim_free(browseFile);
7259 }
7260 else
7261 i = OK;
7262 }
7263 else
7264#endif
7265 if (*eap->arg == NUL)
7266 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007267 if (check_fname() == FAIL) // check for no file name
Bram Moolenaar071d4272004-06-13 20:20:40 +00007268 return;
7269 i = readfile(curbuf->b_ffname, curbuf->b_fname,
7270 eap->line2, (linenr_T)0, (linenr_T)MAXLNUM, eap, 0);
7271 }
7272 else
7273 {
7274 if (vim_strchr(p_cpo, CPO_ALTREAD) != NULL)
7275 (void)setaltfname(eap->arg, eap->arg, (linenr_T)1);
7276 i = readfile(eap->arg, NULL,
7277 eap->line2, (linenr_T)0, (linenr_T)MAXLNUM, eap, 0);
7278
7279 }
Bram Moolenaare13b9af2017-01-13 22:01:02 +01007280 if (i != OK)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007281 {
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01007282#if defined(FEAT_EVAL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007283 if (!aborting())
7284#endif
Bram Moolenaar460ae5d2022-01-01 14:19:49 +00007285 semsg(_(e_cant_open_file_str), eap->arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007286 }
7287 else
Bram Moolenaardf177f62005-02-22 08:39:57 +00007288 {
7289 if (empty && exmode_active)
7290 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007291 // Delete the empty line that remains. Historically ex does
7292 // this but vi doesn't.
Bram Moolenaardf177f62005-02-22 08:39:57 +00007293 if (eap->line2 == 0)
7294 lnum = curbuf->b_ml.ml_line_count;
7295 else
7296 lnum = 1;
Bram Moolenaarcef9dcc2005-12-06 19:50:41 +00007297 if (*ml_get(lnum) == NUL && u_savedel(lnum, 1L) == OK)
Bram Moolenaardf177f62005-02-22 08:39:57 +00007298 {
Bram Moolenaarca70c072020-05-30 20:30:46 +02007299 ml_delete(lnum);
Bram Moolenaarcef9dcc2005-12-06 19:50:41 +00007300 if (curwin->w_cursor.lnum > 1
7301 && curwin->w_cursor.lnum >= lnum)
Bram Moolenaardf177f62005-02-22 08:39:57 +00007302 --curwin->w_cursor.lnum;
Bram Moolenaarcdcaa582009-07-09 18:06:49 +00007303 deleted_lines_mark(lnum, 1L);
Bram Moolenaardf177f62005-02-22 08:39:57 +00007304 }
7305 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00007306 redraw_curbuf_later(VALID);
Bram Moolenaardf177f62005-02-22 08:39:57 +00007307 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00007308 }
7309}
7310
Bram Moolenaarea408852005-06-25 22:49:46 +00007311static char_u *prev_dir = NULL;
7312
7313#if defined(EXITFREE) || defined(PROTO)
7314 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007315free_cd_dir(void)
Bram Moolenaarea408852005-06-25 22:49:46 +00007316{
Bram Moolenaard23a8232018-02-10 18:45:26 +01007317 VIM_CLEAR(prev_dir);
7318 VIM_CLEAR(globaldir);
Bram Moolenaarea408852005-06-25 22:49:46 +00007319}
7320#endif
7321
Bram Moolenaarf4258302013-06-02 18:20:17 +02007322/*
Bram Moolenaar002bc792020-06-05 22:33:42 +02007323 * Get the previous directory for the given chdir scope.
7324 */
7325 static char_u *
7326get_prevdir(cdscope_T scope)
7327{
7328 if (scope == CDSCOPE_WINDOW)
7329 return curwin->w_prevdir;
7330 else if (scope == CDSCOPE_TABPAGE)
7331 return curtab->tp_prevdir;
7332 return prev_dir;
7333}
7334
7335/*
Bram Moolenaarf4258302013-06-02 18:20:17 +02007336 * Deal with the side effects of changing the current directory.
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007337 * When 'scope' is CDSCOPE_TABPAGE then this was after an ":tcd" command.
7338 * When 'scope' is CDSCOPE_WINDOW then this was after an ":lcd" command.
Bram Moolenaarf4258302013-06-02 18:20:17 +02007339 */
7340 void
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007341post_chdir(cdscope_T scope)
Bram Moolenaarf4258302013-06-02 18:20:17 +02007342{
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007343 if (scope != CDSCOPE_WINDOW)
Bram Moolenaar00aa0692019-04-27 20:37:57 +02007344 // Clear tab local directory for both :cd and :tcd
7345 VIM_CLEAR(curtab->tp_localdir);
Bram Moolenaard23a8232018-02-10 18:45:26 +01007346 VIM_CLEAR(curwin->w_localdir);
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007347 if (scope != CDSCOPE_GLOBAL)
Bram Moolenaarf4258302013-06-02 18:20:17 +02007348 {
Bram Moolenaar002bc792020-06-05 22:33:42 +02007349 char_u *pdir = get_prevdir(scope);
7350
7351 // If still in the global directory, need to remember current
7352 // directory as the global directory.
7353 if (globaldir == NULL && pdir != NULL)
7354 globaldir = vim_strsave(pdir);
7355
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007356 // Remember this local directory for the window.
Bram Moolenaarf4258302013-06-02 18:20:17 +02007357 if (mch_dirname(NameBuff, MAXPATHL) == OK)
Bram Moolenaar00aa0692019-04-27 20:37:57 +02007358 {
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007359 if (scope == CDSCOPE_TABPAGE)
Bram Moolenaar00aa0692019-04-27 20:37:57 +02007360 curtab->tp_localdir = vim_strsave(NameBuff);
7361 else
7362 curwin->w_localdir = vim_strsave(NameBuff);
7363 }
Bram Moolenaarf4258302013-06-02 18:20:17 +02007364 }
7365 else
7366 {
Bram Moolenaar002bc792020-06-05 22:33:42 +02007367 // We are now in the global directory, no need to remember its name.
Bram Moolenaard23a8232018-02-10 18:45:26 +01007368 VIM_CLEAR(globaldir);
Bram Moolenaarf4258302013-06-02 18:20:17 +02007369 }
7370
zeertzjq64be6aa2021-11-19 11:59:08 +00007371 last_chdir_reason = NULL;
Bram Moolenaarf4258302013-06-02 18:20:17 +02007372 shorten_fnames(TRUE);
7373}
7374
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007375/*
Bram Moolenaar28e8f732022-02-09 12:58:20 +00007376 * Trigger DirChangedPre for "acmd_fname" with directory "new_dir".
7377 */
7378 void
7379trigger_DirChangedPre(char_u *acmd_fname, char_u *new_dir)
7380{
7381#ifdef FEAT_EVAL
7382 dict_T *v_event;
7383 save_v_event_T save_v_event;
7384
7385 v_event = get_v_event(&save_v_event);
7386 (void)dict_add_string(v_event, "directory", new_dir);
7387 dict_set_items_ro(v_event);
7388#endif
7389 apply_autocmds(EVENT_DIRCHANGEDPRE, acmd_fname, new_dir, FALSE, curbuf);
7390#ifdef FEAT_EVAL
7391 restore_v_event(v_event, &save_v_event);
7392#endif
7393}
7394
7395/*
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007396 * Change directory function used by :cd/:tcd/:lcd Ex commands and the
Bram Moolenaar95058722020-06-01 16:26:19 +02007397 * chdir() function.
7398 * scope == CDSCOPE_WINDOW: changes the window-local directory
7399 * scope == CDSCOPE_TABPAGE: changes the tab-local directory
7400 * Otherwise: changes the global directory
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007401 * Returns TRUE if the directory is successfully changed.
7402 */
7403 int
7404changedir_func(
7405 char_u *new_dir,
7406 int forceit,
7407 cdscope_T scope)
7408{
Bram Moolenaar002bc792020-06-05 22:33:42 +02007409 char_u *pdir = NULL;
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007410 int dir_differs;
Bram Moolenaar28e8f732022-02-09 12:58:20 +00007411 char_u *acmd_fname = NULL;
zeertzjq73257142022-02-02 13:16:37 +00007412 char_u **pp;
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007413
Bram Moolenaar7cc96922020-01-31 22:41:38 +01007414 if (new_dir == NULL || allbuf_locked())
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007415 return FALSE;
7416
7417 if (vim_strchr(p_cpo, CPO_CHDIR) != NULL && curbufIsChanged() && !forceit)
7418 {
Bram Moolenaar677658a2022-01-05 16:09:06 +00007419 emsg(_(e_cannot_change_directory_buffer_is_modified_add_bang_to_override));
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007420 return FALSE;
7421 }
7422
7423 // ":cd -": Change to previous directory
7424 if (STRCMP(new_dir, "-") == 0)
7425 {
Bram Moolenaar002bc792020-06-05 22:33:42 +02007426 pdir = get_prevdir(scope);
7427 if (pdir == NULL)
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007428 {
Bram Moolenaar1a992222021-12-31 17:25:48 +00007429 emsg(_(e_no_previous_directory));
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007430 return FALSE;
7431 }
Bram Moolenaar002bc792020-06-05 22:33:42 +02007432 new_dir = pdir;
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007433 }
7434
7435 // Save current directory for next ":cd -"
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007436 if (mch_dirname(NameBuff, MAXPATHL) == OK)
Bram Moolenaar002bc792020-06-05 22:33:42 +02007437 pdir = vim_strsave(NameBuff);
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007438 else
Bram Moolenaar002bc792020-06-05 22:33:42 +02007439 pdir = NULL;
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007440
Bakudankun29f3a452021-12-11 12:28:08 +00007441 // For UNIX ":cd" means: go to home directory.
7442 // On other systems too if 'cdhome' is set.
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007443#if defined(UNIX) || defined(VMS)
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007444 if (*new_dir == NUL)
Bakudankun29f3a452021-12-11 12:28:08 +00007445#else
7446 if (*new_dir == NUL && p_cdh)
7447#endif
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007448 {
7449 // use NameBuff for home directory name
7450# ifdef VMS
7451 char_u *p;
7452
7453 p = mch_getenv((char_u *)"SYS$LOGIN");
7454 if (p == NULL || *p == NUL) // empty is the same as not set
7455 NameBuff[0] = NUL;
7456 else
7457 vim_strncpy(NameBuff, p, MAXPATHL - 1);
7458# else
7459 expand_env((char_u *)"$HOME", NameBuff, MAXPATHL);
7460# endif
7461 new_dir = NameBuff;
7462 }
zeertzjqf38aad82021-12-30 13:45:57 +00007463 dir_differs = pdir == NULL
Bram Moolenaar28e8f732022-02-09 12:58:20 +00007464 || pathcmp((char *)pdir, (char *)new_dir, -1) != 0;
7465 if (dir_differs)
Richard Doty3d0abad2021-12-29 14:39:08 +00007466 {
Bram Moolenaar28e8f732022-02-09 12:58:20 +00007467 if (scope == CDSCOPE_WINDOW)
7468 acmd_fname = (char_u *)"window";
7469 else if (scope == CDSCOPE_TABPAGE)
7470 acmd_fname = (char_u *)"tabpage";
7471 else
7472 acmd_fname = (char_u *)"global";
7473 trigger_DirChangedPre(acmd_fname, new_dir);
7474
7475 if (vim_chdir(new_dir))
7476 {
7477 emsg(_(e_command_failed));
7478 vim_free(pdir);
7479 return FALSE;
7480 }
Richard Doty3d0abad2021-12-29 14:39:08 +00007481 }
zeertzjq73257142022-02-02 13:16:37 +00007482
7483 if (scope == CDSCOPE_WINDOW)
7484 pp = &curwin->w_prevdir;
7485 else if (scope == CDSCOPE_TABPAGE)
7486 pp = &curtab->tp_prevdir;
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007487 else
zeertzjq73257142022-02-02 13:16:37 +00007488 pp = &prev_dir;
7489 vim_free(*pp);
7490 *pp = pdir;
7491
7492 post_chdir(scope);
7493
7494 if (dir_differs)
Bram Moolenaar28e8f732022-02-09 12:58:20 +00007495 apply_autocmds(EVENT_DIRCHANGED, acmd_fname, new_dir, FALSE, curbuf);
zeertzjq73257142022-02-02 13:16:37 +00007496 return TRUE;
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007497}
Bram Moolenaarea408852005-06-25 22:49:46 +00007498
Bram Moolenaar071d4272004-06-13 20:20:40 +00007499/*
Bram Moolenaar00aa0692019-04-27 20:37:57 +02007500 * ":cd", ":tcd", ":lcd", ":chdir" ":tchdir" and ":lchdir".
Bram Moolenaar071d4272004-06-13 20:20:40 +00007501 */
Bram Moolenaard089d9b2007-09-30 12:02:55 +00007502 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007503ex_cd(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007504{
Bram Moolenaar2caad3f2018-12-16 15:38:02 +01007505 char_u *new_dir;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007506
7507 new_dir = eap->arg;
7508#if !defined(UNIX) && !defined(VMS)
Bakudankun29f3a452021-12-11 12:28:08 +00007509 // for non-UNIX ":cd" means: print current directory unless 'cdhome' is set
7510 if (*new_dir == NUL && !p_cdh)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007511 ex_pwd(NULL);
7512 else
7513#endif
7514 {
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007515 cdscope_T scope = CDSCOPE_GLOBAL;
7516
7517 if (eap->cmdidx == CMD_lcd || eap->cmdidx == CMD_lchdir)
7518 scope = CDSCOPE_WINDOW;
7519 else if (eap->cmdidx == CMD_tcd || eap->cmdidx == CMD_tchdir)
7520 scope = CDSCOPE_TABPAGE;
7521
7522 if (changedir_func(new_dir, eap->forceit, scope))
Bram Moolenaardf177f62005-02-22 08:39:57 +00007523 {
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007524 // Echo the new current directory if the command was typed.
Bram Moolenaarfcfbc672009-07-09 18:13:49 +00007525 if (KeyTyped || p_verbose >= 5)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007526 ex_pwd(eap);
7527 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00007528 }
7529}
7530
7531/*
7532 * ":pwd".
7533 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00007534 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007535ex_pwd(exarg_T *eap UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007536{
7537 if (mch_dirname(NameBuff, MAXPATHL) == OK)
7538 {
7539#ifdef BACKSLASH_IN_FILENAME
7540 slash_adjust(NameBuff);
7541#endif
Bram Moolenaar95058722020-06-01 16:26:19 +02007542 if (p_verbose > 0)
7543 {
7544 char *context = "global";
7545
Bram Moolenaar05268152021-11-18 18:53:45 +00007546 if (last_chdir_reason != NULL)
7547 context = last_chdir_reason;
7548 else if (curwin->w_localdir != NULL)
Bram Moolenaar95058722020-06-01 16:26:19 +02007549 context = "window";
7550 else if (curtab->tp_localdir != NULL)
7551 context = "tabpage";
7552 smsg("[%s] %s", context, (char *)NameBuff);
7553 }
7554 else
7555 msg((char *)NameBuff);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007556 }
7557 else
Bram Moolenaar1a992222021-12-31 17:25:48 +00007558 emsg(_(e_directory_unknown));
Bram Moolenaar071d4272004-06-13 20:20:40 +00007559}
7560
7561/*
7562 * ":=".
7563 */
7564 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007565ex_equal(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007566{
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01007567 smsg("%ld", (long)eap->line2);
Bram Moolenaardf177f62005-02-22 08:39:57 +00007568 ex_may_print(eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007569}
7570
7571 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007572ex_sleep(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007573{
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00007574 int n;
7575 long len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007576
7577 if (cursor_valid())
7578 {
7579 n = W_WINROW(curwin) + curwin->w_wrow - msg_scrolled;
7580 if (n >= 0)
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +00007581 windgoto(n, curwin->w_wincol + curwin->w_wcol);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007582 }
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00007583
7584 len = eap->line2;
7585 switch (*eap->arg)
7586 {
7587 case 'm': break;
7588 case NUL: len *= 1000L; break;
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00007589 default: semsg(_(e_invalid_argument_str), eap->arg); return;
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00007590 }
Bram Moolenaare2edc2e2021-01-16 20:21:23 +01007591
7592 // Hide the cursor if invoked with !
7593 do_sleep(len, eap->forceit);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007594}
7595
7596/*
7597 * Sleep for "msec" milliseconds, but keep checking for a CTRL-C every second.
Bram Moolenaare2edc2e2021-01-16 20:21:23 +01007598 * Hide the cursor if "hide_cursor" is TRUE.
Bram Moolenaar071d4272004-06-13 20:20:40 +00007599 */
7600 void
Bram Moolenaare2edc2e2021-01-16 20:21:23 +01007601do_sleep(long msec, int hide_cursor)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007602{
Bram Moolenaar52953192019-08-16 10:27:13 +02007603 long done = 0;
Bram Moolenaar975b5272016-03-15 23:10:59 +01007604 long wait_now;
Bram Moolenaar52953192019-08-16 10:27:13 +02007605# ifdef ELAPSED_FUNC
7606 elapsed_T start_tv;
7607
7608 // Remember at what time we started, so that we know how much longer we
7609 // should wait after waiting for a bit.
7610 ELAPSED_INIT(start_tv);
7611# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00007612
Bram Moolenaare2edc2e2021-01-16 20:21:23 +01007613 if (hide_cursor)
Richard Doty3d0abad2021-12-29 14:39:08 +00007614 cursor_sleep();
Bram Moolenaare2edc2e2021-01-16 20:21:23 +01007615 else
Richard Doty3d0abad2021-12-29 14:39:08 +00007616 cursor_on();
Bram Moolenaare2edc2e2021-01-16 20:21:23 +01007617
Bram Moolenaarf45d7472018-09-30 18:22:26 +02007618 out_flush_cursor(FALSE, FALSE);
Bram Moolenaar52953192019-08-16 10:27:13 +02007619 while (!got_int && done < msec)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007620 {
Bram Moolenaar975b5272016-03-15 23:10:59 +01007621 wait_now = msec - done > 1000L ? 1000L : msec - done;
7622#ifdef FEAT_TIMERS
7623 {
7624 long due_time = check_due_timer();
7625
7626 if (due_time > 0 && due_time < wait_now)
7627 wait_now = due_time;
7628 }
7629#endif
Bram Moolenaarb9c31e72016-09-29 15:18:57 +02007630#ifdef FEAT_JOB_CHANNEL
Bram Moolenaar28e67e02019-08-15 23:05:49 +02007631 if (has_any_channel() && wait_now > 20L)
7632 wait_now = 20L;
7633#endif
7634#ifdef FEAT_SOUND
7635 if (has_any_sound_callback() && wait_now > 20L)
7636 wait_now = 20L;
Bram Moolenaarb9c31e72016-09-29 15:18:57 +02007637#endif
Bram Moolenaar975b5272016-03-15 23:10:59 +01007638 ui_delay(wait_now, TRUE);
Bram Moolenaar52953192019-08-16 10:27:13 +02007639
Bram Moolenaarb9c31e72016-09-29 15:18:57 +02007640#ifdef FEAT_JOB_CHANNEL
7641 if (has_any_channel())
7642 ui_breakcheck_force(TRUE);
7643 else
7644#endif
7645 ui_breakcheck();
Bram Moolenaar93c88e02015-09-15 14:12:05 +02007646#ifdef MESSAGE_QUEUE
Bram Moolenaar52953192019-08-16 10:27:13 +02007647 // Process the netbeans and clientserver messages that may have been
7648 // received in the call to ui_breakcheck() when the GUI is in use. This
7649 // may occur when running a test case.
Bram Moolenaar93c88e02015-09-15 14:12:05 +02007650 parse_queued_messages();
Bram Moolenaare3cc6d42011-10-20 21:58:34 +02007651#endif
Bram Moolenaar52953192019-08-16 10:27:13 +02007652
7653# ifdef ELAPSED_FUNC
7654 // actual time passed
7655 done = ELAPSED_FUNC(start_tv);
7656# else
7657 // guestimate time passed (will actually be more)
7658 done += wait_now;
7659# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00007660 }
Bram Moolenaar1ebff3d2018-07-07 16:18:13 +02007661
7662 // If CTRL-C was typed to interrupt the sleep, drop the CTRL-C from the
7663 // input buffer, otherwise a following call to input() fails.
7664 if (got_int)
7665 (void)vpeekc();
Bram Moolenaar09f067f2021-04-11 13:29:18 +02007666
7667 if (hide_cursor)
Richard Doty3d0abad2021-12-29 14:39:08 +00007668 cursor_unsleep();
Bram Moolenaar071d4272004-06-13 20:20:40 +00007669}
7670
Bram Moolenaar071d4272004-06-13 20:20:40 +00007671/*
7672 * ":winsize" command (obsolete).
7673 */
7674 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007675ex_winsize(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007676{
7677 int w, h;
7678 char_u *arg = eap->arg;
7679 char_u *p;
7680
Bram Moolenaarf5a51162021-02-06 12:58:18 +01007681 if (!isdigit(*arg))
7682 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00007683 semsg(_(e_invalid_argument_str), arg);
Bram Moolenaarf5a51162021-02-06 12:58:18 +01007684 return;
7685 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00007686 w = getdigits(&arg);
7687 arg = skipwhite(arg);
7688 p = arg;
7689 h = getdigits(&arg);
7690 if (*p != NUL && *arg == NUL)
7691 set_shellsize(w, h, TRUE);
7692 else
Bram Moolenaarb09feaa2022-01-02 20:20:45 +00007693 emsg(_(e_winsize_requires_two_number_arguments));
Bram Moolenaar071d4272004-06-13 20:20:40 +00007694}
7695
Bram Moolenaar071d4272004-06-13 20:20:40 +00007696 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007697ex_wincmd(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007698{
7699 int xchar = NUL;
7700 char_u *p;
7701
7702 if (*eap->arg == 'g' || *eap->arg == Ctrl_G)
7703 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007704 // CTRL-W g and CTRL-W CTRL-G have an extra command character
Bram Moolenaar071d4272004-06-13 20:20:40 +00007705 if (eap->arg[1] == NUL)
7706 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00007707 emsg(_(e_invalid_argument));
Bram Moolenaar071d4272004-06-13 20:20:40 +00007708 return;
7709 }
7710 xchar = eap->arg[1];
7711 p = eap->arg + 2;
7712 }
7713 else
7714 p = eap->arg + 1;
7715
Bram Moolenaar63b91732021-08-05 20:40:03 +02007716 set_nextcmd(eap, p);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007717 p = skipwhite(p);
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02007718 if (*p != NUL && *p != (
7719#ifdef FEAT_EVAL
7720 in_vim9script() ? '#' :
7721#endif
7722 '"')
7723 && eap->nextcmd == NULL)
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00007724 emsg(_(e_invalid_argument));
Bram Moolenaar12bde492011-06-13 01:19:56 +02007725 else if (!eap->skip)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007726 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007727 // Pass flags on for ":vertical wincmd ]".
Bram Moolenaare1004402020-10-24 20:49:43 +02007728 postponed_split_flags = cmdmod.cmod_split;
7729 postponed_split_tab = cmdmod.cmod_tab;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007730 do_window(*eap->arg, eap->addr_count > 0 ? eap->line2 : 0L, xchar);
7731 postponed_split_flags = 0;
Bram Moolenaard326ce82007-03-11 14:48:29 +00007732 postponed_split_tab = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007733 }
7734}
Bram Moolenaar071d4272004-06-13 20:20:40 +00007735
Bram Moolenaar843ee412004-06-30 16:16:41 +00007736#if defined(FEAT_GUI) || defined(UNIX) || defined(VMS) || defined(MSWIN)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007737/*
7738 * ":winpos".
7739 */
7740 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007741ex_winpos(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007742{
7743 int x, y;
7744 char_u *arg = eap->arg;
7745 char_u *p;
7746
7747 if (*arg == NUL)
7748 {
Bram Moolenaar843ee412004-06-30 16:16:41 +00007749# if defined(FEAT_GUI) || defined(MSWIN)
Bram Moolenaarafde13b2019-04-28 19:46:49 +02007750# ifdef VIMDLL
7751 if (gui.in_use ? gui_mch_get_winpos(&x, &y) != FAIL :
7752 mch_get_winpos(&x, &y) != FAIL)
7753# elif defined(FEAT_GUI)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007754 if (gui.in_use && gui_mch_get_winpos(&x, &y) != FAIL)
Bram Moolenaar843ee412004-06-30 16:16:41 +00007755# else
7756 if (mch_get_winpos(&x, &y) != FAIL)
7757# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00007758 {
7759 sprintf((char *)IObuff, _("Window position: X %d, Y %d"), x, y);
Bram Moolenaar32526b32019-01-19 17:43:09 +01007760 msg((char *)IObuff);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007761 }
7762 else
7763# endif
Bram Moolenaar1a992222021-12-31 17:25:48 +00007764 emsg(_(e_obtaining_window_position_not_implemented_for_this_platform));
Bram Moolenaar071d4272004-06-13 20:20:40 +00007765 }
7766 else
7767 {
7768 x = getdigits(&arg);
7769 arg = skipwhite(arg);
7770 p = arg;
7771 y = getdigits(&arg);
7772 if (*p == NUL || *arg != NUL)
7773 {
Bram Moolenaarb09feaa2022-01-02 20:20:45 +00007774 emsg(_(e_winpos_requires_two_number_arguments));
Bram Moolenaar071d4272004-06-13 20:20:40 +00007775 return;
7776 }
7777# ifdef FEAT_GUI
7778 if (gui.in_use)
7779 gui_mch_set_winpos(x, y);
7780 else if (gui.starting)
7781 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007782 // Remember the coordinates for when the window is opened.
Bram Moolenaar071d4272004-06-13 20:20:40 +00007783 gui_win_x = x;
7784 gui_win_y = y;
7785 }
Bram Moolenaarafde13b2019-04-28 19:46:49 +02007786# if defined(HAVE_TGETENT) || defined(VIMDLL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007787 else
7788# endif
Bram Moolenaarafde13b2019-04-28 19:46:49 +02007789# endif
7790# if defined(MSWIN) && (!defined(FEAT_GUI) || defined(VIMDLL))
Bram Moolenaar843ee412004-06-30 16:16:41 +00007791 mch_set_winpos(x, y);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007792# endif
7793# ifdef HAVE_TGETENT
7794 if (*T_CWP)
7795 term_set_winpos(x, y);
7796# endif
7797 }
7798}
7799#endif
7800
7801/*
7802 * Handle command that work like operators: ":delete", ":yank", ":>" and ":<".
7803 */
7804 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007805ex_operators(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007806{
7807 oparg_T oa;
7808
7809 clear_oparg(&oa);
7810 oa.regname = eap->regname;
7811 oa.start.lnum = eap->line1;
7812 oa.end.lnum = eap->line2;
7813 oa.line_count = eap->line2 - eap->line1 + 1;
7814 oa.motion_type = MLINE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007815 virtual_op = FALSE;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007816 if (eap->cmdidx != CMD_yank) // position cursor for undo
Bram Moolenaar071d4272004-06-13 20:20:40 +00007817 {
7818 setpcmark();
7819 curwin->w_cursor.lnum = eap->line1;
7820 beginline(BL_SOL | BL_FIX);
7821 }
7822
Bram Moolenaard07c6e12013-11-21 14:21:40 +01007823 if (VIsual_active)
7824 end_visual_mode();
Bram Moolenaard07c6e12013-11-21 14:21:40 +01007825
Bram Moolenaar071d4272004-06-13 20:20:40 +00007826 switch (eap->cmdidx)
7827 {
7828 case CMD_delete:
7829 oa.op_type = OP_DELETE;
7830 op_delete(&oa);
7831 break;
7832
7833 case CMD_yank:
7834 oa.op_type = OP_YANK;
7835 (void)op_yank(&oa, FALSE, TRUE);
7836 break;
7837
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007838 default: // CMD_rshift or CMD_lshift
Bram Moolenaar6e707362013-06-14 19:15:58 +02007839 if (
Bram Moolenaar071d4272004-06-13 20:20:40 +00007840#ifdef FEAT_RIGHTLEFT
Bram Moolenaar6e707362013-06-14 19:15:58 +02007841 (eap->cmdidx == CMD_rshift) ^ curwin->w_p_rl
7842#else
7843 eap->cmdidx == CMD_rshift
Bram Moolenaar071d4272004-06-13 20:20:40 +00007844#endif
Bram Moolenaar6e707362013-06-14 19:15:58 +02007845 )
Bram Moolenaar071d4272004-06-13 20:20:40 +00007846 oa.op_type = OP_RSHIFT;
7847 else
7848 oa.op_type = OP_LSHIFT;
7849 op_shift(&oa, FALSE, eap->amount);
7850 break;
7851 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00007852 virtual_op = MAYBE;
Bram Moolenaardf177f62005-02-22 08:39:57 +00007853 ex_may_print(eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007854}
7855
7856/*
7857 * ":put".
7858 */
7859 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007860ex_put(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007861{
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007862 // ":0put" works like ":1put!".
Bram Moolenaar071d4272004-06-13 20:20:40 +00007863 if (eap->line2 == 0)
7864 {
7865 eap->line2 = 1;
7866 eap->forceit = TRUE;
7867 }
7868 curwin->w_cursor.lnum = eap->line2;
Bram Moolenaar0b5b06c2021-11-04 15:10:11 +00007869 check_cursor_col();
Bram Moolenaarc3516f72020-09-08 22:45:35 +02007870 do_put(eap->regname, NULL, eap->forceit ? BACKWARD : FORWARD, 1L,
Bram Moolenaardf177f62005-02-22 08:39:57 +00007871 PUT_LINE|PUT_CURSLINE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007872}
7873
7874/*
7875 * Handle ":copy" and ":move".
7876 */
7877 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007878ex_copymove(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007879{
7880 long n;
7881
Bram Moolenaar491799b2020-08-01 19:23:43 +02007882#ifdef FEAT_EVAL
Bram Moolenaarf5a48012020-08-01 17:00:03 +02007883 if (not_in_vim9(eap) == FAIL)
7884 return;
Bram Moolenaar491799b2020-08-01 19:23:43 +02007885#endif
Bram Moolenaar50eb16c2018-09-15 15:42:40 +02007886 n = get_address(eap, &eap->arg, eap->addr_type, FALSE, FALSE, FALSE, 1);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007887 if (eap->arg == NULL) // error detected
Bram Moolenaar071d4272004-06-13 20:20:40 +00007888 {
7889 eap->nextcmd = NULL;
7890 return;
7891 }
Bram Moolenaardf177f62005-02-22 08:39:57 +00007892 get_flags(eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007893
7894 /*
7895 * move or copy lines from 'eap->line1'-'eap->line2' to below line 'n'
7896 */
7897 if (n == MAXLNUM || n < 0 || n > curbuf->b_ml.ml_line_count)
7898 {
Bram Moolenaar108010a2021-06-27 22:03:33 +02007899 emsg(_(e_invalid_range));
Bram Moolenaar071d4272004-06-13 20:20:40 +00007900 return;
7901 }
7902
7903 if (eap->cmdidx == CMD_move)
7904 {
7905 if (do_move(eap->line1, eap->line2, n) == FAIL)
7906 return;
7907 }
7908 else
7909 ex_copy(eap->line1, eap->line2, n);
7910 u_clearline();
7911 beginline(BL_SOL | BL_FIX);
Bram Moolenaardf177f62005-02-22 08:39:57 +00007912 ex_may_print(eap);
7913}
7914
7915/*
7916 * Print the current line if flags were given to the Ex command.
7917 */
Bram Moolenaarfd3fe982014-04-01 17:49:44 +02007918 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007919ex_may_print(exarg_T *eap)
Bram Moolenaardf177f62005-02-22 08:39:57 +00007920{
7921 if (eap->flags != 0)
7922 {
7923 print_line(curwin->w_cursor.lnum, (eap->flags & EXFLAG_NR),
7924 (eap->flags & EXFLAG_LIST));
7925 ex_no_reprint = TRUE;
7926 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00007927}
7928
7929/*
7930 * ":smagic" and ":snomagic".
7931 */
7932 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007933ex_submagic(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007934{
Bram Moolenaard93a7fc2021-01-04 12:42:13 +01007935 optmagic_T saved = magic_overruled;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007936
Bram Moolenaard93a7fc2021-01-04 12:42:13 +01007937 magic_overruled = eap->cmdidx == CMD_smagic
7938 ? OPTION_MAGIC_ON : OPTION_MAGIC_OFF;
Bram Moolenaar66e00142020-08-12 21:58:12 +02007939 ex_substitute(eap);
Bram Moolenaarf4e20992020-12-21 19:59:08 +01007940 magic_overruled = saved;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007941}
7942
7943/*
7944 * ":join".
7945 */
7946 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007947ex_join(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007948{
7949 curwin->w_cursor.lnum = eap->line1;
7950 if (eap->line1 == eap->line2)
7951 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007952 if (eap->addr_count >= 2) // :2,2join does nothing
Bram Moolenaar071d4272004-06-13 20:20:40 +00007953 return;
7954 if (eap->line2 == curbuf->b_ml.ml_line_count)
7955 {
7956 beep_flush();
7957 return;
7958 }
7959 ++eap->line2;
7960 }
Bram Moolenaard69bd9a2014-04-29 12:15:40 +02007961 (void)do_join(eap->line2 - eap->line1 + 1, !eap->forceit, TRUE, TRUE, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007962 beginline(BL_WHITE | BL_FIX);
Bram Moolenaardf177f62005-02-22 08:39:57 +00007963 ex_may_print(eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007964}
7965
7966/*
7967 * ":[addr]@r" or ":[addr]*r": execute register
7968 */
7969 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007970ex_at(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007971{
7972 int c;
Bram Moolenaar60462872009-11-03 11:40:19 +00007973 int prev_len = typebuf.tb_len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007974
7975 curwin->w_cursor.lnum = eap->line2;
Bram Moolenaar4930a762016-09-11 14:39:53 +02007976 check_cursor_col();
Bram Moolenaar071d4272004-06-13 20:20:40 +00007977
7978#ifdef USE_ON_FLY_SCROLL
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007979 dont_scroll = TRUE; // disallow scrolling here
Bram Moolenaar071d4272004-06-13 20:20:40 +00007980#endif
7981
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007982 // get the register name. No name means to use the previous one
Bram Moolenaar071d4272004-06-13 20:20:40 +00007983 c = *eap->arg;
7984 if (c == NUL || (c == '*' && *eap->cmd == '*'))
7985 c = '@';
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007986 // Put the register in the typeahead buffer with the "silent" flag.
Bram Moolenaard333d1e2006-11-07 17:43:47 +00007987 if (do_execreg(c, TRUE, vim_strchr(p_cpo, CPO_EXECBUF) != NULL, TRUE)
7988 == FAIL)
Bram Moolenaardf177f62005-02-22 08:39:57 +00007989 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00007990 beep_flush();
Bram Moolenaardf177f62005-02-22 08:39:57 +00007991 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00007992 else
7993 {
7994 int save_efr = exec_from_reg;
7995
7996 exec_from_reg = TRUE;
7997
7998 /*
7999 * Execute from the typeahead buffer.
Bram Moolenaar60462872009-11-03 11:40:19 +00008000 * Continue until the stuff buffer is empty and all added characters
8001 * have been consumed.
Bram Moolenaar071d4272004-06-13 20:20:40 +00008002 */
Bram Moolenaar60462872009-11-03 11:40:19 +00008003 while (!stuff_empty() || typebuf.tb_len > prev_len)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008004 (void)do_cmdline(NULL, getexline, NULL, DOCMD_NOWAIT|DOCMD_VERBOSE);
8005
8006 exec_from_reg = save_efr;
8007 }
8008}
8009
8010/*
8011 * ":!".
8012 */
8013 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008014ex_bang(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008015{
8016 do_bang(eap->addr_count, eap, eap->forceit, TRUE, TRUE);
8017}
8018
8019/*
8020 * ":undo".
8021 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00008022 static void
Bram Moolenaarf1d25012016-03-03 12:22:53 +01008023ex_undo(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008024{
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008025 if (eap->addr_count == 1) // :undo 123
Bram Moolenaar730cde92010-06-27 05:18:54 +02008026 undo_time(eap->line2, FALSE, FALSE, TRUE);
Bram Moolenaard3667a22006-03-16 21:35:52 +00008027 else
8028 u_undo(1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008029}
8030
Bram Moolenaar55debbe2010-05-23 23:34:36 +02008031#ifdef FEAT_PERSISTENT_UNDO
Bram Moolenaar6df6f472010-07-18 18:04:50 +02008032 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008033ex_wundo(exarg_T *eap)
Bram Moolenaar55debbe2010-05-23 23:34:36 +02008034{
8035 char_u hash[UNDO_HASH_SIZE];
8036
8037 u_compute_hash(hash);
8038 u_write_undo(eap->arg, eap->forceit, curbuf, hash);
8039}
8040
Bram Moolenaar6df6f472010-07-18 18:04:50 +02008041 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008042ex_rundo(exarg_T *eap)
Bram Moolenaar55debbe2010-05-23 23:34:36 +02008043{
8044 char_u hash[UNDO_HASH_SIZE];
8045
8046 u_compute_hash(hash);
Bram Moolenaar6ed8ed82010-05-30 20:40:11 +02008047 u_read_undo(eap->arg, hash, NULL);
Bram Moolenaar55debbe2010-05-23 23:34:36 +02008048}
8049#endif
8050
Bram Moolenaar071d4272004-06-13 20:20:40 +00008051/*
8052 * ":redo".
8053 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00008054 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008055ex_redo(exarg_T *eap UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008056{
8057 u_redo(1);
8058}
8059
8060/*
Bram Moolenaarc7d89352006-03-14 22:53:34 +00008061 * ":earlier" and ":later".
8062 */
Bram Moolenaarc7d89352006-03-14 22:53:34 +00008063 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008064ex_later(exarg_T *eap)
Bram Moolenaarc7d89352006-03-14 22:53:34 +00008065{
8066 long count = 0;
8067 int sec = FALSE;
Bram Moolenaar730cde92010-06-27 05:18:54 +02008068 int file = FALSE;
Bram Moolenaarc7d89352006-03-14 22:53:34 +00008069 char_u *p = eap->arg;
8070
8071 if (*p == NUL)
8072 count = 1;
8073 else if (isdigit(*p))
8074 {
8075 count = getdigits(&p);
8076 switch (*p)
8077 {
8078 case 's': ++p; sec = TRUE; break;
8079 case 'm': ++p; sec = TRUE; count *= 60; break;
8080 case 'h': ++p; sec = TRUE; count *= 60 * 60; break;
Bram Moolenaar730cde92010-06-27 05:18:54 +02008081 case 'd': ++p; sec = TRUE; count *= 24 * 60 * 60; break;
8082 case 'f': ++p; file = TRUE; break;
Bram Moolenaarc7d89352006-03-14 22:53:34 +00008083 }
8084 }
8085
8086 if (*p != NUL)
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00008087 semsg(_(e_invalid_argument_str), eap->arg);
Bram Moolenaarc7d89352006-03-14 22:53:34 +00008088 else
Bram Moolenaar730cde92010-06-27 05:18:54 +02008089 undo_time(eap->cmdidx == CMD_earlier ? -count : count,
8090 sec, file, FALSE);
Bram Moolenaarc7d89352006-03-14 22:53:34 +00008091}
8092
8093/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00008094 * ":redir": start/stop redirection.
8095 */
8096 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008097ex_redir(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008098{
8099 char *mode;
8100 char_u *fname;
Bram Moolenaarca472992005-01-21 11:46:23 +00008101 char_u *arg = eap->arg;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008102
Bram Moolenaarba768492016-07-08 15:32:54 +02008103#ifdef FEAT_EVAL
Bram Moolenaar79815f12016-07-09 17:07:29 +02008104 if (redir_execute)
Bram Moolenaar245a7cb2016-07-08 10:53:12 +02008105 {
Bram Moolenaard82a47d2022-01-05 20:24:39 +00008106 emsg(_(e_cannot_use_redir_inside_execute));
Bram Moolenaar245a7cb2016-07-08 10:53:12 +02008107 return;
8108 }
Bram Moolenaarba768492016-07-08 15:32:54 +02008109#endif
Bram Moolenaar245a7cb2016-07-08 10:53:12 +02008110
Bram Moolenaar071d4272004-06-13 20:20:40 +00008111 if (STRICMP(eap->arg, "END") == 0)
8112 close_redir();
8113 else
8114 {
Bram Moolenaarca472992005-01-21 11:46:23 +00008115 if (*arg == '>')
Bram Moolenaar071d4272004-06-13 20:20:40 +00008116 {
Bram Moolenaarca472992005-01-21 11:46:23 +00008117 ++arg;
8118 if (*arg == '>')
Bram Moolenaar071d4272004-06-13 20:20:40 +00008119 {
Bram Moolenaarca472992005-01-21 11:46:23 +00008120 ++arg;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008121 mode = "a";
8122 }
8123 else
8124 mode = "w";
Bram Moolenaarca472992005-01-21 11:46:23 +00008125 arg = skipwhite(arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008126
8127 close_redir();
8128
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008129 // Expand environment variables and "~/".
Bram Moolenaarca472992005-01-21 11:46:23 +00008130 fname = expand_env_save(arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008131 if (fname == NULL)
8132 return;
8133#ifdef FEAT_BROWSE
Bram Moolenaare1004402020-10-24 20:49:43 +02008134 if (cmdmod.cmod_flags & CMOD_BROWSE)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008135 {
8136 char_u *browseFile;
8137
Bram Moolenaar7171abe2004-10-11 10:06:20 +00008138 browseFile = do_browse(BROWSE_SAVE,
8139 (char_u *)_("Save Redirection"),
Bram Moolenaarc36651b2018-04-29 12:22:56 +02008140 fname, NULL, NULL,
8141 (char_u *)_(BROWSE_FILTER_ALL_FILES), curbuf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008142 if (browseFile == NULL)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008143 return; // operation cancelled
Bram Moolenaar071d4272004-06-13 20:20:40 +00008144 vim_free(fname);
8145 fname = browseFile;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008146 eap->forceit = TRUE; // since dialog already asked
Bram Moolenaar071d4272004-06-13 20:20:40 +00008147 }
8148#endif
8149
8150 redir_fd = open_exfile(fname, eap->forceit, mode);
8151 vim_free(fname);
8152 }
8153#ifdef FEAT_EVAL
Bram Moolenaarca472992005-01-21 11:46:23 +00008154 else if (*arg == '@')
Bram Moolenaar071d4272004-06-13 20:20:40 +00008155 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008156 // redirect to a register a-z (resp. A-Z for appending)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008157 close_redir();
Bram Moolenaarca472992005-01-21 11:46:23 +00008158 ++arg;
8159 if (ASCII_ISALPHA(*arg)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008160# ifdef FEAT_CLIPBOARD
Bram Moolenaarca472992005-01-21 11:46:23 +00008161 || *arg == '*'
Bram Moolenaar9a51c6e2006-11-14 19:25:02 +00008162 || *arg == '+'
Bram Moolenaar071d4272004-06-13 20:20:40 +00008163# endif
Bram Moolenaarca472992005-01-21 11:46:23 +00008164 || *arg == '"')
Bram Moolenaar071d4272004-06-13 20:20:40 +00008165 {
Bram Moolenaarca472992005-01-21 11:46:23 +00008166 redir_reg = *arg++;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008167 if (*arg == '>' && arg[1] == '>') // append
Bram Moolenaard9d30582005-05-18 22:10:28 +00008168 arg += 2;
Bram Moolenaarc188b882007-10-19 14:20:54 +00008169 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00008170 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008171 // Can use both "@a" and "@a>".
Bram Moolenaar2c29bee2005-06-01 21:46:07 +00008172 if (*arg == '>')
8173 arg++;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008174 // Make register empty when not using @A-@Z and the
8175 // command is valid.
Bram Moolenaarc188b882007-10-19 14:20:54 +00008176 if (*arg == NUL && !isupper(redir_reg))
8177 write_reg_contents(redir_reg, (char_u *)"", -1, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008178 }
Bram Moolenaardf177f62005-02-22 08:39:57 +00008179 }
8180 if (*arg != NUL)
8181 {
Bram Moolenaardf177f62005-02-22 08:39:57 +00008182 redir_reg = 0;
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00008183 semsg(_(e_invalid_argument_str), eap->arg);
Bram Moolenaardf177f62005-02-22 08:39:57 +00008184 }
8185 }
8186 else if (*arg == '=' && arg[1] == '>')
8187 {
8188 int append;
8189
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008190 // redirect to a variable
Bram Moolenaardf177f62005-02-22 08:39:57 +00008191 close_redir();
8192 arg += 2;
8193
8194 if (*arg == '>')
8195 {
8196 ++arg;
8197 append = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008198 }
8199 else
Bram Moolenaardf177f62005-02-22 08:39:57 +00008200 append = FALSE;
8201
8202 if (var_redir_start(skipwhite(arg), append) == OK)
8203 redir_vname = 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008204 }
8205#endif
8206
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008207 // TODO: redirect to a buffer
Bram Moolenaar071d4272004-06-13 20:20:40 +00008208
Bram Moolenaar071d4272004-06-13 20:20:40 +00008209 else
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00008210 semsg(_(e_invalid_argument_str), eap->arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008211 }
Bram Moolenaar29b2d262006-09-10 19:07:28 +00008212
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008213 // Make sure redirection is not off. Can happen for cmdline completion
8214 // that indirectly invokes a command to catch its output.
Bram Moolenaar29b2d262006-09-10 19:07:28 +00008215 if (redir_fd != NULL
8216#ifdef FEAT_EVAL
8217 || redir_reg || redir_vname
8218#endif
8219 )
8220 redir_off = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008221}
8222
8223/*
8224 * ":redraw": force redraw
8225 */
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01008226 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008227ex_redraw(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008228{
8229 int r = RedrawingDisabled;
8230 int p = p_lz;
8231
8232 RedrawingDisabled = 0;
8233 p_lz = FALSE;
Bram Moolenaarabc39ab2017-03-01 18:04:05 +01008234 validate_cursor();
Bram Moolenaar071d4272004-06-13 20:20:40 +00008235 update_topline();
Bram Moolenaarf7ff6e82014-03-23 15:13:05 +01008236 update_screen(eap->forceit ? CLEAR : VIsual_active ? INVERTED : 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008237 if (need_maketitle)
8238 maketitle();
Bram Moolenaarafde13b2019-04-28 19:46:49 +02008239#if defined(MSWIN) && (!defined(FEAT_GUI_MSWIN) || defined(VIMDLL))
8240# ifdef VIMDLL
8241 if (!gui.in_use)
8242# endif
8243 resize_console_buf();
Bram Moolenaar78d21da2019-02-17 15:00:52 +01008244#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00008245 RedrawingDisabled = r;
8246 p_lz = p;
8247
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008248 // Reset msg_didout, so that a message that's there is overwritten.
Bram Moolenaar071d4272004-06-13 20:20:40 +00008249 msg_didout = FALSE;
8250 msg_col = 0;
8251
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008252 // No need to wait after an intentional redraw.
Bram Moolenaar56667a52013-07-17 11:54:28 +02008253 need_wait_return = FALSE;
8254
Bram Moolenaar071d4272004-06-13 20:20:40 +00008255 out_flush();
8256}
8257
8258/*
8259 * ":redrawstatus": force redraw of status line(s)
8260 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00008261 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008262ex_redrawstatus(exarg_T *eap UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008263{
Bram Moolenaar071d4272004-06-13 20:20:40 +00008264 int r = RedrawingDisabled;
8265 int p = p_lz;
8266
8267 RedrawingDisabled = 0;
8268 p_lz = FALSE;
8269 if (eap->forceit)
8270 status_redraw_all();
8271 else
8272 status_redraw_curbuf();
Bram Moolenaarf7ff6e82014-03-23 15:13:05 +01008273 update_screen(VIsual_active ? INVERTED : 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008274 RedrawingDisabled = r;
8275 p_lz = p;
8276 out_flush();
Bram Moolenaar071d4272004-06-13 20:20:40 +00008277}
8278
Bram Moolenaare12bab32019-01-08 22:02:56 +01008279/*
8280 * ":redrawtabline": force redraw of the tabline
8281 */
8282 static void
8283ex_redrawtabline(exarg_T *eap UNUSED)
8284{
8285 int r = RedrawingDisabled;
8286 int p = p_lz;
8287
8288 RedrawingDisabled = 0;
8289 p_lz = FALSE;
8290
8291 draw_tabline();
8292
8293 RedrawingDisabled = r;
8294 p_lz = p;
8295 out_flush();
8296}
8297
Bram Moolenaar071d4272004-06-13 20:20:40 +00008298 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008299close_redir(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008300{
8301 if (redir_fd != NULL)
8302 {
8303 fclose(redir_fd);
8304 redir_fd = NULL;
8305 }
8306#ifdef FEAT_EVAL
8307 redir_reg = 0;
Bram Moolenaardf177f62005-02-22 08:39:57 +00008308 if (redir_vname)
8309 {
8310 var_redir_stop();
8311 redir_vname = 0;
8312 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00008313#endif
8314}
8315
Bram Moolenaarf96ae0b2019-07-28 15:21:55 +02008316#if (defined(FEAT_SESSION) || defined(FEAT_EVAL)) || defined(PROTO)
Bram Moolenaardf177f62005-02-22 08:39:57 +00008317 int
Bram Moolenaarbd67aac2019-09-21 23:09:04 +02008318vim_mkdir_emsg(char_u *name, int prot UNUSED)
Bram Moolenaardf177f62005-02-22 08:39:57 +00008319{
8320 if (vim_mkdir(name, prot) != 0)
8321 {
Bram Moolenaara6f79292022-01-04 21:30:47 +00008322 semsg(_(e_cannot_create_directory_str), name);
Bram Moolenaardf177f62005-02-22 08:39:57 +00008323 return FAIL;
8324 }
8325 return OK;
8326}
8327#endif
8328
Bram Moolenaar071d4272004-06-13 20:20:40 +00008329/*
8330 * Open a file for writing for an Ex command, with some checks.
8331 * Return file descriptor, or NULL on failure.
8332 */
8333 FILE *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008334open_exfile(
8335 char_u *fname,
8336 int forceit,
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008337 char *mode) // "w" for create new file or "a" for append
Bram Moolenaar071d4272004-06-13 20:20:40 +00008338{
8339 FILE *fd;
8340
8341#ifdef UNIX
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008342 // with Unix it is possible to open a directory
Bram Moolenaar071d4272004-06-13 20:20:40 +00008343 if (mch_isdir(fname))
8344 {
Bram Moolenaar108010a2021-06-27 22:03:33 +02008345 semsg(_(e_src_is_directory), fname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008346 return NULL;
8347 }
8348#endif
8349 if (!forceit && *mode != 'a' && vim_fexists(fname))
8350 {
Bram Moolenaar1a992222021-12-31 17:25:48 +00008351 semsg(_(e_str_exists_add_bang_to_override), fname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008352 return NULL;
8353 }
8354
8355 if ((fd = mch_fopen((char *)fname, mode)) == NULL)
Bram Moolenaar1a992222021-12-31 17:25:48 +00008356 semsg(_(e_cannot_open_str_for_writing_2), fname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008357
8358 return fd;
8359}
8360
8361/*
8362 * ":mark" and ":k".
8363 */
8364 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008365ex_mark(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008366{
8367 pos_T pos;
8368
Bram Moolenaar10b94212021-02-19 21:42:57 +01008369#ifdef FEAT_EVAL
8370 if (not_in_vim9(eap) == FAIL)
8371 return;
8372#endif
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008373 if (*eap->arg == NUL) // No argument?
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00008374 emsg(_(e_argument_required));
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008375 else if (eap->arg[1] != NUL) // more than one character?
Bram Moolenaar74409f62022-01-01 15:58:22 +00008376 semsg(_(e_trailing_characters_str), eap->arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008377 else
8378 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008379 pos = curwin->w_cursor; // save curwin->w_cursor
Bram Moolenaar071d4272004-06-13 20:20:40 +00008380 curwin->w_cursor.lnum = eap->line2;
8381 beginline(BL_WHITE | BL_FIX);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008382 if (setmark(*eap->arg) == FAIL) // set mark
Bram Moolenaar6d057012021-12-31 18:49:43 +00008383 emsg(_(e_argument_must_be_letter_or_forward_backward_quote));
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008384 curwin->w_cursor = pos; // restore curwin->w_cursor
Bram Moolenaar071d4272004-06-13 20:20:40 +00008385 }
8386}
8387
8388/*
8389 * Update w_topline, w_leftcol and the cursor position.
8390 */
8391 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008392update_topline_cursor(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008393{
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008394 check_cursor(); // put cursor on valid line
Bram Moolenaar071d4272004-06-13 20:20:40 +00008395 update_topline();
8396 if (!curwin->w_p_wrap)
8397 validate_cursor();
8398 update_curswant();
8399}
8400
Bram Moolenaar071d4272004-06-13 20:20:40 +00008401/*
Bram Moolenaara21a6a92017-09-23 16:33:50 +02008402 * Save the current State and go to Normal mode.
8403 * Return TRUE if the typeahead could be saved.
8404 */
8405 int
8406save_current_state(save_state_T *sst)
8407{
8408 sst->save_msg_scroll = msg_scroll;
8409 sst->save_restart_edit = restart_edit;
8410 sst->save_msg_didout = msg_didout;
8411 sst->save_State = State;
8412 sst->save_insertmode = p_im;
8413 sst->save_finish_op = finish_op;
8414 sst->save_opcount = opcount;
Bram Moolenaarcce713d2019-03-04 11:40:12 +01008415 sst->save_reg_executing = reg_executing;
Bram Moolenaara21a6a92017-09-23 16:33:50 +02008416
Bram Moolenaar4324d872020-12-01 20:12:24 +01008417 msg_scroll = FALSE; // no msg scrolling in Normal mode
8418 restart_edit = 0; // don't go to Insert mode
8419 p_im = FALSE; // don't use 'insertmode'
Bram Moolenaar9b8d6222020-12-28 18:26:00 +01008420
Bram Moolenaara452b802020-12-01 21:47:59 +01008421 sst->save_script_version = current_sctx.sc_version;
Bram Moolenaar4324d872020-12-01 20:12:24 +01008422 current_sctx.sc_version = 1; // not in Vim9 script
Bram Moolenaara21a6a92017-09-23 16:33:50 +02008423
8424 /*
8425 * Save the current typeahead. This is required to allow using ":normal"
8426 * from an event handler and makes sure we don't hang when the argument
8427 * ends with half a command.
8428 */
8429 save_typeahead(&sst->tabuf);
8430 return sst->tabuf.typebuf_valid;
8431}
8432
8433 void
8434restore_current_state(save_state_T *sst)
8435{
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008436 // Restore the previous typeahead.
Bram Moolenaarc41badb2021-06-07 22:04:52 +02008437 restore_typeahead(&sst->tabuf, FALSE);
Bram Moolenaara21a6a92017-09-23 16:33:50 +02008438
8439 msg_scroll = sst->save_msg_scroll;
8440 restart_edit = sst->save_restart_edit;
8441 p_im = sst->save_insertmode;
8442 finish_op = sst->save_finish_op;
8443 opcount = sst->save_opcount;
Bram Moolenaarcce713d2019-03-04 11:40:12 +01008444 reg_executing = sst->save_reg_executing;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008445 msg_didout |= sst->save_msg_didout; // don't reset msg_didout now
Bram Moolenaar4324d872020-12-01 20:12:24 +01008446 current_sctx.sc_version = sst->save_script_version;
Bram Moolenaara21a6a92017-09-23 16:33:50 +02008447
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008448 // Restore the state (needed when called from a function executed for
8449 // 'indentexpr'). Update the mouse and cursor, they may have changed.
Bram Moolenaara21a6a92017-09-23 16:33:50 +02008450 State = sst->save_State;
8451#ifdef CURSOR_SHAPE
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008452 ui_cursor_shape(); // may show different cursor shape
Bram Moolenaara21a6a92017-09-23 16:33:50 +02008453#endif
8454}
8455
8456/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00008457 * ":normal[!] {commands}": Execute normal mode commands.
8458 */
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01008459 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008460ex_normal(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008461{
Bram Moolenaara21a6a92017-09-23 16:33:50 +02008462 save_state_T save_state;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008463 char_u *arg = NULL;
8464 int l;
8465 char_u *p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008466
Bram Moolenaarc9b4b052006-04-30 18:54:39 +00008467 if (ex_normal_lock > 0)
8468 {
Bram Moolenaar74409f62022-01-01 15:58:22 +00008469 emsg(_(e_not_allowed_here));
Bram Moolenaarc9b4b052006-04-30 18:54:39 +00008470 return;
8471 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00008472 if (ex_normal_busy >= p_mmd)
8473 {
Bram Moolenaar6d057012021-12-31 18:49:43 +00008474 emsg(_(e_recursive_use_of_normal_too_deep));
Bram Moolenaar071d4272004-06-13 20:20:40 +00008475 return;
8476 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00008477
Bram Moolenaar071d4272004-06-13 20:20:40 +00008478 /*
8479 * vgetc() expects a CSI and K_SPECIAL to have been escaped. Don't do
8480 * this for the K_SPECIAL leading byte, otherwise special keys will not
8481 * work.
8482 */
8483 if (has_mbyte)
8484 {
8485 int len = 0;
8486
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008487 // Count the number of characters to be escaped.
Bram Moolenaar071d4272004-06-13 20:20:40 +00008488 for (p = eap->arg; *p != NUL; ++p)
8489 {
Bram Moolenaar13505972019-01-24 15:04:48 +01008490#ifdef FEAT_GUI
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008491 if (*p == CSI) // leadbyte CSI
Bram Moolenaar071d4272004-06-13 20:20:40 +00008492 len += 2;
Bram Moolenaar13505972019-01-24 15:04:48 +01008493#endif
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00008494 for (l = (*mb_ptr2len)(p) - 1; l > 0; --l)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008495 if (*++p == K_SPECIAL // trailbyte K_SPECIAL or CSI
Bram Moolenaar13505972019-01-24 15:04:48 +01008496#ifdef FEAT_GUI
Bram Moolenaar071d4272004-06-13 20:20:40 +00008497 || *p == CSI
Bram Moolenaar13505972019-01-24 15:04:48 +01008498#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00008499 )
8500 len += 2;
8501 }
8502 if (len > 0)
8503 {
Bram Moolenaar964b3742019-05-24 18:54:09 +02008504 arg = alloc(STRLEN(eap->arg) + len + 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008505 if (arg != NULL)
8506 {
8507 len = 0;
8508 for (p = eap->arg; *p != NUL; ++p)
8509 {
8510 arg[len++] = *p;
Bram Moolenaar13505972019-01-24 15:04:48 +01008511#ifdef FEAT_GUI
Bram Moolenaar071d4272004-06-13 20:20:40 +00008512 if (*p == CSI)
8513 {
8514 arg[len++] = KS_EXTRA;
8515 arg[len++] = (int)KE_CSI;
8516 }
Bram Moolenaar13505972019-01-24 15:04:48 +01008517#endif
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00008518 for (l = (*mb_ptr2len)(p) - 1; l > 0; --l)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008519 {
8520 arg[len++] = *++p;
8521 if (*p == K_SPECIAL)
8522 {
8523 arg[len++] = KS_SPECIAL;
8524 arg[len++] = KE_FILLER;
8525 }
Bram Moolenaar13505972019-01-24 15:04:48 +01008526#ifdef FEAT_GUI
Bram Moolenaar071d4272004-06-13 20:20:40 +00008527 else if (*p == CSI)
8528 {
8529 arg[len++] = KS_EXTRA;
8530 arg[len++] = (int)KE_CSI;
8531 }
Bram Moolenaar13505972019-01-24 15:04:48 +01008532#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00008533 }
8534 arg[len] = NUL;
8535 }
8536 }
8537 }
8538 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00008539
Bram Moolenaara21a6a92017-09-23 16:33:50 +02008540 ++ex_normal_busy;
8541 if (save_current_state(&save_state))
Bram Moolenaar071d4272004-06-13 20:20:40 +00008542 {
8543 /*
8544 * Repeat the :normal command for each line in the range. When no
8545 * range given, execute it just once, without positioning the cursor
8546 * first.
8547 */
8548 do
8549 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00008550 if (eap->addr_count != 0)
8551 {
8552 curwin->w_cursor.lnum = eap->line1++;
8553 curwin->w_cursor.col = 0;
Bram Moolenaard5d37532017-03-27 23:02:07 +02008554 check_cursor_moved(curwin);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008555 }
8556
Bram Moolenaar13505972019-01-24 15:04:48 +01008557 exec_normal_cmd(arg != NULL
8558 ? arg
8559 : eap->arg, eap->forceit ? REMAP_NONE : REMAP_YES, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008560 }
8561 while (eap->addr_count > 0 && eap->line1 <= eap->line2 && !got_int);
8562 }
8563
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008564 // Might not return to the main loop when in an event handler.
Bram Moolenaar071d4272004-06-13 20:20:40 +00008565 update_topline_cursor();
8566
Bram Moolenaara21a6a92017-09-23 16:33:50 +02008567 restore_current_state(&save_state);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008568 --ex_normal_busy;
Bram Moolenaareda73602014-11-05 09:53:23 +01008569 setmouse();
Bram Moolenaareda73602014-11-05 09:53:23 +01008570#ifdef CURSOR_SHAPE
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008571 ui_cursor_shape(); // may show different cursor shape
Bram Moolenaareda73602014-11-05 09:53:23 +01008572#endif
8573
Bram Moolenaar071d4272004-06-13 20:20:40 +00008574 vim_free(arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008575}
8576
8577/*
Bram Moolenaar64969662005-12-14 21:59:55 +00008578 * ":startinsert", ":startreplace" and ":startgreplace"
Bram Moolenaar071d4272004-06-13 20:20:40 +00008579 */
8580 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008581ex_startinsert(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008582{
Bram Moolenaarfd371682005-01-14 21:42:54 +00008583 if (eap->forceit)
8584 {
Bram Moolenaar8d3b5102019-09-05 21:29:01 +02008585 // cursor line can be zero on startup
Bram Moolenaar09ca9322017-09-26 17:40:45 +02008586 if (!curwin->w_cursor.lnum)
8587 curwin->w_cursor.lnum = 1;
Bram Moolenaar8d3b5102019-09-05 21:29:01 +02008588 set_cursor_for_append_to_line();
Bram Moolenaarfd371682005-01-14 21:42:54 +00008589 }
Bram Moolenaareb58a242020-04-19 18:13:19 +02008590#ifdef FEAT_TERMINAL
8591 // Ignore this when running in an active terminal.
8592 if (term_job_running(curbuf->b_term))
8593 return;
8594#endif
Bram Moolenaarfd371682005-01-14 21:42:54 +00008595
Bram Moolenaar8d3b5102019-09-05 21:29:01 +02008596 // Ignore the command when already in Insert mode. Inserting an
8597 // expression register that invokes a function can do this.
Bram Moolenaara40c5002005-01-09 21:16:21 +00008598 if (State & INSERT)
8599 return;
8600
Bram Moolenaar64969662005-12-14 21:59:55 +00008601 if (eap->cmdidx == CMD_startinsert)
8602 restart_edit = 'a';
8603 else if (eap->cmdidx == CMD_startreplace)
8604 restart_edit = 'R';
Bram Moolenaar071d4272004-06-13 20:20:40 +00008605 else
Bram Moolenaar64969662005-12-14 21:59:55 +00008606 restart_edit = 'V';
8607
8608 if (!eap->forceit)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008609 {
Bram Moolenaar325b7a22004-07-05 15:58:32 +00008610 if (eap->cmdidx == CMD_startinsert)
8611 restart_edit = 'i';
Bram Moolenaar8d3b5102019-09-05 21:29:01 +02008612 curwin->w_curswant = 0; // avoid MAXCOL
Bram Moolenaar071d4272004-06-13 20:20:40 +00008613 }
Bram Moolenaar957cf672020-11-12 14:21:06 +01008614
8615 if (VIsual_active)
8616 showmode();
Bram Moolenaar071d4272004-06-13 20:20:40 +00008617}
8618
8619/*
8620 * ":stopinsert"
8621 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00008622 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008623ex_stopinsert(exarg_T *eap UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008624{
8625 restart_edit = 0;
8626 stop_insert_mode = TRUE;
Bram Moolenaarfd773e92016-04-02 19:39:16 +02008627 clearmode();
Bram Moolenaar071d4272004-06-13 20:20:40 +00008628}
Bram Moolenaar071d4272004-06-13 20:20:40 +00008629
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00008630/*
8631 * Execute normal mode command "cmd".
8632 * "remap" can be REMAP_NONE or REMAP_YES.
8633 */
8634 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008635exec_normal_cmd(char_u *cmd, int remap, int silent)
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00008636{
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008637 // Stuff the argument into the typeahead buffer.
Bram Moolenaar25281632016-01-21 23:32:32 +01008638 ins_typebuf(cmd, remap, 0, TRUE, silent);
Bram Moolenaar586c70c2018-10-02 16:23:58 +02008639 exec_normal(FALSE, FALSE, FALSE);
Bram Moolenaar25281632016-01-21 23:32:32 +01008640}
Bram Moolenaar25281632016-01-21 23:32:32 +01008641
Bram Moolenaar25281632016-01-21 23:32:32 +01008642/*
8643 * Execute normal_cmd() until there is no typeahead left.
Bram Moolenaar586c70c2018-10-02 16:23:58 +02008644 * When "use_vpeekc" is TRUE use vpeekc() to check for available chars.
Bram Moolenaar25281632016-01-21 23:32:32 +01008645 */
8646 void
Bram Moolenaar586c70c2018-10-02 16:23:58 +02008647exec_normal(int was_typed, int use_vpeekc, int may_use_terminal_loop UNUSED)
Bram Moolenaar25281632016-01-21 23:32:32 +01008648{
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00008649 oparg_T oa;
Bram Moolenaar905dd902019-04-07 14:21:47 +02008650 int c;
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00008651
Bram Moolenaar905dd902019-04-07 14:21:47 +02008652 // When calling vpeekc() from feedkeys() it will return Ctrl_C when there
8653 // is nothing to get, so also check for Ctrl_C.
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00008654 clear_oparg(&oa);
8655 finish_op = FALSE;
Bram Moolenaar586c70c2018-10-02 16:23:58 +02008656 while ((!stuff_empty()
8657 || ((was_typed || !typebuf_typed()) && typebuf.tb_len > 0)
Bram Moolenaar905dd902019-04-07 14:21:47 +02008658 || (use_vpeekc && (c = vpeekc()) != NUL && c != Ctrl_C))
Bram Moolenaar586c70c2018-10-02 16:23:58 +02008659 && !got_int)
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00008660 {
8661 update_topline_cursor();
Bram Moolenaarb2ac14c2018-05-01 18:47:59 +02008662#ifdef FEAT_TERMINAL
Bram Moolenaar655a82a2018-05-08 22:01:07 +02008663 if (may_use_terminal_loop && term_use_loop()
Bram Moolenaarb2ac14c2018-05-01 18:47:59 +02008664 && oa.op_type == OP_NOP && oa.regname == NUL
8665 && !VIsual_active)
8666 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008667 // If terminal_loop() returns OK we got a key that is handled
8668 // in Normal model. With FAIL we first need to position the
8669 // cursor and the screen needs to be redrawn.
Bram Moolenaarb2ac14c2018-05-01 18:47:59 +02008670 if (terminal_loop(TRUE) == OK)
8671 normal_cmd(&oa, TRUE);
8672 }
8673 else
8674#endif
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008675 // execute a Normal mode cmd
Bram Moolenaarb2ac14c2018-05-01 18:47:59 +02008676 normal_cmd(&oa, TRUE);
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00008677 }
8678}
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00008679
Bram Moolenaar071d4272004-06-13 20:20:40 +00008680#ifdef FEAT_FIND_ID
8681 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008682ex_checkpath(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008683{
8684 find_pattern_in_path(NULL, 0, 0, FALSE, FALSE, CHECK_PATH, 1L,
8685 eap->forceit ? ACTION_SHOW_ALL : ACTION_SHOW,
8686 (linenr_T)1, (linenr_T)MAXLNUM);
8687}
8688
Bram Moolenaar4033c552017-09-16 20:54:51 +02008689#if defined(FEAT_QUICKFIX)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008690/*
8691 * ":psearch"
8692 */
8693 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008694ex_psearch(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008695{
8696 g_do_tagpreview = p_pvh;
8697 ex_findpat(eap);
8698 g_do_tagpreview = 0;
8699}
8700#endif
8701
8702 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008703ex_findpat(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008704{
8705 int whole = TRUE;
8706 long n;
8707 char_u *p;
8708 int action;
8709
8710 switch (cmdnames[eap->cmdidx].cmd_name[2])
8711 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008712 case 'e': // ":psearch", ":isearch" and ":dsearch"
Bram Moolenaar071d4272004-06-13 20:20:40 +00008713 if (cmdnames[eap->cmdidx].cmd_name[0] == 'p')
8714 action = ACTION_GOTO;
8715 else
8716 action = ACTION_SHOW;
8717 break;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008718 case 'i': // ":ilist" and ":dlist"
Bram Moolenaar071d4272004-06-13 20:20:40 +00008719 action = ACTION_SHOW_ALL;
8720 break;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008721 case 'u': // ":ijump" and ":djump"
Bram Moolenaar071d4272004-06-13 20:20:40 +00008722 action = ACTION_GOTO;
8723 break;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008724 default: // ":isplit" and ":dsplit"
Bram Moolenaar071d4272004-06-13 20:20:40 +00008725 action = ACTION_SPLIT;
8726 break;
8727 }
8728
8729 n = 1;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008730 if (vim_isdigit(*eap->arg)) // get count
Bram Moolenaar071d4272004-06-13 20:20:40 +00008731 {
8732 n = getdigits(&eap->arg);
8733 eap->arg = skipwhite(eap->arg);
8734 }
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008735 if (*eap->arg == '/') // Match regexp, not just whole words
Bram Moolenaar071d4272004-06-13 20:20:40 +00008736 {
8737 whole = FALSE;
8738 ++eap->arg;
Bram Moolenaarf4e20992020-12-21 19:59:08 +01008739 p = skip_regexp(eap->arg, '/', magic_isset());
Bram Moolenaar071d4272004-06-13 20:20:40 +00008740 if (*p)
8741 {
8742 *p++ = NUL;
8743 p = skipwhite(p);
8744
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008745 // Check for trailing illegal characters
Bram Moolenaarfaac4102020-04-20 17:46:14 +02008746 if (!ends_excmd2(eap->arg, p))
Bram Moolenaar74409f62022-01-01 15:58:22 +00008747 eap->errmsg = ex_errmsg(e_trailing_characters_str, p);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008748 else
Bram Moolenaar63b91732021-08-05 20:40:03 +02008749 set_nextcmd(eap, p);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008750 }
8751 }
8752 if (!eap->skip)
8753 find_pattern_in_path(eap->arg, 0, (int)STRLEN(eap->arg),
8754 whole, !eap->forceit,
8755 *eap->cmd == 'd' ? FIND_DEFINE : FIND_ANY,
8756 n, action, eap->line1, eap->line2);
8757}
8758#endif
8759
Bram Moolenaar071d4272004-06-13 20:20:40 +00008760
Bram Moolenaar4033c552017-09-16 20:54:51 +02008761#ifdef FEAT_QUICKFIX
Bram Moolenaar071d4272004-06-13 20:20:40 +00008762/*
8763 * ":ptag", ":ptselect", ":ptjump", ":ptnext", etc.
8764 */
8765 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008766ex_ptag(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008767{
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008768 g_do_tagpreview = p_pvh; // will be reset to 0 in ex_tag_cmd()
Bram Moolenaar071d4272004-06-13 20:20:40 +00008769 ex_tag_cmd(eap, cmdnames[eap->cmdidx].cmd_name + 1);
8770}
8771
8772/*
8773 * ":pedit"
8774 */
8775 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008776ex_pedit(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008777{
8778 win_T *curwin_save = curwin;
8779
Bram Moolenaar3a2505c2020-03-09 16:40:41 +01008780 if (ERROR_IF_ANY_POPUP_WINDOW)
8781 return;
8782
Bram Moolenaar026587b2019-08-17 15:08:00 +02008783 // Open the preview window or popup and make it the current window.
Bram Moolenaar071d4272004-06-13 20:20:40 +00008784 g_do_tagpreview = p_pvh;
Bram Moolenaar576a4a62019-08-18 15:25:17 +02008785 prepare_tagpreview(TRUE, TRUE, FALSE);
Bram Moolenaar1b6d9c42019-08-05 21:52:04 +02008786
Bram Moolenaar026587b2019-08-17 15:08:00 +02008787 // Edit the file.
Bram Moolenaar071d4272004-06-13 20:20:40 +00008788 do_exedit(eap, NULL);
Bram Moolenaar1b6d9c42019-08-05 21:52:04 +02008789
Bram Moolenaar071d4272004-06-13 20:20:40 +00008790 if (curwin != curwin_save && win_valid(curwin_save))
8791 {
Bram Moolenaar026587b2019-08-17 15:08:00 +02008792 // Return cursor to where we were
Bram Moolenaar071d4272004-06-13 20:20:40 +00008793 validate_cursor();
8794 redraw_later(VALID);
8795 win_enter(curwin_save, TRUE);
8796 }
Bram Moolenaar05ad5ff2019-11-30 22:48:27 +01008797# ifdef FEAT_PROP_POPUP
Bram Moolenaar1b6d9c42019-08-05 21:52:04 +02008798 else if (WIN_IS_POPUP(curwin))
8799 {
8800 // can't keep focus in popup window
8801 win_enter(firstwin, TRUE);
8802 }
8803# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00008804 g_do_tagpreview = 0;
8805}
Bram Moolenaar4033c552017-09-16 20:54:51 +02008806#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00008807
8808/*
8809 * ":stag", ":stselect" and ":stjump".
8810 */
8811 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008812ex_stag(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008813{
8814 postponed_split = -1;
Bram Moolenaare1004402020-10-24 20:49:43 +02008815 postponed_split_flags = cmdmod.cmod_split;
8816 postponed_split_tab = cmdmod.cmod_tab;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008817 ex_tag_cmd(eap, cmdnames[eap->cmdidx].cmd_name + 1);
8818 postponed_split_flags = 0;
Bram Moolenaard326ce82007-03-11 14:48:29 +00008819 postponed_split_tab = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008820}
Bram Moolenaar071d4272004-06-13 20:20:40 +00008821
8822/*
8823 * ":tag", ":tselect", ":tjump", ":tnext", etc.
8824 */
8825 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008826ex_tag(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008827{
8828 ex_tag_cmd(eap, cmdnames[eap->cmdidx].cmd_name);
8829}
8830
8831 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008832ex_tag_cmd(exarg_T *eap, char_u *name)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008833{
8834 int cmd;
8835
8836 switch (name[1])
8837 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008838 case 'j': cmd = DT_JUMP; // ":tjump"
Bram Moolenaar071d4272004-06-13 20:20:40 +00008839 break;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008840 case 's': cmd = DT_SELECT; // ":tselect"
Bram Moolenaar071d4272004-06-13 20:20:40 +00008841 break;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008842 case 'p': cmd = DT_PREV; // ":tprevious"
Bram Moolenaar071d4272004-06-13 20:20:40 +00008843 break;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008844 case 'N': cmd = DT_PREV; // ":tNext"
Bram Moolenaar071d4272004-06-13 20:20:40 +00008845 break;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008846 case 'n': cmd = DT_NEXT; // ":tnext"
Bram Moolenaar071d4272004-06-13 20:20:40 +00008847 break;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008848 case 'o': cmd = DT_POP; // ":pop"
Bram Moolenaar071d4272004-06-13 20:20:40 +00008849 break;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008850 case 'f': // ":tfirst"
8851 case 'r': cmd = DT_FIRST; // ":trewind"
Bram Moolenaar071d4272004-06-13 20:20:40 +00008852 break;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008853 case 'l': cmd = DT_LAST; // ":tlast"
Bram Moolenaar071d4272004-06-13 20:20:40 +00008854 break;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008855 default: // ":tag"
Bram Moolenaar071d4272004-06-13 20:20:40 +00008856#ifdef FEAT_CSCOPE
Bram Moolenaar7c94c262008-06-20 09:11:34 +00008857 if (p_cst && *eap->arg != NUL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008858 {
Bram Moolenaard4db7712016-11-12 19:16:46 +01008859 ex_cstag(eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008860 return;
8861 }
8862#endif
8863 cmd = DT_TAG;
8864 break;
8865 }
8866
Bram Moolenaarb8a7b562006-02-01 21:47:16 +00008867 if (name[0] == 'l')
8868 {
8869#ifndef FEAT_QUICKFIX
8870 ex_ni(eap);
8871 return;
8872#else
8873 cmd = DT_LTAG;
8874#endif
8875 }
8876
Bram Moolenaar071d4272004-06-13 20:20:40 +00008877 do_tag(eap->arg, cmd, eap->addr_count > 0 ? (int)eap->line2 : 1,
8878 eap->forceit, TRUE);
8879}
8880
8881/*
Bram Moolenaar05bb9532008-07-04 09:44:11 +00008882 * Check "str" for starting with a special cmdline variable.
8883 * If found return one of the SPEC_ values and set "*usedlen" to the length of
8884 * the variable. Otherwise return -1 and "*usedlen" is unchanged.
8885 */
8886 int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008887find_cmdline_var(char_u *src, int *usedlen)
Bram Moolenaar05bb9532008-07-04 09:44:11 +00008888{
8889 int len;
8890 int i;
Bram Moolenaar8f0b2d42009-05-16 14:41:10 +00008891 static char *(spec_str[]) = {
Bram Moolenaar05bb9532008-07-04 09:44:11 +00008892 "%",
8893#define SPEC_PERC 0
8894 "#",
Bram Moolenaar65f08472017-09-10 18:16:20 +02008895#define SPEC_HASH (SPEC_PERC + 1)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008896 "<cword>", // cursor word
Bram Moolenaar65f08472017-09-10 18:16:20 +02008897#define SPEC_CWORD (SPEC_HASH + 1)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008898 "<cWORD>", // cursor WORD
Bram Moolenaar65f08472017-09-10 18:16:20 +02008899#define SPEC_CCWORD (SPEC_CWORD + 1)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008900 "<cexpr>", // expr under cursor
Bram Moolenaar65f08472017-09-10 18:16:20 +02008901#define SPEC_CEXPR (SPEC_CCWORD + 1)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008902 "<cfile>", // cursor path name
Bram Moolenaar65f08472017-09-10 18:16:20 +02008903#define SPEC_CFILE (SPEC_CEXPR + 1)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008904 "<sfile>", // ":so" file name
Bram Moolenaar65f08472017-09-10 18:16:20 +02008905#define SPEC_SFILE (SPEC_CFILE + 1)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008906 "<slnum>", // ":so" file line number
Bram Moolenaar65f08472017-09-10 18:16:20 +02008907#define SPEC_SLNUM (SPEC_SFILE + 1)
Bram Moolenaara5d04232020-07-26 15:37:02 +02008908 "<stack>", // call stack
8909#define SPEC_STACK (SPEC_SLNUM + 1)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008910 "<afile>", // autocommand file name
Bram Moolenaara5d04232020-07-26 15:37:02 +02008911#define SPEC_AFILE (SPEC_STACK + 1)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008912 "<abuf>", // autocommand buffer number
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02008913#define SPEC_ABUF (SPEC_AFILE + 1)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008914 "<amatch>", // autocommand match name
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01008915#define SPEC_AMATCH (SPEC_ABUF + 1)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008916 "<sflnum>", // script file line number
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02008917#define SPEC_SFLNUM (SPEC_AMATCH + 1)
Bram Moolenaar90944302020-08-01 20:45:11 +02008918 "<SID>", // script ID: <SNR>123_
8919#define SPEC_SID (SPEC_SFLNUM + 1)
Bram Moolenaar05bb9532008-07-04 09:44:11 +00008920#ifdef FEAT_CLIENTSERVER
8921 "<client>"
Bram Moolenaar90944302020-08-01 20:45:11 +02008922# define SPEC_CLIENT (SPEC_SID + 1)
Bram Moolenaar05bb9532008-07-04 09:44:11 +00008923#endif
8924 };
Bram Moolenaar05bb9532008-07-04 09:44:11 +00008925
K.Takataeeec2542021-06-02 13:28:16 +02008926 for (i = 0; i < (int)ARRAY_LENGTH(spec_str); ++i)
Bram Moolenaar05bb9532008-07-04 09:44:11 +00008927 {
8928 len = (int)STRLEN(spec_str[i]);
8929 if (STRNCMP(src, spec_str[i], len) == 0)
8930 {
8931 *usedlen = len;
8932 return i;
8933 }
8934 }
8935 return -1;
8936}
8937
8938/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00008939 * Evaluate cmdline variables.
8940 *
Bram Moolenaar4389f9c2020-12-27 16:55:11 +01008941 * change "%" to curbuf->b_ffname
8942 * "#" to curwin->w_alt_fnum
8943 * "%%" to curwin->w_alt_fnum in Vim9 script
8944 * "<cword>" to word under the cursor
8945 * "<cWORD>" to WORD under the cursor
8946 * "<cexpr>" to C-expression under the cursor
8947 * "<cfile>" to path name under the cursor
8948 * "<sfile>" to sourced file name
8949 * "<stack>" to call stack
8950 * "<slnum>" to sourced file line number
8951 * "<afile>" to file name for autocommand
8952 * "<abuf>" to buffer number for autocommand
8953 * "<amatch>" to matching name for autocommand
Bram Moolenaar071d4272004-06-13 20:20:40 +00008954 *
8955 * When an error is detected, "errormsg" is set to a non-NULL pointer (may be
8956 * "" for error without a message) and NULL is returned.
8957 * Returns an allocated string if a valid match was found.
8958 * Returns NULL if no match was found. "usedlen" then still contains the
8959 * number of characters to skip.
8960 */
8961 char_u *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008962eval_vars(
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008963 char_u *src, // pointer into commandline
8964 char_u *srcstart, // beginning of valid memory for src
8965 int *usedlen, // characters after src that are used
8966 linenr_T *lnump, // line number for :e command, or NULL
8967 char **errormsg, // pointer to error message
8968 int *escaped) // return value has escaped white space (can
8969 // be NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008970{
8971 int i;
8972 char_u *s;
8973 char_u *result;
8974 char_u *resultbuf = NULL;
8975 int resultlen;
8976 buf_T *buf;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008977 int valid = VALID_HEAD + VALID_PATH; // assume valid result
Bram Moolenaar071d4272004-06-13 20:20:40 +00008978 int spec_idx;
Bram Moolenaarfd249462018-07-28 16:14:30 +02008979 int tilde_file = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008980 int skip_mod = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008981 char_u strbuf[30];
Bram Moolenaar071d4272004-06-13 20:20:40 +00008982
8983 *errormsg = NULL;
Bram Moolenaar63b92542007-03-27 14:57:09 +00008984 if (escaped != NULL)
8985 *escaped = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008986
8987 /*
8988 * Check if there is something to do.
8989 */
Bram Moolenaar05bb9532008-07-04 09:44:11 +00008990 spec_idx = find_cmdline_var(src, usedlen);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008991 if (spec_idx < 0) // no match
Bram Moolenaar071d4272004-06-13 20:20:40 +00008992 {
8993 *usedlen = 1;
8994 return NULL;
8995 }
8996
8997 /*
8998 * Skip when preceded with a backslash "\%" and "\#".
8999 * Note: In "\\%" the % is also not recognized!
9000 */
9001 if (src > srcstart && src[-1] == '\\')
9002 {
9003 *usedlen = 0;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009004 STRMOVE(src - 1, src); // remove backslash
Bram Moolenaar071d4272004-06-13 20:20:40 +00009005 return NULL;
9006 }
9007
9008 /*
9009 * word or WORD under cursor
9010 */
Bram Moolenaar65f08472017-09-10 18:16:20 +02009011 if (spec_idx == SPEC_CWORD || spec_idx == SPEC_CCWORD
9012 || spec_idx == SPEC_CEXPR)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009013 {
Bram Moolenaar65f08472017-09-10 18:16:20 +02009014 resultlen = find_ident_under_cursor(&result,
9015 spec_idx == SPEC_CWORD ? (FIND_IDENT | FIND_STRING)
9016 : spec_idx == SPEC_CEXPR ? (FIND_IDENT | FIND_STRING | FIND_EVAL)
9017 : FIND_STRING);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009018 if (resultlen == 0)
9019 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009020 *errormsg = "";
Bram Moolenaar071d4272004-06-13 20:20:40 +00009021 return NULL;
9022 }
9023 }
9024
9025 /*
9026 * '#': Alternate file name
9027 * '%': Current file name
9028 * File name under the cursor
9029 * File name for autocommand
9030 * and following modifiers
9031 */
9032 else
9033 {
Bram Moolenaar4389f9c2020-12-27 16:55:11 +01009034 int off = 0;
9035
Bram Moolenaar071d4272004-06-13 20:20:40 +00009036 switch (spec_idx)
9037 {
Bram Moolenaar4389f9c2020-12-27 16:55:11 +01009038 case SPEC_PERC:
Bram Moolenaar39cb2da2020-12-27 17:35:18 +01009039#ifdef FEAT_EVAL
Bram Moolenaar4389f9c2020-12-27 16:55:11 +01009040 if (!in_vim9script() || src[1] != '%')
Bram Moolenaar39cb2da2020-12-27 17:35:18 +01009041#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00009042 {
Bram Moolenaar4389f9c2020-12-27 16:55:11 +01009043 // '%': current file
9044 if (curbuf->b_fname == NULL)
9045 {
9046 result = (char_u *)"";
9047 valid = 0; // Must have ":p:h" to be valid
9048 }
9049 else
9050 {
9051 result = curbuf->b_fname;
9052 tilde_file = STRCMP(result, "~") == 0;
9053 }
9054 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009055 }
Bram Moolenaar39cb2da2020-12-27 17:35:18 +01009056#ifdef FEAT_EVAL
Bram Moolenaar4389f9c2020-12-27 16:55:11 +01009057 // "%%" alternate file
9058 off = 1;
Bram Moolenaar39cb2da2020-12-27 17:35:18 +01009059#endif
Bram Moolenaar9618a252020-12-27 19:18:03 +01009060 // FALLTHROUGH
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009061 case SPEC_HASH: // '#' or "#99": alternate file
Bram Moolenaar4389f9c2020-12-27 16:55:11 +01009062 if (off == 0 ? src[1] == '#' : src[2] == '%')
Bram Moolenaar071d4272004-06-13 20:20:40 +00009063 {
Bram Moolenaar4389f9c2020-12-27 16:55:11 +01009064 // "##" or "%%%": the argument list
Bram Moolenaar071d4272004-06-13 20:20:40 +00009065 result = arg_all();
9066 resultbuf = result;
Bram Moolenaar4389f9c2020-12-27 16:55:11 +01009067 *usedlen = off + 2;
Bram Moolenaar63b92542007-03-27 14:57:09 +00009068 if (escaped != NULL)
9069 *escaped = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009070 skip_mod = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009071 break;
9072 }
Bram Moolenaar4389f9c2020-12-27 16:55:11 +01009073 s = src + off + 1;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009074 if (*s == '<') // "#<99" uses v:oldfiles
Bram Moolenaard812df62008-11-09 12:46:09 +00009075 ++s;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009076 i = (int)getdigits(&s);
Bram Moolenaar4389f9c2020-12-27 16:55:11 +01009077 if (s == src + off + 2 && src[off + 1] == '-')
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009078 // just a minus sign, don't skip over it
Bram Moolenaarc312b8b2017-10-28 17:53:04 +02009079 s--;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009080 *usedlen = (int)(s - src); // length of what we expand
Bram Moolenaar071d4272004-06-13 20:20:40 +00009081
Bram Moolenaar4389f9c2020-12-27 16:55:11 +01009082 if (src[off + 1] == '<' && i != 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009083 {
Bram Moolenaar4389f9c2020-12-27 16:55:11 +01009084 if (*usedlen < off + 2)
Bram Moolenaard812df62008-11-09 12:46:09 +00009085 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009086 // Should we give an error message for #<text?
Bram Moolenaar4389f9c2020-12-27 16:55:11 +01009087 *usedlen = off + 1;
Bram Moolenaard812df62008-11-09 12:46:09 +00009088 return NULL;
9089 }
9090#ifdef FEAT_EVAL
9091 result = list_find_str(get_vim_var_list(VV_OLDFILES),
9092 (long)i);
9093 if (result == NULL)
9094 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009095 *errormsg = "";
Bram Moolenaard812df62008-11-09 12:46:09 +00009096 return NULL;
9097 }
9098#else
Bram Moolenaar9d00e4a2022-01-05 17:49:15 +00009099 *errormsg = _(e_hashsmall_is_not_available_without_the_eval_feature);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009100 return NULL;
Bram Moolenaard812df62008-11-09 12:46:09 +00009101#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00009102 }
9103 else
Bram Moolenaard812df62008-11-09 12:46:09 +00009104 {
Bram Moolenaar4389f9c2020-12-27 16:55:11 +01009105 if (i == 0 && src[off + 1] == '<' && *usedlen > off + 1)
9106 *usedlen = off + 1;
Bram Moolenaard812df62008-11-09 12:46:09 +00009107 buf = buflist_findnr(i);
9108 if (buf == NULL)
9109 {
Bram Moolenaar6d057012021-12-31 18:49:43 +00009110 *errormsg = _(e_no_alternate_file_name_to_substitute_for_hash);
Bram Moolenaard812df62008-11-09 12:46:09 +00009111 return NULL;
9112 }
9113 if (lnump != NULL)
9114 *lnump = ECMD_LAST;
9115 if (buf->b_fname == NULL)
9116 {
9117 result = (char_u *)"";
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009118 valid = 0; // Must have ":p:h" to be valid
Bram Moolenaard812df62008-11-09 12:46:09 +00009119 }
9120 else
Bram Moolenaar00136dc2018-07-25 21:19:13 +02009121 {
Bram Moolenaard812df62008-11-09 12:46:09 +00009122 result = buf->b_fname;
Bram Moolenaar00136dc2018-07-25 21:19:13 +02009123 tilde_file = STRCMP(result, "~") == 0;
9124 }
Bram Moolenaard812df62008-11-09 12:46:09 +00009125 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00009126 break;
9127
9128#ifdef FEAT_SEARCHPATH
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009129 case SPEC_CFILE: // file name under cursor
Bram Moolenaard1f56e62006-02-22 21:25:37 +00009130 result = file_name_at_cursor(FNAME_MESS|FNAME_HYP, 1L, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009131 if (result == NULL)
9132 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009133 *errormsg = "";
Bram Moolenaar071d4272004-06-13 20:20:40 +00009134 return NULL;
9135 }
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009136 resultbuf = result; // remember allocated string
Bram Moolenaar071d4272004-06-13 20:20:40 +00009137 break;
9138#endif
9139
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009140 case SPEC_AFILE: // file name for autocommand
Bram Moolenaar071d4272004-06-13 20:20:40 +00009141 result = autocmd_fname;
Bram Moolenaarf6dad432008-09-18 19:29:58 +00009142 if (result != NULL && !autocmd_fname_full)
9143 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009144 // Still need to turn the fname into a full path. It is
9145 // postponed to avoid a delay when <afile> is not used.
Bram Moolenaarf6dad432008-09-18 19:29:58 +00009146 autocmd_fname_full = TRUE;
9147 result = FullName_save(autocmd_fname, FALSE);
9148 vim_free(autocmd_fname);
9149 autocmd_fname = result;
9150 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00009151 if (result == NULL)
9152 {
Bram Moolenaarb09feaa2022-01-02 20:20:45 +00009153 *errormsg = _(e_no_autocommand_file_name_to_substitute_for_afile);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009154 return NULL;
9155 }
Bram Moolenaara0174af2008-01-02 20:08:25 +00009156 result = shorten_fname1(result);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009157 break;
9158
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009159 case SPEC_ABUF: // buffer number for autocommand
Bram Moolenaar071d4272004-06-13 20:20:40 +00009160 if (autocmd_bufnr <= 0)
9161 {
Bram Moolenaarb09feaa2022-01-02 20:20:45 +00009162 *errormsg = _(e_no_autocommand_buffer_name_to_substitute_for_abuf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009163 return NULL;
9164 }
9165 sprintf((char *)strbuf, "%d", autocmd_bufnr);
9166 result = strbuf;
9167 break;
9168
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009169 case SPEC_AMATCH: // match name for autocommand
Bram Moolenaar071d4272004-06-13 20:20:40 +00009170 result = autocmd_match;
9171 if (result == NULL)
9172 {
Bram Moolenaarb09feaa2022-01-02 20:20:45 +00009173 *errormsg = _(e_no_autocommand_match_name_to_substitute_for_amatch);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009174 return NULL;
9175 }
9176 break;
9177
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009178 case SPEC_SFILE: // file name for ":so" command
Bram Moolenaara5d04232020-07-26 15:37:02 +02009179 case SPEC_STACK: // call stack
Bram Moolenaar4f25b1a2020-09-10 19:25:05 +02009180 result = estack_sfile(spec_idx == SPEC_SFILE
9181 ? ESTACK_SFILE : ESTACK_STACK);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009182 if (result == NULL)
9183 {
Bram Moolenaara5d04232020-07-26 15:37:02 +02009184 *errormsg = spec_idx == SPEC_SFILE
Bram Moolenaarb09feaa2022-01-02 20:20:45 +00009185 ? _(e_no_source_file_name_to_substitute_for_sfile)
9186 : _(e_no_call_stack_to_substitute_for_stack);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009187 return NULL;
9188 }
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01009189 resultbuf = result; // remember allocated string
Bram Moolenaar071d4272004-06-13 20:20:40 +00009190 break;
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02009191
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009192 case SPEC_SLNUM: // line in file for ":so" command
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01009193 if (SOURCING_NAME == NULL || SOURCING_LNUM == 0)
Bram Moolenaar4dbbff52010-11-24 15:50:59 +01009194 {
Bram Moolenaar9d00e4a2022-01-05 17:49:15 +00009195 *errormsg = _(e_no_line_number_to_use_for_slnum);
Bram Moolenaar4dbbff52010-11-24 15:50:59 +01009196 return NULL;
9197 }
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01009198 sprintf((char *)strbuf, "%ld", SOURCING_LNUM);
Bram Moolenaar4dbbff52010-11-24 15:50:59 +01009199 result = strbuf;
9200 break;
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02009201
9202#ifdef FEAT_EVAL
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009203 case SPEC_SFLNUM: // line in script file
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01009204 if (current_sctx.sc_lnum + SOURCING_LNUM == 0)
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02009205 {
Bram Moolenaard82a47d2022-01-05 20:24:39 +00009206 *errormsg = _(e_no_line_number_to_use_for_sflnum);
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02009207 return NULL;
9208 }
9209 sprintf((char *)strbuf, "%ld",
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01009210 (long)(current_sctx.sc_lnum + SOURCING_LNUM));
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02009211 result = strbuf;
9212 break;
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02009213
Bram Moolenaar90944302020-08-01 20:45:11 +02009214 case SPEC_SID:
9215 if (current_sctx.sc_sid <= 0)
9216 {
Bram Moolenaar40bcec12021-12-05 22:19:27 +00009217 *errormsg = _(e_using_sid_not_in_script_context);
Bram Moolenaar90944302020-08-01 20:45:11 +02009218 return NULL;
9219 }
9220 sprintf((char *)strbuf, "<SNR>%d_", current_sctx.sc_sid);
9221 result = strbuf;
9222 break;
Bram Moolenaare4218b92020-08-01 21:11:38 +02009223#endif
Bram Moolenaar90944302020-08-01 20:45:11 +02009224
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02009225#ifdef FEAT_CLIENTSERVER
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009226 case SPEC_CLIENT: // Source of last submitted input
Bram Moolenaareb3593b2006-04-22 22:33:57 +00009227 sprintf((char *)strbuf, PRINTF_HEX_LONG_U,
9228 (long_u)clientWindow);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009229 result = strbuf;
9230 break;
9231#endif
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02009232
Bram Moolenaar9e0f6ec2017-05-16 09:36:54 +02009233 default:
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009234 result = (char_u *)""; // avoid gcc warning
Bram Moolenaar9e0f6ec2017-05-16 09:36:54 +02009235 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009236 }
9237
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009238 resultlen = (int)STRLEN(result); // length of new string
9239 if (src[*usedlen] == '<') // remove the file name extension
Bram Moolenaar071d4272004-06-13 20:20:40 +00009240 {
9241 ++*usedlen;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009242 if ((s = vim_strrchr(result, '.')) != NULL && s >= gettail(result))
Bram Moolenaar071d4272004-06-13 20:20:40 +00009243 resultlen = (int)(s - result);
9244 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00009245 else if (!skip_mod)
9246 {
Bram Moolenaar00136dc2018-07-25 21:19:13 +02009247 valid |= modify_fname(src, tilde_file, usedlen, &result, &resultbuf,
Bram Moolenaar071d4272004-06-13 20:20:40 +00009248 &resultlen);
9249 if (result == NULL)
9250 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009251 *errormsg = "";
Bram Moolenaar071d4272004-06-13 20:20:40 +00009252 return NULL;
9253 }
9254 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00009255 }
9256
9257 if (resultlen == 0 || valid != VALID_HEAD + VALID_PATH)
9258 {
9259 if (valid != VALID_HEAD + VALID_PATH)
Bram Moolenaarb09feaa2022-01-02 20:20:45 +00009260 *errormsg = _(e_empty_file_name_for_percent_or_hash_only_works_with_ph);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009261 else
Bram Moolenaarb09feaa2022-01-02 20:20:45 +00009262 *errormsg = _(e_evaluates_to_an_empty_string);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009263 result = NULL;
9264 }
9265 else
9266 result = vim_strnsave(result, resultlen);
9267 vim_free(resultbuf);
9268 return result;
9269}
9270
9271/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00009272 * Expand the <sfile> string in "arg".
9273 *
9274 * Returns an allocated string, or NULL for any error.
9275 */
9276 char_u *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01009277expand_sfile(char_u *arg)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009278{
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009279 char *errormsg;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009280 int len;
9281 char_u *result;
9282 char_u *newres;
9283 char_u *repl;
9284 int srclen;
9285 char_u *p;
9286
9287 result = vim_strsave(arg);
9288 if (result == NULL)
9289 return NULL;
9290
9291 for (p = result; *p; )
9292 {
9293 if (STRNCMP(p, "<sfile>", 7) != 0)
9294 ++p;
9295 else
9296 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009297 // replace "<sfile>" with the sourced file name, and do ":" stuff
Bram Moolenaar63b92542007-03-27 14:57:09 +00009298 repl = eval_vars(p, result, &srclen, NULL, &errormsg, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009299 if (errormsg != NULL)
9300 {
9301 if (*errormsg)
9302 emsg(errormsg);
9303 vim_free(result);
9304 return NULL;
9305 }
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009306 if (repl == NULL) // no match (cannot happen)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009307 {
9308 p += srclen;
9309 continue;
9310 }
9311 len = (int)STRLEN(result) - srclen + (int)STRLEN(repl) + 1;
9312 newres = alloc(len);
9313 if (newres == NULL)
9314 {
9315 vim_free(repl);
9316 vim_free(result);
9317 return NULL;
9318 }
9319 mch_memmove(newres, result, (size_t)(p - result));
9320 STRCPY(newres + (p - result), repl);
9321 len = (int)STRLEN(newres);
9322 STRCAT(newres, p + srclen);
9323 vim_free(repl);
9324 vim_free(result);
9325 result = newres;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009326 p = newres + len; // continue after the match
Bram Moolenaar071d4272004-06-13 20:20:40 +00009327 }
9328 }
9329
9330 return result;
9331}
Bram Moolenaar071d4272004-06-13 20:20:40 +00009332
Bram Moolenaar071d4272004-06-13 20:20:40 +00009333#if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG) || defined(PROTO)
Bram Moolenaar9c13b352005-05-19 20:53:52 +00009334/*
Bram Moolenaard9462e32011-04-11 21:35:11 +02009335 * Make a dialog message in "buff[DIALOG_MSG_SIZE]".
Bram Moolenaarb765d632005-06-07 21:00:02 +00009336 * "format" must contain "%s".
Bram Moolenaar9c13b352005-05-19 20:53:52 +00009337 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00009338 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01009339dialog_msg(char_u *buff, char *format, char_u *fname)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009340{
Bram Moolenaar071d4272004-06-13 20:20:40 +00009341 if (fname == NULL)
9342 fname = (char_u *)_("Untitled");
Bram Moolenaard9462e32011-04-11 21:35:11 +02009343 vim_snprintf((char *)buff, DIALOG_MSG_SIZE, format, fname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009344}
9345#endif
9346
9347/*
9348 * ":behave {mswin,xterm}"
9349 */
9350 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01009351ex_behave(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009352{
9353 if (STRCMP(eap->arg, "mswin") == 0)
9354 {
9355 set_option_value((char_u *)"selection", 0L, (char_u *)"exclusive", 0);
9356 set_option_value((char_u *)"selectmode", 0L, (char_u *)"mouse,key", 0);
9357 set_option_value((char_u *)"mousemodel", 0L, (char_u *)"popup", 0);
9358 set_option_value((char_u *)"keymodel", 0L,
9359 (char_u *)"startsel,stopsel", 0);
9360 }
9361 else if (STRCMP(eap->arg, "xterm") == 0)
9362 {
9363 set_option_value((char_u *)"selection", 0L, (char_u *)"inclusive", 0);
9364 set_option_value((char_u *)"selectmode", 0L, (char_u *)"", 0);
9365 set_option_value((char_u *)"mousemodel", 0L, (char_u *)"extend", 0);
9366 set_option_value((char_u *)"keymodel", 0L, (char_u *)"", 0);
9367 }
9368 else
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00009369 semsg(_(e_invalid_argument_str), eap->arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009370}
9371
Bram Moolenaar071d4272004-06-13 20:20:40 +00009372static int filetype_detect = FALSE;
9373static int filetype_plugin = FALSE;
9374static int filetype_indent = FALSE;
9375
9376/*
9377 * ":filetype [plugin] [indent] {on,off,detect}"
9378 * on: Load the filetype.vim file to install autocommands for file types.
9379 * off: Load the ftoff.vim file to remove all autocommands for file types.
9380 * plugin on: load filetype.vim and ftplugin.vim
9381 * plugin off: load ftplugof.vim
9382 * indent on: load filetype.vim and indent.vim
9383 * indent off: load indoff.vim
9384 */
9385 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01009386ex_filetype(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009387{
9388 char_u *arg = eap->arg;
9389 int plugin = FALSE;
9390 int indent = FALSE;
9391
9392 if (*eap->arg == NUL)
9393 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009394 // Print current status.
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009395 smsg("filetype detection:%s plugin:%s indent:%s",
Bram Moolenaar071d4272004-06-13 20:20:40 +00009396 filetype_detect ? "ON" : "OFF",
9397 filetype_plugin ? (filetype_detect ? "ON" : "(on)") : "OFF",
9398 filetype_indent ? (filetype_detect ? "ON" : "(on)") : "OFF");
9399 return;
9400 }
9401
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009402 // Accept "plugin" and "indent" in any order.
Bram Moolenaar071d4272004-06-13 20:20:40 +00009403 for (;;)
9404 {
9405 if (STRNCMP(arg, "plugin", 6) == 0)
9406 {
9407 plugin = TRUE;
9408 arg = skipwhite(arg + 6);
9409 continue;
9410 }
9411 if (STRNCMP(arg, "indent", 6) == 0)
9412 {
9413 indent = TRUE;
9414 arg = skipwhite(arg + 6);
9415 continue;
9416 }
9417 break;
9418 }
9419 if (STRCMP(arg, "on") == 0 || STRCMP(arg, "detect") == 0)
9420 {
9421 if (*arg == 'o' || !filetype_detect)
9422 {
Bram Moolenaar7f8989d2016-03-12 22:11:39 +01009423 source_runtime((char_u *)FILETYPE_FILE, DIP_ALL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009424 filetype_detect = TRUE;
9425 if (plugin)
9426 {
Bram Moolenaar7f8989d2016-03-12 22:11:39 +01009427 source_runtime((char_u *)FTPLUGIN_FILE, DIP_ALL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009428 filetype_plugin = TRUE;
9429 }
9430 if (indent)
9431 {
Bram Moolenaar7f8989d2016-03-12 22:11:39 +01009432 source_runtime((char_u *)INDENT_FILE, DIP_ALL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009433 filetype_indent = TRUE;
9434 }
9435 }
9436 if (*arg == 'd')
9437 {
Bram Moolenaar1610d052016-06-09 22:53:01 +02009438 (void)do_doautocmd((char_u *)"filetypedetect BufRead", TRUE, NULL);
Bram Moolenaara3227e22006-03-08 21:32:40 +00009439 do_modelines(0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009440 }
9441 }
9442 else if (STRCMP(arg, "off") == 0)
9443 {
9444 if (plugin || indent)
9445 {
9446 if (plugin)
9447 {
Bram Moolenaar7f8989d2016-03-12 22:11:39 +01009448 source_runtime((char_u *)FTPLUGOF_FILE, DIP_ALL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009449 filetype_plugin = FALSE;
9450 }
9451 if (indent)
9452 {
Bram Moolenaar7f8989d2016-03-12 22:11:39 +01009453 source_runtime((char_u *)INDOFF_FILE, DIP_ALL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009454 filetype_indent = FALSE;
9455 }
9456 }
9457 else
9458 {
Bram Moolenaar7f8989d2016-03-12 22:11:39 +01009459 source_runtime((char_u *)FTOFF_FILE, DIP_ALL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009460 filetype_detect = FALSE;
9461 }
9462 }
9463 else
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00009464 semsg(_(e_invalid_argument_str), arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009465}
9466
9467/*
Bram Moolenaar3e545692017-06-04 19:00:32 +02009468 * ":setfiletype [FALLBACK] {name}"
Bram Moolenaar071d4272004-06-13 20:20:40 +00009469 */
9470 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01009471ex_setfiletype(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009472{
9473 if (!did_filetype)
Bram Moolenaar3e545692017-06-04 19:00:32 +02009474 {
9475 char_u *arg = eap->arg;
9476
9477 if (STRNCMP(arg, "FALLBACK ", 9) == 0)
9478 arg += 9;
9479
9480 set_option_value((char_u *)"filetype", 0L, arg, OPT_LOCAL);
9481 if (arg != eap->arg)
9482 did_filetype = FALSE;
9483 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00009484}
Bram Moolenaar071d4272004-06-13 20:20:40 +00009485
Bram Moolenaar071d4272004-06-13 20:20:40 +00009486 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01009487ex_digraphs(exarg_T *eap UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009488{
9489#ifdef FEAT_DIGRAPHS
9490 if (*eap->arg != NUL)
9491 putdigraph(eap->arg);
9492 else
Bram Moolenaareae8ae12018-12-14 18:53:02 +01009493 listdigraphs(eap->forceit);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009494#else
mityu61065042021-07-19 20:07:21 +02009495 emsg(_(e_no_digraphs_version));
Bram Moolenaar071d4272004-06-13 20:20:40 +00009496#endif
9497}
9498
Bram Moolenaar451fc7b2018-04-27 22:53:07 +02009499#if defined(FEAT_SEARCH_EXTRA) || defined(PROTO)
9500 void
9501set_no_hlsearch(int flag)
9502{
9503 no_hlsearch = flag;
9504# ifdef FEAT_EVAL
9505 set_vim_var_nr(VV_HLSEARCH, !no_hlsearch && p_hls);
9506# endif
9507}
9508
Bram Moolenaar071d4272004-06-13 20:20:40 +00009509/*
9510 * ":nohlsearch"
9511 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00009512 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01009513ex_nohlsearch(exarg_T *eap UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009514{
Bram Moolenaar451fc7b2018-04-27 22:53:07 +02009515 set_no_hlsearch(TRUE);
Bram Moolenaarf71a3db2006-03-12 21:50:18 +00009516 redraw_all_later(SOME_VALID);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009517}
Bram Moolenaar071d4272004-06-13 20:20:40 +00009518#endif
9519
9520#ifdef FEAT_CRYPT
9521/*
9522 * ":X": Get crypt key
9523 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00009524 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01009525ex_X(exarg_T *eap UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009526{
Bram Moolenaar3a0c9082014-11-12 15:15:42 +01009527 crypt_check_current_method();
Bram Moolenaar8f4ac012014-08-10 13:38:34 +02009528 (void)crypt_get_key(TRUE, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009529}
9530#endif
9531
9532#ifdef FEAT_FOLDING
9533 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01009534ex_fold(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009535{
9536 if (foldManualAllowed(TRUE))
9537 foldCreate(eap->line1, eap->line2);
9538}
9539
9540 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01009541ex_foldopen(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009542{
9543 opFoldRange(eap->line1, eap->line2, eap->cmdidx == CMD_foldopen,
9544 eap->forceit, FALSE);
9545}
9546
9547 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01009548ex_folddo(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009549{
9550 linenr_T lnum;
9551
Bram Moolenaar4facea32019-10-12 20:17:40 +02009552# ifdef FEAT_CLIPBOARD
Bram Moolenaar6b1ee342014-08-06 18:17:11 +02009553 start_global_changes();
Bram Moolenaar4facea32019-10-12 20:17:40 +02009554# endif
Bram Moolenaar6b1ee342014-08-06 18:17:11 +02009555
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009556 // First set the marks for all lines closed/open.
Bram Moolenaar071d4272004-06-13 20:20:40 +00009557 for (lnum = eap->line1; lnum <= eap->line2; ++lnum)
9558 if (hasFolding(lnum, NULL, NULL) == (eap->cmdidx == CMD_folddoclosed))
9559 ml_setmarked(lnum);
9560
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009561 // Execute the command on the marked lines.
Bram Moolenaar071d4272004-06-13 20:20:40 +00009562 global_exe(eap->arg);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009563 ml_clearmarked(); // clear rest of the marks
Bram Moolenaar4facea32019-10-12 20:17:40 +02009564# ifdef FEAT_CLIPBOARD
Bram Moolenaar6b1ee342014-08-06 18:17:11 +02009565 end_global_changes();
Bram Moolenaar4facea32019-10-12 20:17:40 +02009566# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00009567}
9568#endif
Bram Moolenaarf5291f32017-09-14 22:55:37 +02009569
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009570#if defined(FEAT_QUICKFIX) || defined(PROTO)
Bram Moolenaar39665952018-08-15 20:59:48 +02009571/*
9572 * Returns TRUE if the supplied Ex cmdidx is for a location list command
9573 * instead of a quickfix command.
9574 */
9575 int
9576is_loclist_cmd(int cmdidx)
9577{
Bram Moolenaar74c8be22018-08-23 22:51:40 +02009578 if (cmdidx < 0 || cmdidx >= CMD_SIZE)
Bram Moolenaar39665952018-08-15 20:59:48 +02009579 return FALSE;
9580 return cmdnames[cmdidx].cmd_name[0] == 'l';
9581}
9582#endif
9583
Bram Moolenaar4facea32019-10-12 20:17:40 +02009584#if defined(FEAT_TIMERS) || defined(PROTO)
Bram Moolenaarf5291f32017-09-14 22:55:37 +02009585 int
9586get_pressedreturn(void)
9587{
9588 return ex_pressedreturn;
9589}
9590
9591 void
9592set_pressedreturn(int val)
9593{
9594 ex_pressedreturn = val;
9595}
9596#endif